whydid 1.0.0

package/dist/llm/schema.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+export const AnnotationJsonSchema = z.object({
+    summary: z.string(),
+    reason: z.string(),
+    decisions: z.array(z.string()).default([]),
+    risk_level: z.enum(["low", "medium", "high"]),
+});
+function extractJsonObject(text) {
+    const jsonStart = text.indexOf("{");
+    const jsonEnd = text.lastIndexOf("}");
+    if (jsonStart === -1 || jsonEnd === -1 || jsonEnd < jsonStart)
+        return null;
+    try {
+        return JSON.parse(text.slice(jsonStart, jsonEnd + 1));
+    }
+    catch {
+        return null;
+    }
+}
+export function parseAnnotationJson(text) {
+    const parsed = extractJsonObject(text);
+    if (parsed === null)
+        return null;
+    const result = AnnotationJsonSchema.safeParse(parsed);
+    return result.success ? result.data : null;
+}
+export const SocialPostJsonSchema = z.object({
+    worth_sharing: z.boolean(),
+    content: z.string(),
+});
+export function parseSocialPostJson(text) {
+    const parsed = extractJsonObject(text);
+    if (parsed === null)
+        return null;
+    const result = SocialPostJsonSchema.safeParse(parsed);
+    return result.success ? result.data : null;
+}
+export const ChatAnswerJsonSchema = z.object({
+    answer: z.string(),
+    cited_state_ids: z.array(z.string()).default([]),
+});
+export function parseChatAnswerJson(text) {
+    const parsed = extractJsonObject(text);
+    if (parsed === null)
+        return null;
+    const result = ChatAnswerJsonSchema.safeParse(parsed);
+    return result.success ? result.data : null;
+}
+//# sourceMappingURL=schema.js.map

package/dist/llm/social-post.js

@@ -0,0 +1,49 @@
+import { randomUUID } from "node:crypto";
+/**
+ * Generates a social post draft from a session's real prompts and
+ * whydid's own checkpoint annotations, and persists it if there's
+ * anything worth saving.
+ *
+ * Manual requests save whenever the model actually produced content —
+ * the user explicitly picked this session, so their judgment about
+ * whether it's worth a post stands even if the model was lukewarm.
+ * Automatic requests only save when the model itself judged the session
+ * worth_sharing — the whole point of the gate is to keep the draft
+ * library free of noise from trivial or in-progress sessions when nobody
+ * asked for a draft in the first place. In practice both end up
+ * equivalent in the common case, since the prompt instructs the model to
+ * leave content empty exactly when it judges a session not worth
+ * sharing — but a manual request never overrides real content the model
+ * did produce.
+ */
+export async function generateAndSaveSocialPost(ctx, provider, projectId, sessionId, platform, source, retentionDays) {
+    const turns = ctx.db.listTurns(sessionId);
+    const sessionPrompts = turns.map((t) => t.prompt).filter((p) => !!p);
+    const checkpointSummaries = [];
+    const seenStateIds = new Set();
+    for (const turn of turns) {
+        for (const state of ctx.db.getStatesForTurn(turn.id)) {
+            if (seenStateIds.has(state.id))
+                continue;
+            seenStateIds.add(state.id);
+            const annotation = ctx.db.getAnnotation(state.id);
+            if (annotation?.status === "generated" && annotation.summary && annotation.reason) {
+                checkpointSummaries.push({ summary: annotation.summary, reason: annotation.reason, decisions: annotation.decisions, riskLevel: annotation.riskLevel });
+            }
+        }
+    }
+    const result = await provider.generateSocialPost({ platform, sessionPrompts, checkpointSummaries });
+    const shouldSave = result.content.trim().length > 0 && (source === "manual" || result.worthSharing);
+    if (!shouldSave) {
+        return { saved: false, post: null, worthSharing: result.worthSharing };
+    }
+    const id = randomUUID();
+    ctx.db.insertSocialPost({
+        id, projectId, sessionId, platform, content: result.content, source,
+        model: result.model ?? null, inputTokens: result.usage?.inputTokens ?? null, outputTokens: result.usage?.outputTokens ?? null,
+    });
+    ctx.db.pruneOldSocialPosts(projectId, retentionDays);
+    const post = ctx.db.getSocialPost(id);
+    return { saved: true, post: post ?? null, worthSharing: result.worthSharing };
+}
+//# sourceMappingURL=social-post.js.map

package/dist/objects/store.js

@@ -0,0 +1,31 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export function hashContent(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+export class ObjectStore {
+    objectsDir;
+    constructor(objectsDir) {
+        this.objectsDir = objectsDir;
+    }
+    pathFor(hash) {
+        return join(this.objectsDir, hash.slice(0, 2), hash.slice(2));
+    }
+    write(content) {
+        const hash = hashContent(content);
+        const path = this.pathFor(hash);
+        if (!existsSync(path)) {
+            mkdirSync(join(this.objectsDir, hash.slice(0, 2)), { recursive: true });
+            writeFileSync(path, content);
+        }
+        return hash;
+    }
+    read(hash) {
+        return readFileSync(this.pathFor(hash));
+    }
+    has(hash) {
+        return existsSync(this.pathFor(hash));
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/shared/config.js

@@ -0,0 +1,45 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export const DEFAULT_CONFIG = {
+    projectName: "",
+    ignoredPaths: ["node_modules", ".next", "dist", "build", ".venv"],
+    checkpoint: {
+        debounceMs: 2500,
+        minIntervalMs: 10000,
+        minChangedFiles: 1,
+        minChangedBytes: 1,
+    },
+    ai: { provider: "noop", model: "" },
+    test: null,
+    privacy: { sendPrompts: true, sendDiffs: true },
+    contextTree: { enabled: true },
+    buildInPublic: { enabled: false, retentionDays: 14 },
+    aiBudget: { monthlyLimitUsd: null, alertThresholdPercent: 80 },
+    pricingOverrides: {},
+};
+function configPath(whydidDir) {
+    return join(whydidDir, "config.json");
+}
+export function loadConfig(whydidDir) {
+    const path = configPath(whydidDir);
+    if (!existsSync(path)) {
+        return structuredClone(DEFAULT_CONFIG);
+    }
+    const onDisk = JSON.parse(readFileSync(path, "utf-8"));
+    return {
+        ...structuredClone(DEFAULT_CONFIG),
+        ...onDisk,
+        checkpoint: { ...DEFAULT_CONFIG.checkpoint, ...(onDisk.checkpoint ?? {}) },
+        ai: { ...DEFAULT_CONFIG.ai, ...(onDisk.ai ?? {}) },
+        test: onDisk.test ?? DEFAULT_CONFIG.test,
+        privacy: { ...DEFAULT_CONFIG.privacy, ...(onDisk.privacy ?? {}) },
+        contextTree: { ...DEFAULT_CONFIG.contextTree, ...(onDisk.contextTree ?? {}) },
+        buildInPublic: { ...DEFAULT_CONFIG.buildInPublic, ...(onDisk.buildInPublic ?? {}) },
+        aiBudget: { ...DEFAULT_CONFIG.aiBudget, ...(onDisk.aiBudget ?? {}) },
+        pricingOverrides: { ...DEFAULT_CONFIG.pricingOverrides, ...(onDisk.pricingOverrides ?? {}) },
+    };
+}
+export function saveConfig(whydidDir, config) {
+    writeFileSync(configPath(whydidDir), JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+//# sourceMappingURL=config.js.map

package/dist/shared/redaction.js

@@ -0,0 +1,18 @@
+const PATTERNS = [
+    /sk_live_[A-Za-z0-9]{16,}/g,
+    /sk_test_[A-Za-z0-9]{16,}/g,
+    /AKIA[0-9A-Z]{16}/g,
+    /eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
+    /(postgres|postgresql|mysql|mongodb(\+srv)?):\/\/[^\s:]+:[^\s@]+@[^\s]+/g,
+    /(ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}/g,
+];
+const KEY_LIKE_ASSIGNMENT = /\b([A-Z_][A-Z0-9_]*(?:KEY|SECRET|TOKEN|PASSWORD)[A-Z0-9_]*)\s*=\s*(\S+)/g;
+export function redactSecrets(text) {
+    let out = text;
+    for (const pattern of PATTERNS) {
+        out = out.replace(pattern, "[REDACTED_SECRET]");
+    }
+    out = out.replace(KEY_LIKE_ASSIGNMENT, (_match, name) => `${name}=[REDACTED_SECRET]`);
+    return out;
+}
+//# sourceMappingURL=redaction.js.map

package/dist/shared/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/watcher/ignore-rules.js

@@ -0,0 +1,92 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, relative } from "node:path";
+import { createRequire } from "node:module";
+const nodeRequire = createRequire(import.meta.url);
+const ignoreFactory = nodeRequire("ignore");
+const BUILT_IN_EXCLUDES = [
+    ".git", ".whydid", "node_modules", ".next", "dist", "build", ".venv",
+];
+/**
+ * Rewrites one line from a nested .gitignore (e.g. `landing/.gitignore`)
+ * into the equivalent pattern rooted at the project root, matching git's
+ * own semantics: a pattern containing a `/` (anchored, whether written
+ * with a leading slash or not — git treats any internal slash as anchoring
+ * to that .gitignore's own directory) is prefixed directly; a pattern with
+ * no `/` at all matches at any depth under that directory, so it needs a
+ * `**\/` in between. Comments and blank lines are dropped; negation (`!`)
+ * is preserved.
+ */
+function rebasePattern(line, relativeDir) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#"))
+        return null;
+    const negated = trimmed.startsWith("!");
+    const body = negated ? trimmed.slice(1) : trimmed;
+    const anchored = body.startsWith("/");
+    const core = anchored ? body.slice(1) : body;
+    const hasInternalSlash = core.includes("/");
+    const rebased = anchored || hasInternalSlash ? `${relativeDir}/${core}` : `${relativeDir}/**/${core}`;
+    return negated ? `!${rebased}` : rebased;
+}
+/**
+ * Walks the project tree looking for .gitignore files below the root one
+ * (already handled separately), skipping any directory the rules built up
+ * so far already exclude — so this never descends into node_modules, the
+ * object store, etc. Each nested file's patterns are rebased onto the
+ * project root before being added, so they only ever apply within their
+ * own subtree, exactly like git itself resolves them.
+ */
+function collectNestedGitignorePatterns(projectRoot, ig) {
+    const patterns = [];
+    function walk(absDir) {
+        let entries;
+        try {
+            entries = readdirSync(absDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const absChild = join(absDir, entry.name);
+            const relChild = relative(projectRoot, absChild).split("\\").join("/");
+            if (ig.ignores(relChild))
+                continue;
+            const gitignorePath = join(absChild, ".gitignore");
+            if (existsSync(gitignorePath)) {
+                const lines = readFileSync(gitignorePath, "utf-8").split("\n");
+                for (const line of lines) {
+                    const rebased = rebasePattern(line, relChild);
+                    if (rebased) {
+                        patterns.push(rebased);
+                        ig.add(rebased);
+                    }
+                }
+            }
+            walk(absChild);
+        }
+    }
+    walk(projectRoot);
+    return patterns;
+}
+export class IgnoreRules {
+    ig;
+    constructor(projectRoot, extraIgnoredPaths) {
+        this.ig = ignoreFactory();
+        this.ig.add(BUILT_IN_EXCLUDES);
+        this.ig.add(extraIgnoredPaths);
+        const gitignorePath = join(projectRoot, ".gitignore");
+        if (existsSync(gitignorePath)) {
+            this.ig.add(readFileSync(gitignorePath, "utf-8"));
+        }
+        collectNestedGitignorePatterns(projectRoot, this.ig);
+    }
+    isIgnored(relativePath) {
+        const normalized = relativePath.split("\\").join("/").replace(/^\/+/, "");
+        if (!normalized)
+            return false;
+        return this.ig.ignores(normalized);
+    }
+}
+//# sourceMappingURL=ignore-rules.js.map

package/dist/watcher/watcher.js

@@ -0,0 +1,249 @@
+import chokidar from "chokidar";
+import { createCheckpoint } from "../core/engine.js";
+import { annotateCheckpoint } from "../llm/annotate-checkpoint.js";
+import { updateContextTree } from "../core/context-tree.js";
+import { generateAndSaveSocialPost } from "../llm/social-post.js";
+import { NoopProvider } from "../llm/noop-provider.js";
+import { syncClaudeCodeTurns } from "../adapters/sync-claude-code.js";
+const TURN_POLL_MS = 250;
+export class ProjectWatcher {
+    ctx;
+    projectId;
+    config;
+    claudeProjectsDir;
+    turnPollMs;
+    privacy;
+    contextTreeEnabled;
+    buildInPublicEnabled;
+    buildInPublicRetentionDays;
+    fsWatcher = null;
+    debounceTimer = null;
+    turnPollTimer = null;
+    lastCheckpointAt = 0;
+    pollingMode = false;
+    callbacks = [];
+    llmProvider;
+    isReady = false;
+    running = false;
+    pendingForcedCheckpoints = [];
+    lastFinalizedTurnId = null;
+    lastBuildInPublicSessionId = null;
+    // Latest active coding-agent session/turn, used to attribute checkpoints.
+    currentSessionId = null;
+    currentTurnId = null;
+    currentTurnPrompt = null;
+    constructor(ctx, projectId, config, llmProvider, claudeProjectsDir, turnPollMs = TURN_POLL_MS, privacy = { sendPrompts: true, sendDiffs: true }, contextTreeEnabled = true, buildInPublicEnabled = false, buildInPublicRetentionDays = 14) {
+        this.ctx = ctx;
+        this.projectId = projectId;
+        this.config = config;
+        this.claudeProjectsDir = claudeProjectsDir;
+        this.turnPollMs = turnPollMs;
+        this.privacy = privacy;
+        this.contextTreeEnabled = contextTreeEnabled;
+        this.buildInPublicEnabled = buildInPublicEnabled;
+        this.buildInPublicRetentionDays = buildInPublicRetentionDays;
+        this.llmProvider = llmProvider ?? new NoopProvider();
+    }
+    onCheckpoint(cb) {
+        this.callbacks.push(cb);
+    }
+    // Lets a running daemon pick up an AI provider change made in Settings
+    // without requiring a restart. (A change to *which key is present in the
+    // environment* still needs a restart — the daemon process's env is fixed
+    // at spawn time — but switching between already-available providers, or
+    // toggling privacy settings that flow through config, takes effect on the
+    // very next checkpoint.)
+    setLLMProvider(provider) {
+        this.llmProvider = provider;
+    }
+    setPrivacy(privacy) {
+        this.privacy = privacy;
+    }
+    setContextTreeEnabled(enabled) {
+        this.contextTreeEnabled = enabled;
+    }
+    setBuildInPublic(config) {
+        this.buildInPublicEnabled = config.enabled;
+        this.buildInPublicRetentionDays = config.retentionDays;
+    }
+    start() {
+        this.startFsWatcher(false);
+        this.pollAgentTurn();
+        this.turnPollTimer = setInterval(() => this.pollAgentTurn(), this.turnPollMs);
+    }
+    // Native fs watching opens one OS handle per watched file on some
+    // platforms (confirmed via chokidar's _watchWithNodeFs path). On a large
+    // enough tree (verified: a 50,000-file synthetic project) this exceeds the
+    // process's file-descriptor limit and chokidar emits an EMFILE error —
+    // which, being an EventEmitter 'error' event with no listener attached,
+    // previously crashed the entire daemon process outright (confirmed: the
+    // process died while its pidfile kept claiming it was running). Watching
+    // now always has an error handler, and on EMFILE specifically it retries
+    // once in polling mode, which has a fixed CPU cost instead of one handle
+    // per file and so isn't subject to the same ceiling. Any other watch
+    // error is logged and the daemon keeps running rather than crashing —
+    // the agent turn-boundary checkpoint path is independent
+    // of file watching and keeps working as a safety net either way, and
+    // `whydid checkpoint` always works as a manual fallback.
+    startFsWatcher(usePolling) {
+        this.isReady = false;
+        this.pollingMode = usePolling;
+        const watcher = chokidar.watch(this.ctx.projectRoot, {
+            ignored: (path) => {
+                const rel = path.replace(this.ctx.projectRoot, "").replace(/^[\\/]/, "");
+                return rel !== "" && this.ctx.ignoreRules.isIgnored(rel);
+            },
+            ignoreInitial: true,
+            persistent: true,
+            usePolling,
+        });
+        this.fsWatcher = watcher;
+        watcher.on("ready", () => {
+            this.isReady = true;
+        });
+        watcher.on("all", () => this.scheduleCheckpoint());
+        watcher.on("error", (err) => {
+            const code = err?.code;
+            if (code === "EMFILE" && !usePolling) {
+                console.error("[whydid] File watching hit the OS file-descriptor limit on this project's size — falling back to polling mode.");
+                void watcher.close().finally(() => this.startFsWatcher(true));
+                return;
+            }
+            console.error("[whydid] File watcher error (agent turn-boundary checkpoints and `whydid checkpoint` still work):", err);
+        });
+    }
+    /**
+     * Polls Claude Code's local transcript and the database's hook-reported
+     * active turn. At a prompt boundary, pending changes are checkpointed
+     * against the turn that just ended instead of waiting for debounce.
+     */
+    pollAgentTurn() {
+        let claudeTurn = null;
+        try {
+            claudeTurn = syncClaudeCodeTurns(this.ctx, this.projectId, this.claudeProjectsDir);
+        }
+        catch { }
+        const activeTurn = this.ctx.db.getMostRecentActiveTurn(this.projectId);
+        if (activeTurn && this.currentTurnId && activeTurn.turnId !== this.currentTurnId) {
+            if (this.debounceTimer) {
+                clearTimeout(this.debounceTimer);
+                this.debounceTimer = null;
+            }
+            this.queueForcedCheckpoint(this.currentSessionId ?? activeTurn.sessionId, this.currentTurnId);
+        }
+        if (!activeTurn) {
+            if (this.currentSessionId && this.currentTurnId) {
+                const turn = this.ctx.db.getTurn(this.currentTurnId);
+                if (turn?.status === "completed") {
+                    if (this.debounceTimer) {
+                        clearTimeout(this.debounceTimer);
+                        this.debounceTimer = null;
+                    }
+                    this.queueForcedCheckpoint(this.currentSessionId, this.currentTurnId);
+                    this.currentTurnId = null;
+                    this.currentTurnPrompt = null;
+                }
+            }
+            this.maybeDraftForEndedSession(this.currentSessionId);
+            return;
+        }
+        // Two separate completion signals, not redundant: Codex/Cursor sessions
+        // get an explicit SessionEnd hook event, recorded as sessions.ended_at
+        // (checked inside maybeDraftForEndedSession) — but Claude Code's local
+        // transcript has no such signal, only turns, so its session-end is
+        // inferred here from "a new session file appeared" instead. Both funnel
+        // through the same lastBuildInPublicSessionId guard, so neither can
+        // double-fire for the same session.
+        if (this.currentSessionId && activeTurn.sessionId !== this.currentSessionId) {
+            this.maybeDraftForEndedSession(this.currentSessionId);
+        }
+        if (this.buildInPublicEnabled && claudeTurn && this.currentSessionId && claudeTurn.sessionId !== this.currentSessionId) {
+            const endedSessionId = this.currentSessionId;
+            if (this.lastBuildInPublicSessionId !== endedSessionId) {
+                this.lastBuildInPublicSessionId = endedSessionId;
+                generateAndSaveSocialPost(this.ctx, this.llmProvider, this.projectId, endedSessionId, "x", "automatic", this.buildInPublicRetentionDays).catch(() => { });
+            }
+        }
+        this.currentSessionId = activeTurn.sessionId;
+        this.currentTurnId = activeTurn.turnId;
+        this.currentTurnPrompt = activeTurn.prompt;
+    }
+    queueForcedCheckpoint(sessionId, turnId) {
+        if (this.lastFinalizedTurnId === turnId)
+            return;
+        this.lastFinalizedTurnId = turnId;
+        this.pendingForcedCheckpoints.push({ sessionId, turnId });
+        if (!this.running) {
+            const pending = this.pendingForcedCheckpoints.shift();
+            void this.maybeCheckpoint({ force: true, ...pending });
+        }
+    }
+    maybeDraftForEndedSession(sessionId) {
+        if (!this.buildInPublicEnabled || !sessionId || this.lastBuildInPublicSessionId === sessionId)
+            return;
+        const session = this.ctx.db.getSession(sessionId);
+        if (!session?.endedAt)
+            return;
+        this.lastBuildInPublicSessionId = sessionId;
+        generateAndSaveSocialPost(this.ctx, this.llmProvider, this.projectId, sessionId, "x", "automatic", this.buildInPublicRetentionDays).catch(() => { });
+    }
+    scheduleCheckpoint() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => void this.maybeCheckpoint(), this.config.debounceMs);
+    }
+    async maybeCheckpoint(opts = {}) {
+        if (this.running) {
+            if (opts.force && opts.sessionId && opts.turnId && !this.pendingForcedCheckpoints.some((item) => item.turnId === opts.turnId)) {
+                this.pendingForcedCheckpoints.push({ sessionId: opts.sessionId, turnId: opts.turnId });
+            }
+            return;
+        }
+        if (opts.force && opts.turnId) {
+            const queuedIndex = this.pendingForcedCheckpoints.findIndex((item) => item.turnId === opts.turnId);
+            if (queuedIndex !== -1)
+                this.pendingForcedCheckpoints.splice(queuedIndex, 1);
+        }
+        if (!opts.force) {
+            const elapsed = Date.now() - this.lastCheckpointAt;
+            if (this.lastCheckpointAt !== 0 && elapsed < this.config.minIntervalMs)
+                return;
+        }
+        this.running = true;
+        let result;
+        try {
+            const sessionId = opts.sessionId ?? this.currentSessionId ?? undefined;
+            const turnId = opts.turnId ?? this.currentTurnId ?? undefined;
+            result = await createCheckpoint(this.ctx, { projectId: this.projectId, sessionId, turnId });
+        }
+        finally {
+            this.running = false;
+            const pending = this.pendingForcedCheckpoints.shift();
+            if (pending)
+                void this.maybeCheckpoint({ force: true, ...pending });
+        }
+        if (result.changed) {
+            this.lastCheckpointAt = Date.now();
+            const userInstruction = opts.turnId ? undefined : this.currentTurnPrompt ?? undefined;
+            const annotation = await annotateCheckpoint(this.ctx, this.llmProvider, result.stateId, result.fileChanges, {
+                userInstruction,
+                sendPrompts: this.privacy.sendPrompts,
+                sendDiffs: this.privacy.sendDiffs,
+            });
+            if (annotation.status === "generated" && this.contextTreeEnabled) {
+                await updateContextTree(this.ctx, this.projectId, result.fileChanges.map((c) => c.filePath));
+            }
+        }
+        for (const cb of this.callbacks)
+            cb({ stateId: result.stateId, changed: result.changed });
+    }
+    async stop() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        if (this.turnPollTimer)
+            clearInterval(this.turnPollTimer);
+        await this.fsWatcher?.close();
+        this.fsWatcher = null;
+    }
+}
+//# sourceMappingURL=watcher.js.map

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "whydid",
+  "version": "1.0.0",
+  "type": "module",
+  "license": "UNLICENSED",
+  "description": "A local-first AI coding time machine — captures meaningful changes, reasoning, and session context so you can see what happened across your coding sessions, even days later.",
+  "homepage": "https://whydid.dev",
+  "keywords": [
+    "ai",
+    "coding-agent",
+    "checkpoint",
+    "cli",
+    "developer-tools",
+    "local-first"
+  ],
+  "bin": {
+    "whydid": "dist/cli/index.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dashboard/dist/**",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "dashboard:dev": "vite --config dashboard/vite.config.ts",
+    "dashboard:build": "vite build --config dashboard/vite.config.ts",
+    "dashboard:test": "npm --prefix dashboard run test",
+    "dashboard:build:demo": "npm --prefix dashboard run build:demo",
+    "landing:build": "npm --prefix landing run build",
+    "landing:test": "npm --prefix landing run test"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "@napi-rs/keyring": "^2.1.0",
+    "chokidar": "^4.0.3",
+    "commander": "^12.1.0",
+    "diff": "^7.0.0",
+    "express": "^4.21.1",
+    "ignore": "^6.0.2",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/diff": "^7.0.2",
+    "@types/express": "^4.17.21",
+    "@types/node": "^24.0.0",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.4"
+  }
+}