diffdoc 0.2.0 → 0.4.0

package/dist/commands/status.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStatus = runStatus;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const vectra_1 = require("vectra");
+const embed_1 = require("./embed");
+const artifacts_1 = require("../types/artifacts");
+const paths_1 = require("../utils/paths");
+function getSummaryDir(manifestPath) {
+    return node_path_1.default.resolve(node_path_1.default.dirname(manifestPath), "summaries");
+}
+async function readManifest(manifestPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await promises_1.default.readFile(manifestPath, "utf8"));
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code === "ENOENT") {
+            throw new Error(`Manifest not found: ${manifestPath}. Run \"diffdoc summarize\" first.`);
+        }
+        throw error;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`Invalid manifest JSON in ${manifestPath}. Expected an object.`);
+    }
+    const manifest = parsed;
+    if (manifest.schemaVersion !== artifacts_1.MANIFEST_SCHEMA_VERSION) {
+        throw new Error(`Unsupported manifest schema in ${manifestPath}. Expected schemaVersion ${artifacts_1.MANIFEST_SCHEMA_VERSION}.`);
+    }
+    return {
+        schemaVersion: artifacts_1.MANIFEST_SCHEMA_VERSION,
+        lastSyncedCommit: typeof manifest.lastSyncedCommit === "string" ? manifest.lastSyncedCommit : "",
+        files: manifest.files && typeof manifest.files === "object" ? manifest.files : {}
+    };
+}
+async function getSummaryStats(manifestPath, manifest) {
+    const summaryDir = getSummaryDir(manifestPath);
+    let entries = [];
+    try {
+        entries = await promises_1.default.readdir(summaryDir);
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    const summaryHashes = new Set(entries.filter((entry) => entry.endsWith(".json")).map((entry) => entry.slice(0, -5)));
+    const manifestHashes = new Set(Object.values(manifest.files));
+    let orphanCount = 0;
+    for (const hash of summaryHashes) {
+        if (!manifestHashes.has(hash)) {
+            orphanCount += 1;
+        }
+    }
+    let missingFromManifestCount = 0;
+    for (const hash of manifestHashes) {
+        if (!summaryHashes.has(hash)) {
+            missingFromManifestCount += 1;
+        }
+    }
+    return {
+        summaryFileCount: summaryHashes.size,
+        orphanCount,
+        missingFromManifestCount
+    };
+}
+async function getIndexFreshness(manifest, config) {
+    const indexPath = (0, embed_1.getVectraIndexPath)(config);
+    const index = new vectra_1.LocalIndex(indexPath);
+    const exists = await index.isIndexCreated();
+    if (!exists) {
+        return {
+            status: "missing",
+            missing: 0,
+            mismatched: 0,
+            extra: 0
+        };
+    }
+    const items = await index.listItems();
+    const indexHashesByPath = new Map();
+    for (const item of items) {
+        if (!item.id || typeof item.id !== "string") {
+            continue;
+        }
+        const hash = item.metadata && typeof item.metadata.hash === "string"
+            ? item.metadata.hash
+            : "";
+        indexHashesByPath.set(item.id, hash);
+    }
+    let missing = 0;
+    let mismatched = 0;
+    for (const [filePath, manifestHash] of Object.entries(manifest.files)) {
+        const indexedHash = indexHashesByPath.get(filePath);
+        if (indexedHash === undefined) {
+            missing += 1;
+            continue;
+        }
+        if (indexedHash !== manifestHash) {
+            mismatched += 1;
+        }
+    }
+    const manifestPathSet = new Set(Object.keys(manifest.files));
+    let extra = 0;
+    for (const filePath of indexHashesByPath.keys()) {
+        if (!manifestPathSet.has(filePath)) {
+            extra += 1;
+        }
+    }
+    return {
+        status: missing === 0 && mismatched === 0 && extra === 0 ? "fresh" : "stale",
+        missing,
+        mismatched,
+        extra
+    };
+}
+function formatSummaryFreshness(stats) {
+    if (stats.missingFromManifestCount === 0) {
+        return "fresh";
+    }
+    return `stale (missing: ${stats.missingFromManifestCount})`;
+}
+function buildStatusReport(manifest, summaryStats, indexFreshness) {
+    return {
+        manifestSchema: manifest.schemaVersion,
+        trackedFileCount: Object.keys(manifest.files).length,
+        summaryFileCount: summaryStats.summaryFileCount,
+        orphanCount: summaryStats.orphanCount,
+        summaryFreshness: {
+            status: summaryStats.missingFromManifestCount === 0 ? "fresh" : "stale",
+            missing: summaryStats.missingFromManifestCount
+        },
+        indexFreshness
+    };
+}
+function formatIndexFreshness(freshness) {
+    if (freshness.status === "missing") {
+        return "missing";
+    }
+    if (freshness.status === "fresh") {
+        return "fresh";
+    }
+    return `stale (missing: ${freshness.missing}, mismatched: ${freshness.mismatched}, extra: ${freshness.extra})`;
+}
+async function runStatus(options, config) {
+    const manifestPath = (0, paths_1.resolveDiffdocArtifactPath)(options.manifest, config.baseDir);
+    const manifest = await readManifest(manifestPath);
+    const summaryStats = await getSummaryStats(manifestPath, manifest);
+    const indexFreshness = await getIndexFreshness(manifest, config);
+    const report = buildStatusReport(manifest, summaryStats, indexFreshness);
+    if (options.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    console.log(`manifest schema: ${report.manifestSchema}`);
+    console.log(`tracked files: ${report.trackedFileCount}`);
+    console.log(`summary files: ${report.summaryFileCount}`);
+    console.log(`orphans: ${report.orphanCount}`);
+    console.log(`summary freshness: ${formatSummaryFreshness(summaryStats)}`);
+    console.log(`index freshness: ${formatIndexFreshness(indexFreshness)}`);
+}

package/dist/commands/summarize.js

@@ -6,108 +6,432 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSummarize = runSummarize;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
+const artifacts_1 = require("../types/artifacts");
 const git_1 = require("../utils/git");
 const hashing_1 = require("../utils/hashing");
 const llm_1 = require("../utils/llm");
 const paths_1 = require("../utils/paths");
-const TARGET_EXTENSIONS = new Set([".ts", ".js", ".cs", ".py"]);
-const IGNORED_DIRECTORIES = new Set([".git", "node_modules", "dist"]);
-const IGNORED_FILES = new Set(["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb"]);
 function normalizeRelativePath(filePath) {
     return filePath.split(node_path_1.default.sep).join("/");
 }
-function isTargetCodeFile(filePath) {
-    return TARGET_EXTENSIONS.has(node_path_1.default.extname(filePath)) && !IGNORED_FILES.has(node_path_1.default.basename(filePath));
+function getSummaryDir(manifestPath) {
+    return node_path_1.default.resolve(node_path_1.default.dirname(manifestPath), "summaries");
+}
+function getSummaryPath(summaryDir, hash) {
+    return node_path_1.default.resolve(summaryDir, `${hash}.json`);
+}
+function normalizeGlobPattern(pattern) {
+    return pattern.split(node_path_1.default.sep).join("/");
+}
+function escapeRegex(value) {
+    return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function globToRegExp(pattern) {
+    const normalized = normalizeGlobPattern(pattern);
+    let regexBody = "";
+    for (let i = 0; i < normalized.length; i += 1) {
+        const char = normalized[i];
+        const next = normalized[i + 1];
+        if (char === "*" && next === "*") {
+            regexBody += ".*";
+            i += 1;
+            continue;
+        }
+        if (char === "*") {
+            regexBody += "[^/]*";
+            continue;
+        }
+        if (char === "?") {
+            regexBody += "[^/]";
+            continue;
+        }
+        regexBody += escapeRegex(char);
+    }
+    return new RegExp(`^${regexBody}$`);
+}
+function compileGlobs(patterns) {
+    return patterns.filter(Boolean).map(globToRegExp);
+}
+function matchesAny(filePath, patterns) {
+    return patterns.some((pattern) => pattern.test(filePath));
+}
+function shouldIncludeFile(filePath, includeGlobs, excludeGlobs, ignoreGlobs) {
+    if (includeGlobs.length > 0 && !matchesAny(filePath, includeGlobs)) {
+        return false;
+    }
+    if (excludeGlobs.length > 0 && matchesAny(filePath, excludeGlobs)) {
+        return false;
+    }
+    if (ignoreGlobs.length > 0 && matchesAny(filePath, ignoreGlobs)) {
+        return false;
+    }
+    return true;
+}
+async function fileExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function atomicWriteUtf8(targetPath, content) {
+    await promises_1.default.mkdir(node_path_1.default.dirname(targetPath), { recursive: true });
+    const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+    const handle = await promises_1.default.open(tempPath, "w");
+    try {
+        await handle.writeFile(content, "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    await promises_1.default.rename(tempPath, targetPath);
+}
+async function writeManifest(manifestPath, manifest) {
+    await atomicWriteUtf8(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+async function writeSummaryAsset(summaryPath, summary) {
+    await atomicWriteUtf8(summaryPath, `${JSON.stringify(summary, null, 2)}\n`);
 }
 async function readManifest(manifestPath) {
     try {
-        return JSON.parse(await promises_1.default.readFile(manifestPath, "utf8"));
+        const parsed = JSON.parse(await promises_1.default.readFile(manifestPath, "utf8"));
+        if (parsed.schemaVersion !== artifacts_1.MANIFEST_SCHEMA_VERSION) {
+            throw new Error(`Unsupported manifest schema in ${manifestPath}. Expected schemaVersion ${artifacts_1.MANIFEST_SCHEMA_VERSION}.`);
+        }
+        return {
+            schemaVersion: artifacts_1.MANIFEST_SCHEMA_VERSION,
+            lastSyncedCommit: typeof parsed.lastSyncedCommit === "string" ? parsed.lastSyncedCommit : "",
+            files: parsed.files && typeof parsed.files === "object" ? parsed.files : {}
+        };
     }
     catch (error) {
         const nodeError = error;
         if (nodeError.code === "ENOENT") {
-            return { lastSyncedCommit: "", files: {} };
+            return {
+                schemaVersion: artifacts_1.MANIFEST_SCHEMA_VERSION,
+                lastSyncedCommit: "",
+                files: {}
+            };
         }
         throw error;
     }
 }
-async function writeManifest(manifestPath, manifest) {
-    await promises_1.default.mkdir(node_path_1.default.dirname(manifestPath), { recursive: true });
-    await promises_1.default.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+async function readIgnorePatterns(repoPath, ignoreFilePath) {
+    const absolutePath = node_path_1.default.isAbsolute(ignoreFilePath)
+        ? ignoreFilePath
+        : node_path_1.default.resolve(repoPath, ignoreFilePath);
+    try {
+        const raw = await promises_1.default.readFile(absolutePath, "utf8");
+        return raw
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && !line.startsWith("#"))
+            .map(normalizeGlobPattern);
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
 }
-async function walkCodeFiles(rootPath, currentPath = rootPath) {
+async function walkCodeFiles(rootPath, includeGlobs, excludeGlobs, ignoreGlobs, currentPath = rootPath) {
     const entries = await promises_1.default.readdir(currentPath, { withFileTypes: true });
     const files = [];
     for (const entry of entries) {
         const entryPath = node_path_1.default.join(currentPath, entry.name);
         if (entry.isDirectory()) {
-            if (!IGNORED_DIRECTORIES.has(entry.name)) {
-                files.push(...await walkCodeFiles(rootPath, entryPath));
-            }
+            files.push(...await walkCodeFiles(rootPath, includeGlobs, excludeGlobs, ignoreGlobs, entryPath));
             continue;
         }
-        if (entry.isFile() && isTargetCodeFile(entry.name)) {
-            files.push(normalizeRelativePath(node_path_1.default.relative(rootPath, entryPath)));
+        if (entry.isFile()) {
+            const relativePath = normalizeRelativePath(node_path_1.default.relative(rootPath, entryPath));
+            if (shouldIncludeFile(relativePath, includeGlobs, excludeGlobs, ignoreGlobs)) {
+                files.push(relativePath);
+            }
         }
     }
     return files.sort();
 }
-async function summarizeFile(rootPath, relativePath, config) {
-    const absolutePath = node_path_1.default.join(rootPath, relativePath);
-    const rawCodeSnapshot = await promises_1.default.readFile(absolutePath, "utf8");
-    return {
-        hash: (0, hashing_1.hashFileContent)(rawCodeSnapshot),
-        summaryText: await (0, llm_1.generateFunctionalSummary)(relativePath, rawCodeSnapshot, config.chat),
-        rawCodeSnapshot
+function countHashRefs(files) {
+    const refs = new Map();
+    for (const hash of Object.values(files)) {
+        refs.set(hash, (refs.get(hash) || 0) + 1);
+    }
+    return refs;
+}
+async function deleteSummaryIfUnreferenced(summaryDir, hash, refs) {
+    if ((refs.get(hash) || 0) > 0) {
+        return;
+    }
+    const summaryPath = getSummaryPath(summaryDir, hash);
+    try {
+        await promises_1.default.unlink(summaryPath);
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code !== "ENOENT") {
+            throw error;
+        }
+    }
+}
+async function setManifestPathHash(filePath, newHash, manifest, manifestPath, summaryDir, refs) {
+    const previousHash = manifest.files[filePath];
+    if (previousHash === newHash) {
+        return false;
+    }
+    if (previousHash) {
+        refs.set(previousHash, Math.max((refs.get(previousHash) || 1) - 1, 0));
+    }
+    manifest.files[filePath] = newHash;
+    refs.set(newHash, (refs.get(newHash) || 0) + 1);
+    await writeManifest(manifestPath, manifest);
+    if (previousHash) {
+        await deleteSummaryIfUnreferenced(summaryDir, previousHash, refs);
+    }
+    return true;
+}
+async function removeManifestPath(filePath, manifest, manifestPath, summaryDir, refs) {
+    const previousHash = manifest.files[filePath];
+    if (!previousHash) {
+        return false;
+    }
+    delete manifest.files[filePath];
+    refs.set(previousHash, Math.max((refs.get(previousHash) || 1) - 1, 0));
+    await writeManifest(manifestPath, manifest);
+    await deleteSummaryIfUnreferenced(summaryDir, previousHash, refs);
+    return true;
+}
+async function ensureSummaryAsset(summaryDir, hash, summaryText, rawCodeSnapshot, includeCodeSnapshot) {
+    const summaryPath = getSummaryPath(summaryDir, hash);
+    if (await fileExists(summaryPath)) {
+        return;
+    }
+    const summary = {
+        schemaVersion: artifacts_1.SUMMARY_ASSET_SCHEMA_VERSION,
+        content_hash: hash,
+        summary: summaryText,
+        raw_code_snapshot: includeCodeSnapshot ? rawCodeSnapshot : undefined
     };
+    await writeSummaryAsset(summaryPath, summary);
+}
+async function pruneOrphanedSummaries(summaryDir, manifest) {
+    const activeHashes = new Set(Object.values(manifest.files));
+    let entries = [];
+    try {
+        entries = await promises_1.default.readdir(summaryDir);
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code === "ENOENT") {
+            return;
+        }
+        throw error;
+    }
+    for (const entry of entries) {
+        if (!entry.endsWith(".json")) {
+            continue;
+        }
+        const hash = entry.slice(0, -5);
+        if (activeHashes.has(hash)) {
+            continue;
+        }
+        await promises_1.default.unlink(node_path_1.default.resolve(summaryDir, entry));
+    }
 }
 async function runSummarize(options, config) {
     if (options.mode !== "all" && options.mode !== "delta") {
         throw new Error('Invalid summarize mode. Expected "all" or "delta".');
     }
+    const startedAt = new Date();
     const commandCwd = process.cwd();
     const repoPath = node_path_1.default.resolve(commandCwd, options.path);
     const manifestPath = (0, paths_1.resolveDiffdocArtifactPath)(options.out, config.baseDir);
-    const manifest = options.mode === "delta" ? await readManifest(manifestPath) : { lastSyncedCommit: "", files: {} };
+    const summaryDir = getSummaryDir(manifestPath);
+    const manifest = await readManifest(manifestPath);
+    const refs = countHashRefs(manifest.files);
+    const includePatterns = compileGlobs((options.includeGlobs && options.includeGlobs.length > 0)
+        ? options.includeGlobs.map(normalizeGlobPattern)
+        : config.summarize.includeGlobs.map(normalizeGlobPattern));
+    const excludePatterns = compileGlobs((options.excludeGlobs && options.excludeGlobs.length > 0)
+        ? options.excludeGlobs.map(normalizeGlobPattern)
+        : config.summarize.excludeGlobs.map(normalizeGlobPattern));
+    const ignoreFile = options.ignoreFile || config.summarize.ignoreFile;
+    const ignorePatterns = compileGlobs(await readIgnorePatterns(repoPath, ignoreFile));
+    const totals = { scanned: 0, skipped: 0, updated: 0, failed: 0, pruned: 0 };
+    const failures = [];
+    const isJson = options.json;
+    if (!isJson) {
+        console.log(`Starting summarize run`);
+        console.log(`Mode: ${options.mode}`);
+        console.log(`Repo: ${repoPath}`);
+        console.log(`Manifest: ${manifestPath}`);
+        console.log(`Summaries: ${summaryDir}`);
+        console.log("---");
+    }
     if (options.mode === "all") {
-        const files = await walkCodeFiles(repoPath);
         manifest.files = {};
-        for (const filePath of files) {
-            manifest.files[filePath] = await summarizeFile(repoPath, filePath, config);
-            console.log(`Summarized ${filePath}`);
+        refs.clear();
+        await writeManifest(manifestPath, manifest);
+        const files = await walkCodeFiles(repoPath, includePatterns, excludePatterns, ignorePatterns);
+        const totalFiles = files.length;
+        if (!isJson) {
+            console.log(`Candidates: ${totalFiles}`);
+        }
+        for (let i = 0; i < files.length; i += 1) {
+            const filePath = files[i];
+            totals.scanned += 1;
+            try {
+                const absolutePath = node_path_1.default.join(repoPath, filePath);
+                const rawCodeSnapshot = await promises_1.default.readFile(absolutePath, "utf8");
+                const hash = (0, hashing_1.hashFileContent)(rawCodeSnapshot);
+                const summaryPath = getSummaryPath(summaryDir, hash);
+                if (!await fileExists(summaryPath)) {
+                    const summaryText = await (0, llm_1.generateFunctionalSummary)(filePath, rawCodeSnapshot, config.chat);
+                    await ensureSummaryAsset(summaryDir, hash, summaryText, rawCodeSnapshot, options.includeCodeSnapshot);
+                }
+                manifest.files[filePath] = hash;
+                refs.set(hash, (refs.get(hash) || 0) + 1);
+                await writeManifest(manifestPath, manifest);
+                totals.updated += 1;
+                if (!isJson) {
+                    console.log(`[${i + 1}/${totalFiles}] summarized ${filePath}`);
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                failures.push({ filePath, message });
+                totals.failed += 1;
+                if (!isJson) {
+                    console.error(`[${i + 1}/${totalFiles}] failed ${filePath}: ${message}`);
+                }
+            }
         }
     }
     else {
         const deltas = await (0, git_1.getGitDeltas)(repoPath, manifest.lastSyncedCommit);
+        const totalCandidates = deltas.modifiedOrAdded.length + deltas.deleted.length;
+        if (!isJson) {
+            console.log(`Candidates: ${totalCandidates} (${deltas.modifiedOrAdded.length} modified/added, ${deltas.deleted.length} deleted)`);
+        }
         for (const deletedPath of deltas.deleted) {
-            delete manifest.files[deletedPath];
-            console.log(`Pruned ${deletedPath}`);
+            const removed = await removeManifestPath(deletedPath, manifest, manifestPath, summaryDir, refs);
+            if (removed) {
+                totals.pruned += 1;
+            }
+            if (!isJson) {
+                console.log(`pruned ${deletedPath}`);
+            }
         }
-        for (const filePath of deltas.modifiedOrAdded) {
-            const absolutePath = node_path_1.default.join(repoPath, filePath);
+        for (let i = 0; i < deltas.modifiedOrAdded.length; i += 1) {
+            const filePath = deltas.modifiedOrAdded[i];
+            totals.scanned += 1;
             try {
+                if (!shouldIncludeFile(filePath, includePatterns, excludePatterns, ignorePatterns)) {
+                    const removed = await removeManifestPath(filePath, manifest, manifestPath, summaryDir, refs);
+                    if (removed) {
+                        totals.pruned += 1;
+                    }
+                    else {
+                        totals.skipped += 1;
+                    }
+                    if (!isJson) {
+                        console.log(`[${i + 1}/${deltas.modifiedOrAdded.length}] excluded ${filePath}`);
+                    }
+                    continue;
+                }
+                const previousHash = manifest.files[filePath];
+                const absolutePath = node_path_1.default.join(repoPath, filePath);
                 const rawCodeSnapshot = await promises_1.default.readFile(absolutePath, "utf8");
                 const hash = (0, hashing_1.hashFileContent)(rawCodeSnapshot);
-                if (manifest.files[filePath]?.hash === hash)
+                if (previousHash === hash) {
+                    totals.skipped += 1;
+                    if (!isJson) {
+                        console.log(`[${i + 1}/${deltas.modifiedOrAdded.length}] unchanged ${filePath}`);
+                    }
                     continue;
-                manifest.files[filePath] = {
-                    hash,
-                    summaryText: await (0, llm_1.generateFunctionalSummary)(filePath, rawCodeSnapshot, config.chat),
-                    rawCodeSnapshot
-                };
-                console.log(`Updated ${filePath}`);
+                }
+                const summaryPath = getSummaryPath(summaryDir, hash);
+                if (!await fileExists(summaryPath)) {
+                    const summaryText = await (0, llm_1.generateFunctionalSummary)(filePath, rawCodeSnapshot, config.chat);
+                    await ensureSummaryAsset(summaryDir, hash, summaryText, rawCodeSnapshot, options.includeCodeSnapshot);
+                }
+                const changed = await setManifestPathHash(filePath, hash, manifest, manifestPath, summaryDir, refs);
+                if (changed) {
+                    totals.updated += 1;
+                }
+                else {
+                    totals.skipped += 1;
+                }
+                if (!isJson) {
+                    console.log(`[${i + 1}/${deltas.modifiedOrAdded.length}] updated ${filePath}`);
+                }
             }
             catch (error) {
                 const nodeError = error;
                 if (nodeError.code === "ENOENT") {
-                    delete manifest.files[filePath];
+                    const removed = await removeManifestPath(filePath, manifest, manifestPath, summaryDir, refs);
+                    if (removed) {
+                        totals.pruned += 1;
+                    }
+                    else {
+                        totals.skipped += 1;
+                    }
+                    if (!isJson) {
+                        console.log(`[${i + 1}/${deltas.modifiedOrAdded.length}] missing ${filePath}`);
+                    }
                     continue;
                 }
-                throw error;
+                const message = error instanceof Error ? error.message : String(error);
+                failures.push({ filePath, message });
+                totals.failed += 1;
+                if (!isJson) {
+                    console.error(`[${i + 1}/${deltas.modifiedOrAdded.length}] failed ${filePath}: ${message}`);
+                }
             }
         }
     }
     manifest.lastSyncedCommit = await (0, git_1.getCurrentCommit)(repoPath);
     await writeManifest(manifestPath, manifest);
-    console.log(`Wrote manifest to ${manifestPath}`);
+    await pruneOrphanedSummaries(summaryDir, manifest);
+    const finishedAt = new Date();
+    const durationMs = finishedAt.getTime() - startedAt.getTime();
+    const report = {
+        mode: options.mode,
+        repoPath,
+        manifestPath,
+        summaryDir,
+        startedAt: startedAt.toISOString(),
+        finishedAt: finishedAt.toISOString(),
+        durationMs,
+        totals,
+        failures
+    };
+    if (isJson) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log("---");
+        console.log(`Summarize complete`);
+        console.log(`Scanned: ${totals.scanned}`);
+        console.log(`Updated: ${totals.updated}`);
+        console.log(`Skipped: ${totals.skipped}`);
+        console.log(`Pruned: ${totals.pruned}`);
+        console.log(`Failed: ${totals.failed}`);
+        console.log(`Duration: ${(durationMs / 1000).toFixed(2)}s`);
+        console.log(`Manifest: ${manifestPath}`);
+    }
+    if (failures.length > 0) {
+        if (!isJson) {
+            console.error(`\n${failures.length} file(s) failed during summarization:`);
+            for (const failure of failures) {
+                console.error(`- ${failure.filePath}: ${failure.message}`);
+            }
+        }
+        throw new Error("Summarization completed with failures.");
+    }
 }

package/dist/config.js

@@ -9,6 +9,22 @@ const node_path_1 = __importDefault(require("node:path"));
 function readOption(value, envName, fallback = "") {
     return value || process.env[envName] || fallback;
 }
+function parseCsv(value) {
+    return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function readListOption(value, envName, fallback = []) {
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => parseCsv(item)).filter(Boolean);
+    }
+    if (typeof value === "string" && value.trim()) {
+        return parseCsv(value);
+    }
+    const envValue = process.env[envName];
+    if (envValue && envValue.trim()) {
+        return parseCsv(envValue);
+    }
+    return fallback;
+}
 function loadRcFile(configPath) {
     const resolvedPath = node_path_1.default.resolve(process.cwd(), configPath || ".diffdocrc");
     if (!node_fs_1.default.existsSync(resolvedPath)) {
@@ -41,6 +57,9 @@ function buildRuntimeConfig(options, needs = { chat: true, embeddings: true }) {
     const mergedOptions = mergeConfigOptions(options);
     const provider = readProvider(mergedOptions.aiProvider);
     const apiKey = readOption(mergedOptions.openaiApiKey, "OPENAI_API_KEY", provider === "local" ? "local-key" : "");
+    const includeGlobs = readListOption(mergedOptions.includeGlobs, "DIFFDOC_INCLUDE_GLOBS");
+    const excludeGlobs = readListOption(mergedOptions.excludeGlobs, "DIFFDOC_EXCLUDE_GLOBS");
+    const ignoreFile = readOption(mergedOptions.ignoreFile, "DIFFDOC_IGNORE_FILE", ".diffdocignore");
     const chatBaseURL = provider === "cloud"
         ? readOption(mergedOptions.cloudLlmEndpoint, "CLOUD_LLM_ENDPOINT", "https://api.openai.com/v1")
         : readOption(mergedOptions.localLlmEndpoint, "LOCAL_LLM_ENDPOINT");
@@ -80,6 +99,11 @@ function buildRuntimeConfig(options, needs = { chat: true, embeddings: true }) {
             apiKey,
             baseURL: embedBaseURL,
             model: embedModel
+        },
+        summarize: {
+            includeGlobs,
+            excludeGlobs,
+            ignoreFile
         }
     };
 }