aidimag 1.0.0

package/dist/cli/commands/verify.js

@@ -0,0 +1,136 @@
+/**
+ * Verification & guardrail commands: verify, check, brief.
+ */
+import { MemoryStore, findRepoRoot } from "../../db/store.js";
+import { verifyAll } from "../../verify/engine.js";
+import { fail, autoSync, maybeRegenerateContext, createPrompter } from "../shared.js";
+export function registerVerifyCommands(program) {
+    program
+        .command("verify")
+        .description("Re-run evidence and update memory statuses (cheap tier; --deep adds tests/exec)")
+        .option("-i, --id <ids...>", "Only verify specific memory ids (prefix ok)")
+        .option("-d, --deep", "Also run expensive evidence (TEST_RESULT, EXEC_TRACE)")
+        .option("--trust", "Review evidence commands that arrived via team sync and approve them to run on this machine")
+        .option("-q, --quiet", "Only print status changes (for git hooks)")
+        .action(async (opts) => {
+        const root = findRepoRoot() ?? fail("not inside a repo");
+        const store = MemoryStore.open(root);
+        if (opts.trust) {
+            const pending = store.untrustedEvidence();
+            if (!pending.length) {
+                console.log("No untrusted evidence — everything runnable was authored or approved on this machine.");
+            }
+            else {
+                console.log(`${pending.length} synced-in evidence command(s) are NOT yet approved to execute here:\n`);
+                for (const u of pending) {
+                    console.log(`  [${u.type}] ${u.payload}`);
+                    console.log(`      for: "${u.claim.slice(0, 90)}"\n`);
+                }
+                const { ask, close } = await createPrompter("n");
+                const ans = (await ask("Approve ALL of the above to run on this machine? [y/N] ")).trim().toLowerCase();
+                close();
+                if (ans === "y" || ans === "yes") {
+                    console.log(`✓ approved ${store.trustAllEvidence()} command(s). They'll run on the next verify.`);
+                }
+                else {
+                    console.log("Nothing approved — they stay skipped during verification.");
+                }
+            }
+        }
+        const report = verifyAll(store, root, { ids: opts.id, deep: Boolean(opts.deep) });
+        for (const r of report.results) {
+            const changed = r.after !== r.before || r.decayed;
+            if (opts.quiet && !changed)
+                continue;
+            const arrow = r.after !== r.before ? `${r.before} → ${r.after}` : r.after;
+            const icon = r.after === "VERIFIED" ? "✓" : r.after === "STALE" ? "~" : "?";
+            const decayNote = r.decayed ? " (decayed)" : "";
+            console.log(`${icon} [${arrow}] conf ${r.confidenceBefore.toFixed(2)}→${r.confidenceAfter.toFixed(2)}${decayNote}  ${r.claim.slice(0, 90)}`);
+            for (const o of r.outcomes) {
+                if (opts.quiet && o.result !== "FAIL")
+                    continue;
+                console.log(`    ${o.type}: ${o.result} (${o.detail})`);
+            }
+        }
+        if (opts.quiet) {
+            // hook mode: machine-stable output — only speak when something went stale
+            if (report.stale > 0) {
+                console.log(`\nchecked ${report.checked}: ${report.verified} verified, ${report.stale} stale, ${report.decayed} decayed, ${report.unchanged} unchanged`);
+            }
+        }
+        else if (report.checked === 0) {
+            console.log("Nothing to verify yet — store something with `dim remember` first.");
+        }
+        else if (report.stale > 0) {
+            console.log(`\n⚠ ${report.stale} memor${report.stale === 1 ? "y" : "ies"} went stale — the code changed under ${report.stale === 1 ? "it" : "them"}. ` +
+                `Stale memories are down-ranked in recall until they recover.\n` +
+                `(checked ${report.checked}: ${report.verified} verified, ${report.stale} stale, ${report.decayed} decayed, ${report.unchanged} unchanged)`);
+        }
+        else {
+            console.log(`\n✓ All good — ${report.verified} verified, ${report.unchanged} unchanged${report.decayed ? `, ${report.decayed} aging (decayed)` : ""} of ${report.checked} checked.`);
+        }
+        await autoSync(store);
+        // keep generated context in sync when a status actually flipped
+        if (report.results.some((r) => r.after !== r.before))
+            await maybeRegenerateContext(store);
+        store.close();
+        if (report.stale > 0)
+            process.exitCode = 2; // signal staleness to scripts
+    });
+    program
+        .command("check")
+        .description("Pre-commit contradiction check: scan the staged diff against active memories and guardrails")
+        .option("-r, --ref <ref>", "Diff against a ref instead of the staged index (e.g. HEAD~1)")
+        .option("--block", "Exit 1 when a hard violation is found (default: warn only)")
+        .option("--pre-commit", "Run in hook mode: behavior follows preCommitCheck in .aidimag/config.json (no-op if unset)", false)
+        .action(async (opts) => {
+        const root = findRepoRoot() ?? fail("not inside a git repo");
+        let block = Boolean(opts.block);
+        if (opts.preCommit) {
+            const { readConfig } = await import("../../config.js");
+            const mode = readConfig(root).preCommitCheck;
+            if (!mode)
+                return; // hook installed but feature disabled — silent no-op
+            block = mode === "block";
+        }
+        const store = MemoryStore.open(root);
+        const { checkDiff } = await import("../../verify/check.js");
+        const report = checkDiff(store, root, { ref: opts.ref });
+        store.close();
+        if (report.changedFiles.length === 0) {
+            if (!opts.preCommit)
+                console.log("dim check: no changes to check.");
+            return;
+        }
+        const fails = report.violations.filter((v) => v.severity === "fail");
+        const warns = report.violations.filter((v) => v.severity === "warn");
+        if (report.violations.length === 0) {
+            if (!opts.preCommit) {
+                console.log(`✓ dim check: ${report.checked} memorie(s) considered across ${report.changedFiles.length} file(s) — no conflicts.`);
+            }
+            return;
+        }
+        for (const v of fails) {
+            console.error(`✗ [${v.memory.kind}] ${v.detail}\n    "${v.memory.claim}"`);
+        }
+        for (const v of warns) {
+            console.error(`~ [${v.memory.kind}] ${v.detail}\n    "${v.memory.claim}"`);
+        }
+        if (fails.length && block) {
+            console.error(`\ndim check: ${fails.length} blocking violation(s). Resolve them or commit with --no-verify.`);
+            process.exit(1);
+        }
+    });
+    program
+        .command("brief")
+        .description("Print a session-start briefing: in-scope memory, guardrails, stale warnings, and questions to ask")
+        .action(async () => {
+        const root = findRepoRoot() ?? fail("not inside a git repo");
+        const store = MemoryStore.open(root);
+        const { buildSessionBriefing, renderBriefing } = await import("../../capture/session-briefing.js");
+        const briefing = buildSessionBriefing(store, root);
+        process.stdout.write(renderBriefing(briefing));
+        store.close();
+    });
+}
+//# sourceMappingURL=verify.js.map

package/dist/cli/index.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * dim — the aidimag CLI.
+ *
+ * Thin entry point: builds the commander program and delegates to the command
+ * modules in ./commands/ (one file per domain):
+ *
+ *   memory.ts     init, remember, recall, reindex, status, log, gaps,
+ *                 refute, pin, unpin, forget
+ *   capture.ts    mine (commits/PRs), bootstrap, harvest, review, proposals gc
+ *   verify.ts     verify, check, brief
+ *   sync.ts       serve, cloud, login, logout, sync, keys
+ *   tickets.ts    ticket, branch, branch-check
+ *   knowledge.ts  knowledge sync | status | list | watch
+ *   hosts.ts      ui, generate-context, mcp
+ *
+ * Shared helpers (printers, prompter, auto-sync, fail) live in ../shared.ts.
+ */
+export {};

package/dist/cli/index.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+/**
+ * dim — the aidimag CLI.
+ *
+ * Thin entry point: builds the commander program and delegates to the command
+ * modules in ./commands/ (one file per domain):
+ *
+ *   memory.ts     init, remember, recall, reindex, status, log, gaps,
+ *                 refute, pin, unpin, forget
+ *   capture.ts    mine (commits/PRs), bootstrap, harvest, review, proposals gc
+ *   verify.ts     verify, check, brief
+ *   sync.ts       serve, cloud, login, logout, sync, keys
+ *   tickets.ts    ticket, branch, branch-check
+ *   knowledge.ts  knowledge sync | status | list | watch
+ *   hosts.ts      ui, generate-context, mcp
+ *
+ * Shared helpers (printers, prompter, auto-sync, fail) live in ../shared.ts.
+ */
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { fail } from "./shared.js";
+import { registerMemoryCommands } from "./commands/memory.js";
+import { registerCaptureCommands } from "./commands/capture.js";
+import { registerVerifyCommands } from "./commands/verify.js";
+import { registerSyncCommands } from "./commands/sync.js";
+import { registerTicketCommands } from "./commands/tickets.js";
+import { registerKnowledgeCommands } from "./commands/knowledge.js";
+import { registerHostCommands } from "./commands/hosts.js";
+/** Version comes from package.json — single source of truth. */
+const PKG_VERSION = JSON.parse(readFileSync(path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../package.json"), "utf8")).version;
+const program = new Command();
+program
+    .name("dim")
+    .description("aidimag — persistent, verified memory for AI coding agents")
+    .version(PKG_VERSION, "-v, --version", "print the aidimag version");
+registerMemoryCommands(program);
+registerCaptureCommands(program);
+registerVerifyCommands(program);
+registerSyncCommands(program);
+registerTicketCommands(program);
+registerKnowledgeCommands(program);
+registerHostCommands(program);
+program.parseAsync().catch((err) => fail(err instanceof Error ? err.message : String(err)));
+//# sourceMappingURL=index.js.map

package/dist/cli/shared.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared CLI helpers — used by every command module in src/cli/commands/.
+ *
+ * Nothing here registers commands; it's the common vocabulary: fail-fast
+ * error exit, printers for memories/proposals/ingest reports, the
+ * line-buffering prompter, best-effort auto-sync and context regeneration.
+ */
+import { MemoryStore } from "../db/store.js";
+import type { GuardrailLevel, MemoryEntry, MemoryKind, Proposal } from "../types.js";
+export declare const KINDS: MemoryKind[];
+export declare const GUARDRAIL_LEVELS: GuardrailLevel[];
+export declare const GUARDRAIL_ICON: Record<GuardrailLevel, string>;
+export declare function fail(msg: string): never;
+/** Debounced best-effort sync after local mutations (no-op unless cloud-linked). */
+export declare function autoSync(store: MemoryStore): Promise<void>;
+/**
+ * Regenerate the static context file(s) after a memory-set change, but only when
+ * the repo opted in via `generateContext.auto` in .aidimag/config.json. Keeps
+ * CLAUDE.md / .cursorrules / copilot-instructions in lock-step with verified
+ * memory so non-MCP tools never read a stale spec. Best-effort: never throws.
+ */
+export declare function maybeRegenerateContext(store: MemoryStore): Promise<void>;
+export declare function printMemory(m: MemoryEntry, verbose?: boolean): void;
+export declare function printProposal(p: Proposal): void;
+/** Human-readable summary of a knowledge-inbox ingest run. */
+export declare function printIngestReport(report: import("../knowledge/ingest.js").IngestReport): void;
+/**
+ * Line-buffering prompt for interactive flows (review, ticket connect).
+ * Unlike readline/promises, lines arriving between questions (piped input)
+ * are queued, not dropped — so scripted/agent-driven input works too.
+ */
+export declare function createPrompter(closedValue?: string): Promise<{
+    ask: (prompt: string) => Promise<string>;
+    close: () => void;
+}>;
+/** Open a URL in the default browser, best-effort (matches `dim login` / `dim ui`). */
+export declare function openBrowser(url: string): Promise<void>;

package/dist/cli/shared.js

@@ -0,0 +1,175 @@
+/**
+ * Shared CLI helpers — used by every command module in src/cli/commands/.
+ *
+ * Nothing here registers commands; it's the common vocabulary: fail-fast
+ * error exit, printers for memories/proposals/ingest reports, the
+ * line-buffering prompter, best-effort auto-sync and context regeneration.
+ */
+import { findRepoRoot } from "../db/store.js";
+import { debugLog } from "../debug.js";
+export const KINDS = [
+    "DECISION", "CONVENTION", "GOTCHA", "FAILED_APPROACH",
+    "ARCHITECTURE", "INVARIANT", "TODO_CONTEXT", "GUARDRAIL", "SKILL",
+];
+export const GUARDRAIL_LEVELS = ["never", "always", "ask-first"];
+export const GUARDRAIL_ICON = { never: "🚫", always: "✅", "ask-first": "🤚" };
+export function fail(msg) {
+    console.error(`dim: ${msg}`);
+    process.exit(1);
+}
+/** Debounced best-effort sync after local mutations (no-op unless cloud-linked). */
+export async function autoSync(store) {
+    const root = findRepoRoot();
+    if (!root)
+        return;
+    const { maybeAutoSync } = await import("../sync/client.js");
+    const r = await maybeAutoSync(store, root);
+    if (r)
+        console.log(`(auto-synced: sent ${r.memoriesPushed} memories, pulled ${r.pulled}, events ${r.eventsPushed})`);
+}
+/**
+ * Regenerate the static context file(s) after a memory-set change, but only when
+ * the repo opted in via `generateContext.auto` in .aidimag/config.json. Keeps
+ * CLAUDE.md / .cursorrules / copilot-instructions in lock-step with verified
+ * memory so non-MCP tools never read a stale spec. Best-effort: never throws.
+ */
+export async function maybeRegenerateContext(store) {
+    const root = findRepoRoot();
+    if (!root)
+        return;
+    try {
+        const { readConfig } = await import("../config.js");
+        const cfg = readConfig(root).generateContext;
+        if (!cfg?.auto)
+            return;
+        const { generateContext } = await import("../context/generate.js");
+        const r = generateContext(store, root, cfg.format ?? "claude");
+        console.log(`(regenerated ${r.files.join(", ")} — ${r.total} memories)`);
+    }
+    catch (err) {
+        // context regen is advisory; failures must not break the command
+        debugLog("context regeneration", err);
+    }
+}
+export function printMemory(m, verbose = false) {
+    const statusIcon = m.status === "VERIFIED" ? "✓" : m.status === "REFUTED" ? "✗" : m.status === "STALE" ? "~" : "?";
+    const guard = m.kind === "GUARDRAIL" && m.guardrailLevel
+        ? ` ${GUARDRAIL_ICON[m.guardrailLevel]} ${m.guardrailLevel.toUpperCase()}`
+        : "";
+    console.log(`${statusIcon} ${m.pinned ? "📌 " : ""}[${m.kind}${guard}] ${m.claim}`);
+    const scope = [...m.scope.paths, ...m.scope.symbols];
+    console.log(`    id=${m.id.slice(0, 8)} status=${m.status} conf=${m.confidence.toFixed(2)}` +
+        (m.pinned ? " pinned" : "") +
+        (scope.length ? ` scope=${scope.join(",")}` : ""));
+    if (verbose && m.grounding.length) {
+        for (const e of m.grounding) {
+            console.log(`    evidence: ${e.type}(${e.result}) ${e.payload}`);
+        }
+    }
+}
+export function printProposal(p) {
+    console.log(`◆ [${p.id.slice(0, 8)}] ${p.kind} (via ${p.source}${p.sourceRef ? ` @ ${p.sourceRef.slice(0, 8)}` : ""})`);
+    console.log(`    ${p.claim}`);
+    if (p.paths.length || p.symbols.length) {
+        console.log(`    scope: ${[...p.paths, ...p.symbols].join(", ")}`);
+    }
+    if (p.evidence.length) {
+        console.log(`    evidence: ${p.evidence.map((e) => `${e.type}:${e.payload}`).join("  ")}`);
+    }
+    if (p.ticketRef)
+        console.log(`    ticket: ${p.ticketRef}`);
+    if (p.rationale)
+        console.log(`    rationale: ${p.rationale}`);
+}
+/** Human-readable summary of a knowledge-inbox ingest run. */
+export function printIngestReport(report) {
+    if (report.processed.length) {
+        const claims = report.processed.reduce((n, d) => n + d.claimCount, 0);
+        const pinned = report.processed.filter((d) => d.pinned).length;
+        console.log(`📚 Processed ${report.processed.length} doc(s) → ${claims} claim(s) ` +
+            (pinned ? `(${pinned} auto-pinned)` : "queued as proposals — review with `dim review`") +
+            (report.summarizer ? `  ·  via ${report.summarizer}` : ""));
+        for (const d of report.processed) {
+            console.log(`   • ${d.file}: ${d.claimCount} claim(s)${d.pinned ? " (pinned)" : ""}`);
+        }
+    }
+    if (report.duplicates.length) {
+        console.log(`↩︎  ${report.duplicates.length} unchanged duplicate(s) retired: ${report.duplicates.join(", ")}`);
+    }
+    if (report.skipped.length) {
+        console.log(`⚠️  Skipped ${report.skipped.length} unsupported file(s) (moved to .aidimag/knowledge/skipped/):`);
+        for (const s of report.skipped)
+            console.log(`   • ${s.file} — ${s.reason}`);
+    }
+    if (report.pendingNoSummarizer.length) {
+        console.log(`⏳ ${report.pendingNoSummarizer.length} doc(s) waiting in the inbox — no summarizer available.\n` +
+            `\n` +
+            `   📋 Files waiting:\n`);
+        for (const f of report.pendingNoSummarizer)
+            console.log(`      • ${f}`);
+        console.log(`\n` +
+            `   💡 To summarize, choose one:\n` +
+            `\n` +
+            `   1. Use Cursor AI (if you have MCP configured):\n` +
+            `      Ask Cursor: "Process the knowledge inbox and create memory proposals"\n` +
+            `      (Cursor will use the knowledge_ingest prompt automatically)\n` +
+            `\n` +
+            `   2. Set OpenAI API key:\n` +
+            `      export OPENAI_API_KEY="sk-your-key-here"\n` +
+            `      dim knowledge sync\n` +
+            `\n` +
+            `   3. Use Ollama (free/local):\n` +
+            `      brew install ollama && ollama serve &\n` +
+            `      ollama pull llama3.2\n` +
+            `      export AIDIMAG_LLM=ollama\n` +
+            `      dim knowledge sync`);
+    }
+    if (!report.processed.length && !report.duplicates.length &&
+        !report.skipped.length && !report.pendingNoSummarizer.length) {
+        console.log("Knowledge inbox is empty — nothing to process.");
+    }
+}
+/**
+ * Line-buffering prompt for interactive flows (review, ticket connect).
+ * Unlike readline/promises, lines arriving between questions (piped input)
+ * are queued, not dropped — so scripted/agent-driven input works too.
+ */
+export async function createPrompter(closedValue = "") {
+    const { createInterface } = await import("node:readline");
+    const rl = createInterface({ input: process.stdin });
+    const queued = [];
+    const waiters = [];
+    let closed = false;
+    rl.on("line", (l) => {
+        const w = waiters.shift();
+        if (w)
+            w(l);
+        else
+            queued.push(l);
+    });
+    rl.on("close", () => {
+        closed = true;
+        while (waiters.length)
+            waiters.shift()(closedValue);
+    });
+    const ask = (prompt) => {
+        process.stdout.write(prompt);
+        if (queued.length)
+            return Promise.resolve(queued.shift());
+        if (closed)
+            return Promise.resolve(closedValue);
+        return new Promise((resolve) => waiters.push(resolve));
+    };
+    return { ask, close: () => rl.close() };
+}
+/** Open a URL in the default browser, best-effort (matches `dim login` / `dim ui`). */
+export async function openBrowser(url) {
+    const { execFile } = await import("node:child_process");
+    const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+    execFile(opener, args, (err) => {
+        if (err)
+            process.stderr.write(`Could not open browser: ${err.message}\n`);
+    });
+}
+//# sourceMappingURL=shared.js.map

package/dist/config.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Generic reader/writer for the committed, secret-free repo config at
+ * <repo>/.aidimag/config.json. Ticket + sync sections have their own typed
+ * helpers; this covers the rest (generateContext, preCommitCheck, ...).
+ */
+import type { GuardrailLevel } from "./types.js";
+export type ContextFormat = "claude" | "cursorrules" | "copilot" | "windsurfrules" | "agents" | "all";
+export interface GenerateContextConfig {
+    /** which file(s) to write — defaults to "claude" */
+    format?: ContextFormat;
+    /** regenerate automatically after verify/sync/review */
+    auto?: boolean;
+}
+/** "block" → exit 1 on violations; true → warn (exit 0); falsy → hook is a no-op. */
+export type PreCommitCheckConfig = boolean | "warn" | "block";
+/** Who summarizes dropped knowledge docs: auto (agent→llm), agent-only, llm-only, or off. */
+export type KnowledgeSummarizer = "auto" | "agent" | "llm" | "off";
+export interface KnowledgeConfig {
+    /** inbox folder (repo-relative) where docs are dropped — default "knowledge" */
+    folder?: string;
+    /** summarizer strategy — default "auto" */
+    summarizer?: KnowledgeSummarizer;
+    /** require `dim review` approval before pinning — default true */
+    requireReview?: boolean;
+    /** keep a backup of the original in .aidimag/knowledge/processed/ — default true */
+    backup?: boolean;
+    /** text extensions we will summarize — default DEFAULT_KNOWLEDGE_EXTENSIONS */
+    extensions?: string[];
+    /** hard cap; larger files are skipped — default 1 MiB */
+    maxBytes?: number;
+    /** soft threshold; larger text docs are chunked — default 16 KiB */
+    chunkBytes?: number;
+}
+export interface AidimagConfig {
+    generateContext?: GenerateContextConfig;
+    preCommitCheck?: PreCommitCheckConfig;
+    knowledge?: KnowledgeConfig;
+    [k: string]: unknown;
+}
+export declare const DEFAULT_KNOWLEDGE_EXTENSIONS: string[];
+export interface ResolvedKnowledgeConfig {
+    folder: string;
+    summarizer: KnowledgeSummarizer;
+    requireReview: boolean;
+    backup: boolean;
+    extensions: string[];
+    maxBytes: number;
+    chunkBytes: number;
+}
+/** Knowledge config with every field filled in from defaults. */
+export declare function resolveKnowledgeConfig(repoRoot: string): ResolvedKnowledgeConfig;
+export declare function readConfig(repoRoot: string): AidimagConfig;
+/** Shallow-merge a patch into config.json, never clobbering sibling sections. */
+export declare function writeConfig(repoRoot: string, patch: Partial<AidimagConfig>): void;
+export type { GuardrailLevel };

package/dist/config.js

@@ -0,0 +1,51 @@
+/**
+ * Generic reader/writer for the committed, secret-free repo config at
+ * <repo>/.aidimag/config.json. Ticket + sync sections have their own typed
+ * helpers; this covers the rest (generateContext, preCommitCheck, ...).
+ */
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
+export const DEFAULT_KNOWLEDGE_EXTENSIONS = [
+    ".md", ".markdown", ".txt", ".rst", ".adoc", ".org",
+    ".json", ".yaml", ".yml", ".toml", ".csv", ".html",
+    ".pdf", ".docx", // binary docs — text is extracted before summarization
+];
+/** Reject repo-relative knowledge inbox paths that escape or touch sensitive dirs. */
+function safeKnowledgeFolder(folder) {
+    const normalized = folder.replace(/\\/g, "/").replace(/^\/+/, "").trim();
+    if (!normalized || normalized.includes("..") || normalized.startsWith(".aidimag"))
+        return "knowledge";
+    return normalized;
+}
+/** Knowledge config with every field filled in from defaults. */
+export function resolveKnowledgeConfig(repoRoot) {
+    const k = readConfig(repoRoot).knowledge ?? {};
+    return {
+        folder: safeKnowledgeFolder(k.folder ?? "knowledge"),
+        summarizer: k.summarizer ?? "auto",
+        requireReview: k.requireReview ?? true,
+        backup: k.backup ?? true,
+        extensions: (k.extensions ?? DEFAULT_KNOWLEDGE_EXTENSIONS).map((e) => e.startsWith(".") ? e.toLowerCase() : "." + e.toLowerCase()),
+        maxBytes: k.maxBytes ?? 1024 * 1024,
+        chunkBytes: k.chunkBytes ?? 16 * 1024,
+    };
+}
+function configPath(repoRoot) {
+    return path.join(repoRoot, ".aidimag", "config.json");
+}
+export function readConfig(repoRoot) {
+    try {
+        return JSON.parse(readFileSync(configPath(repoRoot), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+/** Shallow-merge a patch into config.json, never clobbering sibling sections. */
+export function writeConfig(repoRoot, patch) {
+    const p = configPath(repoRoot);
+    mkdirSync(path.dirname(p), { recursive: true });
+    const existing = readConfig(repoRoot);
+    writeFileSync(p, JSON.stringify({ ...existing, ...patch }, null, 2) + "\n");
+}
+//# sourceMappingURL=config.js.map

package/dist/context/generate.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `dim generate-context` (KARPATHY_LAYERS Feature 1) — Environment layer.
+ *
+ * Renders the repo's trustworthy memory (VERIFIED + UNVERIFIED + pinned, never
+ * STALE/REFUTED) into the static context file that non-MCP AI tools read at
+ * session start: CLAUDE.md, .cursorrules, .windsurfrules, AGENTS.md, or
+ * .github/copilot-instructions.md.
+ *
+ * This is what makes aidimag useful to *every* AI tool, not just MCP clients.
+ */
+import type { MemoryStore } from "../db/store.js";
+import type { ContextFormat } from "../config.js";
+export interface RenderResult {
+    markdown: string;
+    total: number;
+    pinned: number;
+}
+/** Build the markdown body shared by all output formats. */
+export declare function renderContext(store: MemoryStore): RenderResult;
+export interface WriteResult extends RenderResult {
+    files: string[];
+}
+/** Render + write the configured context file(s). Returns repo-relative paths written. */
+export declare function generateContext(store: MemoryStore, repoRoot: string, format?: ContextFormat): WriteResult;

package/dist/context/generate.js

@@ -0,0 +1,115 @@
+/**
+ * `dim generate-context` (KARPATHY_LAYERS Feature 1) — Environment layer.
+ *
+ * Renders the repo's trustworthy memory (VERIFIED + UNVERIFIED + pinned, never
+ * STALE/REFUTED) into the static context file that non-MCP AI tools read at
+ * session start: CLAUDE.md, .cursorrules, .windsurfrules, AGENTS.md, or
+ * .github/copilot-instructions.md.
+ *
+ * This is what makes aidimag useful to *every* AI tool, not just MCP clients.
+ */
+import { writeFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
+const GENERATED_HEADER = "aidimag — do not edit manually; regenerate with `dim generate-context`";
+/** Files written per format. `all` writes every target. */
+const FORMAT_FILES = {
+    claude: "CLAUDE.md",
+    cursorrules: ".cursorrules",
+    copilot: path.join(".github", "copilot-instructions.md"),
+    windsurfrules: ".windsurfrules",
+    agents: "AGENTS.md",
+};
+const GUARDRAIL_ICON = {
+    never: "🚫 NEVER",
+    always: "✅ ALWAYS",
+    "ask-first": "🤚 ASK FIRST",
+};
+// Order matters: guardrails + failed approaches are the highest-signal sections.
+const SECTIONS = [
+    { kind: "GUARDRAIL", heading: "Guardrails ⚠️" },
+    { kind: "DECISION", heading: "Decisions" },
+    { kind: "CONVENTION", heading: "Conventions" },
+    { kind: "INVARIANT", heading: "Invariants" },
+    { kind: "ARCHITECTURE", heading: "Architecture" },
+    { kind: "GOTCHA", heading: "Gotchas" },
+    { kind: "SKILL", heading: "Skills (reusable procedures)" },
+    { kind: "FAILED_APPROACH", heading: "Failed Approaches (don't retry these)" },
+    { kind: "TODO_CONTEXT", heading: "Open Context (unfinished work)" },
+];
+function statusTag(m) {
+    const bits = [m.status === "VERIFIED" ? "VERIFIED" : m.status];
+    if (m.pinned)
+        bits.push("📌");
+    return `[${bits.join(" ")}]`;
+}
+/** SKILL claims often embed "1) … 2) …" steps — render them as an ordered list. */
+function renderSkill(m) {
+    const steps = m.claim.split(/\s*\d+\)\s+/).map((s) => s.trim()).filter(Boolean);
+    if (steps.length < 2)
+        return `- ${m.claim} ${statusTag(m)}`;
+    const [title, ...rest] = m.claim.includes(":") ? [m.claim.split(":")[0]] : [""];
+    const head = title ? `**${title.trim()}** ${statusTag(m)}` : statusTag(m);
+    const items = (title ? steps.slice(1) : steps).map((s, i) => `  ${i + 1}. ${s}`);
+    return `- ${head}\n${items.join("\n")}`;
+}
+function renderGuardrail(m) {
+    const level = m.guardrailLevel ?? "ask-first";
+    return `- ${GUARDRAIL_ICON[level]}: ${m.claim} ${statusTag(m)}`;
+}
+function renderMemory(m) {
+    if (m.kind === "GUARDRAIL")
+        return renderGuardrail(m);
+    if (m.kind === "SKILL")
+        return renderSkill(m);
+    const scope = m.scope.paths.length ? ` _(scope: ${m.scope.paths.join(", ")})_` : "";
+    return `- ${m.claim}${scope} ${statusTag(m)}`;
+}
+/** Pinned first, then by confidence desc — the most load-bearing memory leads. */
+function sortForContext(a, b) {
+    if (a.pinned !== b.pinned)
+        return a.pinned ? -1 : 1;
+    return b.confidence - a.confidence;
+}
+/** Build the markdown body shared by all output formats. */
+export function renderContext(store) {
+    const memories = store
+        .list(10_000)
+        .filter((m) => m.status === "VERIFIED" || m.status === "UNVERIFIED");
+    const pinned = memories.filter((m) => m.pinned).length;
+    const lines = [
+        `<!-- ${GENERATED_HEADER} -->`,
+        `# Project Memory`,
+        `> Auto-generated by aidimag · ${new Date().toISOString()} · ${memories.length} memories, ${pinned} pinned`,
+        "",
+        "Treat the items below as the project's verified beliefs. Respect every **Guardrail**:",
+        "🚫 NEVER = refuse and explain why · ✅ ALWAYS = do it without asking · 🤚 ASK FIRST = check with the user first.",
+        "",
+    ];
+    for (const section of SECTIONS) {
+        const items = memories.filter((m) => m.kind === section.kind).sort(sortForContext);
+        if (!items.length)
+            continue;
+        lines.push(`## ${section.heading}`, ...items.map(renderMemory), "");
+    }
+    if (memories.length === 0) {
+        lines.push("_No verified memories yet — run `dim remember` or approve proposals with `dim review`._", "");
+    }
+    return { markdown: lines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n", total: memories.length, pinned };
+}
+function targetsFor(format) {
+    return format === "all" ? ["claude", "cursorrules", "copilot", "windsurfrules", "agents"] : [format];
+}
+/** Render + write the configured context file(s). Returns repo-relative paths written. */
+export function generateContext(store, repoRoot, format = "claude") {
+    const rendered = renderContext(store);
+    const files = [];
+    for (const target of targetsFor(format)) {
+        const rel = FORMAT_FILES[target];
+        const abs = path.join(repoRoot, rel);
+        mkdirSync(path.dirname(abs), { recursive: true });
+        writeFileSync(abs, rendered.markdown);
+        files.push(rel);
+    }
+    return { ...rendered, files };
+}
+//# sourceMappingURL=generate.js.map