EasyAI repo scnner and documentation updated

Author: gcclinux

README.md

@@ -19,6 +19,7 @@ From simple notes to complex technical documentation, Easyeditor has you covered
 *   **Export Power**: Export to **PNG**, **TXT**, **PDF**, **MD** and secure **SSTP Encryption**.
 *   **Customizable**: Choose from beautiful themes or create your own!
 *   **SSTP Encryption**: SSTP (Simple Security Text Protocol) protection using modern AES-256-CBC encryption!
+*   **EasyAI Personas**: Built-in AI personas for documentation, diagrams, code fixes, and more — with full repo scanning that reads your project file-by-file to generate accurate, context-aware documentation.
 
 [![Infographic](https://img.shields.io/badge/📊_Infographic-View_PDF-orange?style=for-the-badge)](docs/Easyeditor-Infographic.pdf)
 
@@ -127,6 +128,15 @@ Seamlessly manage your version control without leaving the editor.
 
 <a><img src="screenshots/git_feature.png" alt="Git Feature" width="720" height="400"></a>
 
+### 🤖 EasyAI Personas
+Multiple AI personas for documentation, diagrams, code fixes, user stories, and more. The Documentation persona scans your entire Git repository file-by-file to produce accurate, project-specific documentation.
+
+<a><img src="screenshots/easyai-new-feature-many-personas.png" alt="EasyAI Personas" width="720" height="400"></a>
+
+**Repo Scanning for Documentation:**
+
+<a><img src="screenshots/easyai-scanning-repo-ofr-documentation.png" alt="EasyAI Repo Scanning" width="720" height="400"></a>
+
 ### 📝 Table Support
 Clean and responsive table rendering.
 

screenshots/easyai-new-feature-many-personas.png

@@ -103,6 +103,8 @@ import EasyNotesSidebar from './components/EasyNotesSidebar';
 import EasyAIPanel from './components/EasyAIPanel';
 import { buildSystemPrompt, parseFixTarget, extractBlock, extractTable } from './components/easyai/aiPersonas';
 import { queryEasyAI } from './components/easyai/aiService';
+import { scanRepository } from './components/easyai/repoScanner';
+import { generateDocumentation } from './components/easyai/docGenerator';
 import FeaturesModal from './components/FeaturesModal';
 import ThemeModal from './components/ThemeModal';
 import ImportThemeModal from './components/ImportThemeModal';
@@ -256,6 +258,16 @@ const App = () => {
   const [pendingCredentialAction, setPendingCredentialAction] = useState<(() => void) | null>(null);
   const [prefillCredentials, setPrefillCredentials] = useState<{ username: string; token: string } | null>(null);
   const [currentDirHandle, setCurrentDirHandle] = useState<any>(null); // For web File System Access API
+
+  // Repo scan progress state
+  const [scanProgress, setScanProgress] = useState<{
+    isScanning: boolean;
+    currentFile: string;
+    filesProcessed: number;
+    totalFiles: number;
+  }>({ isScanning: false, currentFile: '', filesProcessed: 0, totalFiles: 0 });
+  const scanAbortControllerRef = useRef<AbortController | null>(null);
+
   const [confirmModalConfig, setConfirmModalConfig] = useState<{
     open: boolean;
     title: string;
@@ -3220,11 +3232,170 @@ const App = () => {
           )
         }
 
+        {scanProgress.isScanning && (
+          <div style={{
+            position: 'fixed',
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0,
+            backgroundColor: 'rgba(0, 0, 0, 0.5)',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+            zIndex: 10000,
+          }}>
+            <div style={{
+              background: 'var(--bg-color, #1e1e1e)',
+              color: 'var(--text-color, #ccc)',
+              borderRadius: '8px',
+              padding: '24px 32px',
+              minWidth: '360px',
+              maxWidth: '480px',
+              boxShadow: '0 4px 24px rgba(0,0,0,0.4)',
+            }}>
+              <h3 style={{ margin: '0 0 16px 0', fontSize: '16px' }}>Scanning Repository…</h3>
+              <div style={{
+                background: 'var(--border-color, #333)',
+                borderRadius: '4px',
+                height: '8px',
+                overflow: 'hidden',
+                marginBottom: '12px',
+              }}>
+                <div style={{
+                  background: 'var(--accent-color, #007acc)',
+                  height: '100%',
+                  width: `${scanProgress.totalFiles > 0 ? (scanProgress.filesProcessed / scanProgress.totalFiles) * 100 : 0}%`,
+                  transition: 'width 0.3s ease',
+                  borderRadius: '4px',
+                }} />
+              </div>
+              <div style={{ fontSize: '13px', marginBottom: '8px' }}>
+                {scanProgress.filesProcessed} / {scanProgress.totalFiles} files
+              </div>
+              <div style={{
+                fontSize: '12px',
+                color: 'var(--text-muted, #888)',
+                marginBottom: '16px',
+                overflow: 'hidden',
+                textOverflow: 'ellipsis',
+                whiteSpace: 'nowrap',
+              }}>
+                {scanProgress.currentFile || 'Preparing…'}
+              </div>
+              <button
+                onClick={() => scanAbortControllerRef.current?.abort()}
+                style={{
+                  background: 'var(--danger-color, #d32f2f)',
+                  color: '#fff',
+                  border: 'none',
+                  borderRadius: '4px',
+                  padding: '6px 18px',
+                  cursor: 'pointer',
+                  fontSize: '13px',
+                }}
+              >
+                Cancel
+              </button>
+            </div>
+          </div>
+        )}
+
         <EasyAIPanel
           showEasyAIPanel={showEasyAIPanel}
           setShowEasyAIPanel={setShowEasyAIPanel}
           showToast={showToast}
           onActionSelect={async (actionId, promptText) => {
+            // ── Documentation persona with repo scanning ──
+            if (actionId === 'documentation') {
+              const isTauri = !!(window as any).__TAURI_INTERNALS__;
+              console.log('[EasyAI-Doc] Documentation action triggered');
+              console.log('[EasyAI-Doc] isTauri:', isTauri);
+              console.log('[EasyAI-Doc] currentRepoPath:', currentRepoPath);
+              console.log('[EasyAI-Doc] currentDirHandle:', currentDirHandle);
+              console.log('[EasyAI-Doc] isGitRepo state:', isGitRepo);
+
+              // Tauri uses file paths; web uses FileSystemDirectoryHandle
+              const hasTauriRepo = isTauri && currentRepoPath;
+              const hasWebRepo = !isTauri && currentDirHandle;
+
+              if (!hasTauriRepo && !hasWebRepo) {
+                console.warn('[EasyAI-Doc] No repository available — aborting');
+                showToast('No Git repository loaded. Please open a repository first via EasyGit.', 'warning');
+                return;
+              }
+
+              const controller = new AbortController();
+              scanAbortControllerRef.current = controller;
+
+              setScanProgress({ isScanning: true, currentFile: '', filesProcessed: 0, totalFiles: 0 });
+              setShowEasyAIPanel(false);
+
+              try {
+                let scanResult;
+
+                if (hasTauriRepo) {
+                  console.log('[EasyAI-Doc] Using Tauri scanner for path:', currentRepoPath);
+                  const { scanRepositoryTauri } = await import('./components/easyai/tauriRepoScanner');
+                  scanResult = await scanRepositoryTauri({
+                    repoPath: currentRepoPath!,
+                    userPrompt: promptText,
+                    onProgress: (current, total, filePath) => {
+                      setScanProgress({ isScanning: true, currentFile: filePath, filesProcessed: current, totalFiles: total });
+                    },
+                    signal: controller.signal,
+                  });
+                } else {
+                  console.log('[EasyAI-Doc] Using web scanner with dirHandle:', currentDirHandle.name);
+                  scanResult = await scanRepository({
+                    dirHandle: currentDirHandle,
+                    userPrompt: promptText,
+                    onProgress: (current, total, filePath) => {
+                      setScanProgress({ isScanning: true, currentFile: filePath, filesProcessed: current, totalFiles: total });
+                    },
+                    signal: controller.signal,
+                  });
+                }
+
+                if (scanResult.cancelled) {
+                  showToast('Scan cancelled.', 'info');
+                  setScanProgress({ isScanning: false, currentFile: '', filesProcessed: 0, totalFiles: 0 });
+                  return;
+                }
+
+                if (scanResult.cache.size <= 1) {
+                  showToast('No scannable files found in the repository.', 'warning');
+                  setScanProgress({ isScanning: false, currentFile: '', filesProcessed: 0, totalFiles: 0 });
+                  return;
+                }
+
+                // Log scan results for debugging
+                console.log(`[RepoScanner] Cache contains ${scanResult.cache.size - 1} file summaries`);
+
+                setScanProgress(prev => ({ ...prev, currentFile: 'Generating documentation…' }));
+                const doc = await generateDocumentation({
+                  cache: scanResult.cache,
+                  userPrompt: promptText,
+                  signal: controller.signal,
+                });
+
+                if (doc) {
+                  setEditorContent(doc + '\n');
+                  showToast('EasyAI (documentation) — documentation generated.', 'success');
+                } else {
+                  showToast('EasyAI (documentation) — empty response.', 'warning');
+                }
+              } catch (err: any) {
+                const msg = err.message || 'Scan failed';
+                console.error('[EasyAI-Doc] Scan error:', msg, err);
+                showToast(msg, 'error');
+              } finally {
+                setScanProgress({ isScanning: false, currentFile: '', filesProcessed: 0, totalFiles: 0 });
+                scanAbortControllerRef.current = null;
+              }
+              return;
+            }
+
             const systemPrompt = buildSystemPrompt(actionId, editorContent, promptText);
             if (!systemPrompt) {
               showToast(`Unknown EasyAI action: ${actionId}`, 'error');

screenshots/easyai-scanning-repo-ofr-documentation.png

@@ -0,0 +1,151 @@
+/**
+ * Property-based tests for CacheStore
+ * Feature: documentation-persona-repo-scanner, Property 3: CacheStore round-trip
+ *
+ * **Validates: Requirements 3.3, 3.4**
+ *
+ * Property 3: For any valid SummaryRecord (with non-empty filePath, fileType,
+ * and summary), adding it to the CacheStore and then retrieving it by filePath
+ * shall return a record with identical filePath, fileType, and summary values.
+ */
+
+import * as fc from 'fast-check';
+import { CacheStore, SummaryRecord } from '../cacheStore';
+
+/** Generate a safe path segment (alphanumeric + underscore/hyphen). */
+const safeSegment = fc
+  .array(fc.constantFrom(...'abcdefghijklmnopqrstuvwxyz0123456789_-'.split('')), {
+    minLength: 1,
+    maxLength: 10,
+  })
+  .map((chars) => chars.join(''));
+
+/** Generate a non-empty relative file path like "src/utils/helper.ts". */
+const nonEmptyFilePath = fc
+  .tuple(
+    fc.array(safeSegment, { minLength: 1, maxLength: 4 }),
+    safeSegment,
+    fc.constantFrom('.ts', '.js', '.md', '.json', '.txt', '.py', '.rs', '.go'),
+  )
+  .map(([dirs, name, ext]) => [...dirs, `${name}${ext}`].join('/'));
+
+/** Generate a non-empty file type string. */
+const nonEmptyFileType = fc.constantFrom(
+  'typescript', 'javascript', 'markdown', 'json', 'python', 'rust', 'go', 'text',
+);
+
+/** Generate a non-empty summary string. */
+const nonEmptySummary = fc
+  .string({ minLength: 1, maxLength: 200 })
+  .filter((s) => s.trim().length > 0);
+
+/** Generate a valid SummaryRecord with non-empty fields. */
+const summaryRecordArb: fc.Arbitrary<SummaryRecord> = fc
+  .tuple(nonEmptyFilePath, nonEmptyFileType, nonEmptySummary)
+  .map(([filePath, fileType, summary]) => ({ filePath, fileType, summary }));
+
+// Feature: documentation-persona-repo-scanner, Property 3: CacheStore round-trip
+describe('Property 3: CacheStore round-trip', () => {
+  // **Validates: Requirements 3.3, 3.4**
+  // Adding a record and retrieving by filePath returns identical values
+  it('round-trips any valid SummaryRecord through add and getByPath', () => {
+    fc.assert(
+      fc.property(summaryRecordArb, (record) => {
+        const store = new CacheStore();
+        store.add(record);
+        const retrieved = store.getByPath(record.filePath);
+        expect(retrieved).toBeDefined();
+        expect(retrieved!.filePath).toBe(record.filePath);
+        expect(retrieved!.fileType).toBe(record.fileType);
+        expect(retrieved!.summary).toBe(record.summary);
+      }),
+      { numRuns: 100 },
+    );
+  });
+
+  // **Validates: Requirements 3.3, 3.4**
+  // Adding multiple distinct records and retrieving each returns the correct record
+  it('round-trips multiple distinct SummaryRecords', () => {
+    fc.assert(
+      fc.property(
+        fc.array(summaryRecordArb, { minLength: 1, maxLength: 20 }),
+        (records) => {
+          const store = new CacheStore();
+          // Deduplicate by filePath — last one wins (matches overwrite semantics)
+          const expected = new Map<string, SummaryRecord>();
+          for (const r of records) {
+            store.add(r);
+            expected.set(r.filePath, r);
+          }
+
+          expect(store.size).toBe(expected.size);
+
+          for (const [path, rec] of expected) {
+            const retrieved = store.getByPath(path);
+            expect(retrieved).toBeDefined();
+            expect(retrieved!.filePath).toBe(rec.filePath);
+            expect(retrieved!.fileType).toBe(rec.fileType);
+            expect(retrieved!.summary).toBe(rec.summary);
+          }
+        },
+      ),
+      { numRuns: 100 },
+    );
+  });
+
+  // **Validates: Requirements 3.3, 3.4**
+  // Duplicate filePath additions overwrite the previous record
+  it('overwrites previous record when adding duplicate filePath', () => {
+    fc.assert(
+      fc.property(
+        nonEmptyFilePath,
+        nonEmptyFileType,
+        nonEmptySummary,
+        nonEmptyFileType,
+        nonEmptySummary,
+        (filePath, type1, summary1, type2, summary2) => {
+          const store = new CacheStore();
+          store.add({ filePath, fileType: type1, summary: summary1 });
+          store.add({ filePath, fileType: type2, summary: summary2 });
+
+          expect(store.size).toBe(1);
+          const retrieved = store.getByPath(filePath);
+          expect(retrieved).toBeDefined();
+          expect(retrieved!.fileType).toBe(type2);
+          expect(retrieved!.summary).toBe(summary2);
+        },
+      ),
+      { numRuns: 100 },
+    );
+  });
+
+  // **Validates: Requirements 3.3, 3.4**
+  // getAll returns all added records and they match what was added
+  it('getAll returns all stored records with correct values', () => {
+    fc.assert(
+      fc.property(
+        fc.array(summaryRecordArb, { minLength: 1, maxLength: 20 }),
+        (records) => {
+          const store = new CacheStore();
+          const expected = new Map<string, SummaryRecord>();
+          for (const r of records) {
+            store.add(r);
+            expected.set(r.filePath, r);
+          }
+
+          const all = store.getAll();
+          expect(all.length).toBe(expected.size);
+
+          for (const rec of all) {
+            const exp = expected.get(rec.filePath);
+            expect(exp).toBeDefined();
+            expect(rec.filePath).toBe(exp!.filePath);
+            expect(rec.fileType).toBe(exp!.fileType);
+            expect(rec.summary).toBe(exp!.summary);
+          }
+        },
+      ),
+      { numRuns: 100 },
+    );
+  });
+});