diffdoc 0.2.0 → 0.4.0

package/.diffdocrc.example

@@ -8,5 +8,8 @@
   "cloudLlmEndpoint": "https://api.openai.com/v1",
   "cloudChatModel": "gpt-4o-mini",
   "cloudEmbedModel": "text-embedding-3-small",
-  "openaiApiKey": ""
+  "openaiApiKey": "",
+  "includeGlobs": [],
+  "excludeGlobs": [],
+  "ignoreFile": ".diffdocignore"
 }

package/README.md

@@ -2,7 +2,7 @@
 
 ## Project Description
 
-DiffDoc turns source code into searchable, plain-English project context. It scans repository files, asks an OpenAI-compatible chat model to summarize the business behavior in each file, stores those summaries in a portable JSON manifest, embeds the manifest into a local Vectra index, and answers questions using the indexed results as retrieval context.
+DiffDoc turns source code into searchable, plain-English project context. It scans repository files, asks an OpenAI-compatible chat model to summarize the business behavior in each file, stores the summaries as portable per-hash JSON assets, embeds those assets into a local Vectra index, and answers questions using the indexed results as retrieval context.
 
 The project is designed for teams that need fast codebase comprehension without requiring every stakeholder to read implementation details. It can run against local model servers such as Ollama, LM Studio, or vLLM, or against cloud OpenAI-compatible APIs.
 
@@ -34,7 +34,9 @@ Package scripts can call the installed binary:
 ```json
 {
   "scripts": {
+    "diffdoc:init": "diffdoc init",
     "diffdoc:summarize": "diffdoc summarize",
+    "diffdoc:status": "diffdoc status",
     "diffdoc:embed": "diffdoc embed",
     "diffdoc:search": "diffdoc search",
     "diffdoc:query": "diffdoc query",
@@ -72,37 +74,68 @@ Example config with all supported keys:
   "cloudLlmEndpoint": "https://api.openai.com/v1",
   "cloudChatModel": "gpt-4o-mini",
   "cloudEmbedModel": "text-embedding-3-small",
-  "openaiApiKey": ""
+  "openaiApiKey": "",
+  "includeGlobs": [],
+  "excludeGlobs": [],
+  "ignoreFile": ".diffdocignore"
 }
 ```
 
-Supported environment fallbacks use the uppercase names for the same settings, including `AI_PROVIDER`, `DIFFDOC_BASE_DIR`, `LOCAL_LLM_ENDPOINT`, `LOCAL_EMBED_ENDPOINT`, `LOCAL_CHAT_MODEL`, `LOCAL_EMBED_MODEL`, `CLOUD_LLM_ENDPOINT`, `CLOUD_CHAT_MODEL`, `CLOUD_EMBED_MODEL`, and `OPENAI_API_KEY`.
+Supported environment fallbacks use the uppercase names for the same settings, including `AI_PROVIDER`, `DIFFDOC_BASE_DIR`, `LOCAL_LLM_ENDPOINT`, `LOCAL_EMBED_ENDPOINT`, `LOCAL_CHAT_MODEL`, `LOCAL_EMBED_MODEL`, `CLOUD_LLM_ENDPOINT`, `CLOUD_CHAT_MODEL`, `CLOUD_EMBED_MODEL`, `OPENAI_API_KEY`, `DIFFDOC_INCLUDE_GLOBS`, `DIFFDOC_EXCLUDE_GLOBS`, and `DIFFDOC_IGNORE_FILE`.
 
 ## Manifest-First Design
 
-DiffDoc separates summarization from embedding. The `summarize` command writes all generated file summaries to `manifest.json` under `baseDir`, usually `./.diffdoc/manifest.json`.
+DiffDoc separates summarization from embedding. The `summarize` command writes file-to-hash mappings to `manifest.json` and stores each summary in an independent hash-addressed JSON file under `./.diffdoc/summaries/`.
 
 The manifest is plain JSON and contains one entry per tracked file:
 
 ```json
 {
+  "schemaVersion": 2,
   "lastSyncedCommit": "string-hash",
   "files": {
-    "src/example.ts": {
-      "hash": "md5-string",
-      "summaryText": "Plain-English explanation text here.",
-      "rawCodeSnapshot": "Full code text here..."
-    }
+    "src/example.ts": "md5-string"
   }
 }
 ```
 
+Example summary asset at `./.diffdoc/summaries/<hash>.json`:
+
+```json
+{
+  "schemaVersion": 1,
+  "content_hash": "md5-string",
+  "summary": "Plain-English explanation text here.",
+  "raw_code_snapshot": "Optional code text when --include-code-snapshot is enabled"
+}
+```
+
 Because the summaries are stored independently, users do not have to embed immediately. They can review, archive, transform, or embed the manifest later using their preferred vectorization model and storage solution.
 
 DiffDoc includes `diffdoc embed` as a built-in convenience path for creating a local Vectra index, but the manifest can also be consumed by other tools such as custom OpenAI-compatible embedding pipelines, hosted vector databases, local search systems, or internal documentation workflows.
 
 ## Commands
 
+Initialize DiffDoc configuration for a repository:
+
+```bash
+diffdoc init
+```
+
+Use defaults without prompts:
+
+```bash
+diffdoc init --yes
+```
+
+Choose a provider and overwrite an existing config file:
+
+```bash
+diffdoc init --provider cloud --force
+```
+
+`init` creates or updates repo setup files, appends missing `.gitignore` entries, and prints next commands. It does not run `summarize` or `embed`.
+
 Summarize a repository into `./.diffdoc/manifest.json`:
 
 ```bash
@@ -115,12 +148,54 @@ Summarize only changed Git files using the existing manifest state:
 diffdoc summarize --path . --mode delta
 ```
 
+Store raw code snapshots in summary assets:
+
+```bash
+diffdoc summarize --path . --mode all --include-code-snapshot
+```
+
+Add include/exclude filters at runtime:
+
+```bash
+diffdoc summarize --path . --mode all --include-glob "src/**/*.ts" --exclude-glob "**/*.test.ts"
+```
+
+Emit a CI-friendly JSON summarize report:
+
+```bash
+diffdoc summarize --path . --mode delta --json
+```
+
+Inspect manifest-relative artifact freshness:
+
+```bash
+diffdoc status
+```
+
+Use a custom manifest path under `--base-dir`:
+
+```bash
+diffdoc status --manifest manifest.json
+```
+
+Emit CI-friendly JSON output:
+
+```bash
+diffdoc status --json
+```
+
 Embed the manifest into a local Vectra index at `./.diffdoc/vectra`:
 
 ```bash
 diffdoc embed
 ```
 
+Force full index rebuild:
+
+```bash
+diffdoc embed --rebuild
+```
+
 Search the local Vectra index and print raw matches:
 
 ```bash
@@ -145,12 +220,6 @@ Include retrieved code snapshots after the generated answer:
 diffdoc query "How does embedding work?" --top 3 --code
 ```
 
-Prompt the configured chat model directly:
-
-```bash
-diffdoc prompt "Confirm the configured model is reachable."
-```
-
 Use a custom config file:
 
 ```bash
@@ -226,8 +295,14 @@ Run `diffdoc summarize` and `diffdoc embed` before using the MCP server, otherwi
 
 - Node.js `>=22` is required because Vectra requires it.
 - This repository ignores `.diffdoc/vectra` and `.diffdocrc`; add similar entries to your project's `.gitignore` if you do not want generated indexes or local config committed. The manifest at `.diffdoc/manifest.json` is not ignored by this repository.
+- Summary assets are written to `.diffdoc/summaries/*.json`.
+- Manifest schema is currently `schemaVersion: 2`; older manifest shapes are not auto-migrated.
 - Commit `.diffdoc/manifest.json` when using delta workflows. Delta summarization reads the previous manifest state to decide which changed files need fresh summaries.
 - `summarize` requires a configured chat model.
+- `summarize` prints run progress and final totals (`scanned`, `skipped`, `updated`, `failed`, `pruned`).
+- `summarize --json` prints a single machine-readable run report to stdout for CI parsing.
+- `status` does not require a configured chat or embedding model.
+- `status --json` prints a machine-readable report with summary and index freshness details.
 - `embed` requires a configured embedding model.
 - `search` requires a configured embedding model and returns raw retrieval results without calling the chat model.
 - `query` requires both a configured chat model and embedding model.

package/dist/commands/embed.js

@@ -8,56 +8,142 @@ exports.runEmbed = runEmbed;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const vectra_1 = require("vectra");
+const artifacts_1 = require("../types/artifacts");
 const llm_1 = require("../utils/llm");
 const paths_1 = require("../utils/paths");
 const VECTRA_INDEX_DIR = "vectra";
 function getVectraIndexPath(config) {
     return node_path_1.default.resolve((0, paths_1.getDiffdocBaseDir)(config.baseDir), VECTRA_INDEX_DIR);
 }
+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`);
+}
+async function readManifest(manifestPath) {
+    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 : {}
+    };
+}
+async function readSummaryAsset(summaryPath) {
+    const parsed = JSON.parse(await promises_1.default.readFile(summaryPath, "utf8"));
+    if (parsed.schemaVersion !== artifacts_1.SUMMARY_ASSET_SCHEMA_VERSION) {
+        throw new Error(`Unsupported summary schema in ${summaryPath}. Expected schemaVersion ${artifacts_1.SUMMARY_ASSET_SCHEMA_VERSION}.`);
+    }
+    if (typeof parsed.content_hash !== "string") {
+        throw new Error(`Invalid summary hash in ${summaryPath}.`);
+    }
+    if (typeof parsed.summary !== "string") {
+        throw new Error(`Invalid summary text in ${summaryPath}.`);
+    }
+    return {
+        schemaVersion: artifacts_1.SUMMARY_ASSET_SCHEMA_VERSION,
+        content_hash: parsed.content_hash,
+        summary: parsed.summary,
+        raw_code_snapshot: typeof parsed.raw_code_snapshot === "string" ? parsed.raw_code_snapshot : undefined
+    };
+}
 function buildDocument(filePath, summaryText, rawCodeSnapshot) {
-    return `File: ${filePath}\n` +
-        `Summary: ${summaryText}\n\n` +
-        `Code Snapshot:\n\`\`\`\n${rawCodeSnapshot}\n\`\`\``;
+    let output = `File: ${filePath}\nSummary: ${summaryText}`;
+    if (rawCodeSnapshot) {
+        output += `\n\nCode Snapshot:\n\`\`\`\n${rawCodeSnapshot}\n\`\`\``;
+    }
+    return output;
 }
 async function runEmbed(options, config) {
     const manifestPath = (0, paths_1.resolveDiffdocArtifactPath)(options.manifest, config.baseDir);
-    const manifest = JSON.parse(await promises_1.default.readFile(manifestPath, "utf8"));
+    const manifest = await readManifest(manifestPath);
     const entries = Object.entries(manifest.files);
+    const summaryDir = getSummaryDir(manifestPath);
     const indexPath = getVectraIndexPath(config);
     const index = new vectra_1.LocalIndex(indexPath);
-    await index.createIndex({
-        version: 1,
-        deleteIfExists: true,
-        metadata_config: {
-            indexed: ["filePath", "hash"]
+    if (options.rebuild) {
+        await index.createIndex({
+            version: 1,
+            deleteIfExists: true,
+            metadata_config: {
+                indexed: ["filePath", "hash"]
+            }
+        });
+    }
+    else if (!await index.isIndexCreated()) {
+        await index.createIndex({
+            version: 1,
+            deleteIfExists: false,
+            metadata_config: {
+                indexed: ["filePath", "hash"]
+            }
+        });
+    }
+    const existingItems = await index.listItems();
+    const existingByPath = new Map(existingItems.map((item) => [item.id, item]));
+    const toUpsert = [];
+    for (const [filePath, hash] of entries) {
+        const existing = existingByPath.get(filePath);
+        if (existing?.metadata.hash === hash) {
+            continue;
+        }
+        const summaryPath = getSummaryPath(summaryDir, hash);
+        const summaryAsset = await readSummaryAsset(summaryPath);
+        if (summaryAsset.content_hash !== hash) {
+            throw new Error(`Hash mismatch in summary asset ${summaryPath}.`);
         }
-    });
-    if (entries.length === 0) {
-        console.log(`Created empty Vectra index at ${indexPath}.`);
+        toUpsert.push({
+            filePath,
+            hash,
+            summaryText: summaryAsset.summary,
+            rawCodeSnapshot: summaryAsset.raw_code_snapshot,
+            document: buildDocument(filePath, summaryAsset.summary, summaryAsset.raw_code_snapshot)
+        });
+    }
+    const activePathSet = new Set(entries.map(([filePath]) => filePath));
+    const toDelete = existingItems
+        .map((item) => item.id)
+        .filter((id) => Boolean(id) && !activePathSet.has(id));
+    if (toUpsert.length === 0 && toDelete.length === 0) {
+        console.log(`Index is already up to date at ${indexPath}.`);
         return;
     }
-    const documents = entries.map(([filePath, file]) => buildDocument(filePath, file.summaryText, file.rawCodeSnapshot));
-    const embeddings = await (0, llm_1.generateEmbeddings)(documents, config.embeddings);
+    const embeddings = toUpsert.length > 0
+        ? await (0, llm_1.generateEmbeddings)(toUpsert.map((item) => item.document), config.embeddings)
+        : [];
     await index.beginUpdate();
     try {
-        for (let i = 0; i < entries.length; i += 1) {
-            const [filePath, file] = entries[i];
+        for (let i = 0; i < toUpsert.length; i += 1) {
+            const item = toUpsert[i];
+            const metadata = item.rawCodeSnapshot
+                ? {
+                    filePath: item.filePath,
+                    hash: item.hash,
+                    summaryText: item.summaryText,
+                    rawCodeSnapshot: item.rawCodeSnapshot
+                }
+                : {
+                    filePath: item.filePath,
+                    hash: item.hash,
+                    summaryText: item.summaryText
+                };
             await index.upsertItem({
-                id: filePath,
+                id: item.filePath,
                 vector: embeddings[i],
-                metadata: {
-                    filePath,
-                    hash: file.hash,
-                    summaryText: file.summaryText,
-                    rawCodeSnapshot: file.rawCodeSnapshot
-                }
+                metadata
             });
         }
+        for (const itemId of toDelete) {
+            await index.deleteItem(itemId);
+        }
         await index.endUpdate();
     }
     catch (error) {
         index.cancelUpdate();
         throw error;
     }
-    console.log(`Embedded ${entries.length} summaries into Vectra index at ${indexPath}.`);
+    console.log(`Embedded ${toUpsert.length} summaries and pruned ${toDelete.length} items in ${indexPath}.`);
 }

package/dist/commands/init.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const promises_2 = require("node:readline/promises");
+const node_process_1 = require("node:process");
+const DEFAULT_CONFIG = {
+    baseDir: "./.diffdoc",
+    aiProvider: "local",
+    localLlmEndpoint: "http://localhost:11434/v1",
+    localEmbedEndpoint: "http://localhost:11434/v1/embeddings",
+    localChatModel: "qwen2.5-coder:7b",
+    localEmbedModel: "nomic-embed-code",
+    cloudLlmEndpoint: "https://api.openai.com/v1",
+    cloudChatModel: "gpt-4o-mini",
+    cloudEmbedModel: "text-embedding-3-small",
+    openaiApiKey: "",
+    includeGlobs: [],
+    excludeGlobs: [],
+    ignoreFile: ".diffdocignore"
+};
+function parseProvider(value, fallback) {
+    const provider = value || fallback;
+    if (provider !== "local" && provider !== "cloud") {
+        throw new Error('Invalid init provider. Expected "local" or "cloud".');
+    }
+    return provider;
+}
+function parseCsv(value) {
+    return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function toDisplayPath(filePath) {
+    return filePath.split(node_path_1.default.sep).join("/");
+}
+function resolveRepoPath(filePath) {
+    return node_path_1.default.resolve(process.cwd(), filePath);
+}
+function relativeToRepo(absolutePath) {
+    const relative = node_path_1.default.relative(process.cwd(), absolutePath) || ".";
+    return toDisplayPath(relative);
+}
+function normalizeRepoPattern(value) {
+    return toDisplayPath(value.trim())
+        .replace(/^\.\//, "")
+        .replace(/\/+/g, "/")
+        .replace(/\/$/, "");
+}
+async function fileExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readExistingConfig(configPath) {
+    try {
+        const parsed = JSON.parse(await promises_1.default.readFile(configPath, "utf8"));
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code === "ENOENT") {
+            return {};
+        }
+        throw error;
+    }
+}
+async function promptText(rl, question, fallback) {
+    const suffix = fallback ? ` (${fallback})` : "";
+    const answer = (await rl.question(`${question}${suffix}: `)).trim();
+    return answer || fallback;
+}
+async function promptBoolean(rl, question, fallback) {
+    const suffix = fallback ? "Y/n" : "y/N";
+    const answer = (await rl.question(`${question} (${suffix}): `)).trim().toLowerCase();
+    if (!answer)
+        return fallback;
+    return answer === "y" || answer === "yes";
+}
+async function buildInteractiveConfig(options, existing) {
+    const rl = (0, promises_2.createInterface)({ input: node_process_1.stdin, output: node_process_1.stdout });
+    try {
+        const fallbackProvider = parseProvider(existing.aiProvider, "local");
+        const provider = parseProvider(options.provider || await promptText(rl, "AI provider: local or cloud", fallbackProvider), fallbackProvider);
+        const baseDir = options.baseDir || await promptText(rl, "DiffDoc artifact directory", existing.baseDir || DEFAULT_CONFIG.baseDir);
+        const ignoreFile = await promptText(rl, "Ignore file path", existing.ignoreFile || DEFAULT_CONFIG.ignoreFile);
+        const includeGlobs = parseCsv(await promptText(rl, "Include globs, comma-separated", (existing.includeGlobs || []).join(",")));
+        const excludeGlobs = parseCsv(await promptText(rl, "Exclude globs, comma-separated", (existing.excludeGlobs || []).join(",")));
+        const config = {
+            ...DEFAULT_CONFIG,
+            ...existing,
+            baseDir,
+            aiProvider: provider,
+            ignoreFile,
+            includeGlobs,
+            excludeGlobs
+        };
+        if (provider === "local") {
+            config.localLlmEndpoint = await promptText(rl, "Local chat endpoint", config.localLlmEndpoint || DEFAULT_CONFIG.localLlmEndpoint);
+            config.localChatModel = await promptText(rl, "Local chat model", config.localChatModel || DEFAULT_CONFIG.localChatModel);
+            config.localEmbedEndpoint = await promptText(rl, "Local embedding endpoint", config.localEmbedEndpoint || DEFAULT_CONFIG.localEmbedEndpoint);
+            config.localEmbedModel = await promptText(rl, "Local embedding model", config.localEmbedModel || DEFAULT_CONFIG.localEmbedModel);
+        }
+        else {
+            config.cloudLlmEndpoint = await promptText(rl, "Cloud OpenAI-compatible endpoint", config.cloudLlmEndpoint || DEFAULT_CONFIG.cloudLlmEndpoint);
+            config.cloudChatModel = await promptText(rl, "Cloud chat model", config.cloudChatModel || DEFAULT_CONFIG.cloudChatModel);
+            config.cloudEmbedModel = await promptText(rl, "Cloud embedding model", config.cloudEmbedModel || DEFAULT_CONFIG.cloudEmbedModel);
+            if (await promptBoolean(rl, "Store OPENAI_API_KEY in config file", false)) {
+                config.openaiApiKey = await promptText(rl, "OpenAI-compatible API key", config.openaiApiKey || "");
+            }
+            else {
+                config.openaiApiKey = "";
+            }
+        }
+        return config;
+    }
+    finally {
+        rl.close();
+    }
+}
+function buildYesConfig(options, existing) {
+    return {
+        ...DEFAULT_CONFIG,
+        ...existing,
+        baseDir: options.baseDir || existing.baseDir || DEFAULT_CONFIG.baseDir,
+        aiProvider: parseProvider(options.provider || existing.aiProvider, "local"),
+        openaiApiKey: ""
+    };
+}
+async function writeJsonFile(filePath, value, summary, force) {
+    const exists = await fileExists(filePath);
+    if (exists && !force) {
+        summary.skipped.push(relativeToRepo(filePath));
+        summary.warnings.push(`${relativeToRepo(filePath)} already exists; pass --force to overwrite.`);
+        return;
+    }
+    await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+    await promises_1.default.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    (exists ? summary.updated : summary.created).push(relativeToRepo(filePath));
+}
+function buildStarterIgnore(baseDir) {
+    const normalizedBaseDir = normalizeRepoPattern(baseDir);
+    return [
+        "# DiffDoc ignore patterns",
+        "node_modules/**",
+        ".git/**",
+        `${normalizedBaseDir}/**`,
+        "dist/**",
+        ""
+    ].join("\n");
+}
+async function createIgnoreFile(ignorePath, config, summary) {
+    if (await fileExists(ignorePath)) {
+        summary.skipped.push(relativeToRepo(ignorePath));
+        return;
+    }
+    await promises_1.default.writeFile(ignorePath, buildStarterIgnore(config.baseDir), "utf8");
+    summary.created.push(relativeToRepo(ignorePath));
+}
+function buildGitignoreEntries(configPath, config) {
+    const configRelative = normalizeRepoPattern(relativeToRepo(configPath));
+    const baseDir = normalizeRepoPattern(config.baseDir);
+    return [`${baseDir}/vectra/`, configRelative];
+}
+async function updateGitignore(configPath, config, summary) {
+    const gitignorePath = resolveRepoPath(".gitignore");
+    const entries = buildGitignoreEntries(configPath, config);
+    let existing = "";
+    let exists = false;
+    try {
+        existing = await promises_1.default.readFile(gitignorePath, "utf8");
+        exists = true;
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code !== "ENOENT")
+            throw error;
+    }
+    const existingLines = new Set(existing.split(/\r?\n/).map(normalizeRepoPattern).filter(Boolean));
+    const missing = entries.filter((entry) => !existingLines.has(normalizeRepoPattern(entry)));
+    if (missing.length === 0) {
+        summary.skipped.push(".gitignore");
+        return;
+    }
+    const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
+    await promises_1.default.writeFile(gitignorePath, `${existing}${prefix}${missing.join("\n")}\n`, "utf8");
+    (exists ? summary.updated : summary.created).push(".gitignore");
+}
+function printList(label, values) {
+    console.log(`${label}: ${values.length > 0 ? values.join(", ") : "none"}`);
+}
+async function runInit(options) {
+    const summary = { created: [], updated: [], skipped: [], warnings: [] };
+    const configPath = resolveRepoPath(options.config || ".diffdocrc");
+    const existingConfig = await readExistingConfig(configPath);
+    const config = options.yes
+        ? buildYesConfig(options, existingConfig)
+        : await buildInteractiveConfig(options, existingConfig);
+    const ignorePath = resolveRepoPath(config.ignoreFile || ".diffdocignore");
+    await writeJsonFile(configPath, config, summary, options.force);
+    await createIgnoreFile(ignorePath, config, summary);
+    await updateGitignore(configPath, config, summary);
+    console.log("DiffDoc init complete.");
+    console.log("");
+    console.log("Init changes:");
+    printList("Created", summary.created);
+    printList("Updated", summary.updated);
+    printList("Skipped", summary.skipped);
+    printList("Warnings", summary.warnings);
+    console.log("");
+    console.log("Next commands:");
+    console.log("1. diffdoc summarize --path . --mode all");
+    console.log("2. diffdoc embed");
+    console.log("3. diffdoc status");
+}

package/dist/commands/query.js

@@ -25,7 +25,7 @@ async function runQuery(message, options, config) {
         console.log((0, retrieval_1.trimForDisplay)(result.summaryText, 1200));
         if (options.code) {
             console.log("Code Snapshot:");
-            console.log((0, retrieval_1.trimForDisplay)(result.rawCodeSnapshot, 2000));
+            console.log((0, retrieval_1.trimForDisplay)(result.rawCodeSnapshot || "(not stored)", 2000));
         }
     }
 }
@@ -44,7 +44,7 @@ async function runSearch(message, options, config) {
         console.log((0, retrieval_1.trimForDisplay)(result.summaryText, 1200));
         if (options.code) {
             console.log("Code Snapshot:");
-            console.log((0, retrieval_1.trimForDisplay)(result.rawCodeSnapshot, 2000));
+            console.log((0, retrieval_1.trimForDisplay)(result.rawCodeSnapshot || "(not stored)", 2000));
         }
     }
 }