@malindar/whyline 0.1.0

package/src/commands/export.ts

@@ -0,0 +1,95 @@
+import fs from "fs";
+import { isInitialized, resolveConfig } from "../config.js";
+import { openDb } from "../db/connection.js";
+import { getRepoRoot } from "../git/git.js";
+import { getRepoId } from "../git/repoId.js";
+import { getAllMemories } from "../memory/saveMemory.js";
+import type { CodingMemory } from "../memory/types.js";
+
+function memoryToMarkdown(memory: CodingMemory): string {
+  const lines: string[] = [];
+  lines.push(`# ${memory.id}`);
+  lines.push(`Created: ${memory.createdAt}`);
+  if (memory.commitSha) lines.push(`Commit: ${memory.commitSha}`);
+  if (memory.repoName) lines.push(`Repo: ${memory.repoName}`);
+  if (memory.files.length) lines.push(`Files: ${memory.files.join(", ")}`);
+  if (memory.tags.length) lines.push(`Tags: ${memory.tags.join(", ")}`);
+  lines.push("");
+  if (memory.task) { lines.push("Task:", memory.task, ""); }
+  lines.push("Intent:", memory.intent, "");
+  lines.push("Summary:", memory.summary, "");
+  lines.push("Decision:", memory.decision, "");
+  lines.push("Why:", memory.why, "");
+  if (memory.alternativesRejected.length) {
+    lines.push("Alternatives rejected:");
+    for (const a of memory.alternativesRejected) lines.push(`- ${a}`);
+    lines.push("");
+  }
+  if (memory.risks.length) {
+    lines.push("Risks:");
+    for (const r of memory.risks) lines.push(`- ${r}`);
+    lines.push("");
+  }
+  if (memory.followUps.length) {
+    lines.push("Follow-ups:");
+    for (const fu of memory.followUps) lines.push(`- ${fu}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+export async function runExport(options: {
+  format: string;
+  output?: string;
+  repo: boolean;
+  since?: string;
+  before?: string;
+  tag: string[];
+}): Promise<void> {
+  if (!isInitialized()) {
+    console.error("whyline is not initialized. Run `whyline init` first.");
+    process.exit(1);
+  }
+
+  const db = openDb(resolveConfig().storage.dbPath);
+  let memories = getAllMemories(db);
+  db.close();
+
+  if (options.repo) {
+    const repoRoot = getRepoRoot(process.cwd());
+    if (!repoRoot) {
+      console.error("Not inside a git repository.");
+      process.exit(1);
+    }
+    const repoId = getRepoId(repoRoot);
+    memories = memories.filter((m) => m.repoId === repoId);
+  }
+
+  if (options.since) {
+    const sinceMs = new Date(options.since).getTime();
+    memories = memories.filter((m) => new Date(m.createdAt).getTime() >= sinceMs);
+  }
+  if (options.before) {
+    const beforeMs = new Date(options.before).getTime();
+    memories = memories.filter((m) => new Date(m.createdAt).getTime() <= beforeMs);
+  }
+  if (options.tag.length > 0) {
+    const lowerTags = options.tag.map((t) => t.toLowerCase());
+    memories = memories.filter((m) => {
+      const mTags = m.tags.map((t) => t.toLowerCase());
+      return lowerTags.every((t) => mTags.includes(t));
+    });
+  }
+
+  const output =
+    options.format === "md"
+      ? memories.map(memoryToMarkdown).join("\n---\n\n")
+      : JSON.stringify({ schemaVersion: 1, memories }, null, 2);
+
+  if (options.output) {
+    fs.writeFileSync(options.output, output, "utf-8");
+    console.error(`Exported ${memories.length} memory(s) to ${options.output}`);
+  } else {
+    process.stdout.write(output + "\n");
+  }
+}

package/src/commands/import.ts

@@ -0,0 +1,119 @@
+import fs from "fs";
+import { isInitialized, resolveConfig } from "../config.js";
+import { openDb } from "../db/connection.js";
+import { saveMemory, getMemoryById } from "../memory/saveMemory.js";
+import { redactSecrets } from "../memory/redactSecrets.js";
+import type { CodingMemory } from "../memory/types.js";
+
+const VALID_SOURCES = new Set(["manual", "claude-code", "cli", "hook"]);
+
+function validateMemory(obj: unknown): CodingMemory | null {
+  if (!obj || typeof obj !== "object") return null;
+  const m = obj as Record<string, unknown>;
+  if (
+    typeof m.id !== "string" ||
+    typeof m.createdAt !== "string" ||
+    typeof m.updatedAt !== "string" ||
+    typeof m.repoId !== "string" ||
+    typeof m.intent !== "string" ||
+    typeof m.summary !== "string" ||
+    typeof m.decision !== "string" ||
+    typeof m.why !== "string" ||
+    !Array.isArray(m.files) ||
+    !Array.isArray(m.tags) ||
+    !Array.isArray(m.alternativesRejected) ||
+    !Array.isArray(m.risks) ||
+    !Array.isArray(m.followUps) ||
+    typeof m.embeddingText !== "string"
+  ) {
+    return null;
+  }
+  const source = VALID_SOURCES.has(m.source as string)
+    ? (m.source as CodingMemory["source"])
+    : "manual";
+  return {
+    id: m.id,
+    createdAt: m.createdAt,
+    updatedAt: m.updatedAt,
+    repoId: m.repoId,
+    repoPath: typeof m.repoPath === "string" ? m.repoPath : undefined,
+    repoName: typeof m.repoName === "string" ? m.repoName : undefined,
+    branch: typeof m.branch === "string" ? m.branch : undefined,
+    commitSha: typeof m.commitSha === "string" ? m.commitSha : undefined,
+    task: typeof m.task === "string" ? m.task : undefined,
+    intent: redactSecrets(m.intent),
+    summary: redactSecrets(m.summary),
+    decision: redactSecrets(m.decision),
+    why: redactSecrets(m.why),
+    files: (m.files as unknown[]).filter((f): f is string => typeof f === "string"),
+    tags: (m.tags as unknown[]).filter((t): t is string => typeof t === "string"),
+    alternativesRejected: (m.alternativesRejected as unknown[]).filter((a): a is string => typeof a === "string").map(redactSecrets),
+    risks: (m.risks as unknown[]).filter((r): r is string => typeof r === "string").map(redactSecrets),
+    followUps: (m.followUps as unknown[]).filter((f): f is string => typeof f === "string").map(redactSecrets),
+    source,
+    embeddingText: m.embeddingText,
+    rawTranscriptPath: typeof m.rawTranscriptPath === "string" ? m.rawTranscriptPath : undefined,
+  };
+}
+
+export async function runImport(filePath: string): Promise<void> {
+  if (!isInitialized()) {
+    console.error("whyline is not initialized. Run `whyline init` first.");
+    process.exit(1);
+  }
+
+  let raw: string;
+  try {
+    raw = fs.readFileSync(filePath, "utf-8");
+  } catch {
+    console.error(`Cannot read file: ${filePath}`);
+    process.exit(1);
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    console.error("File is not valid JSON. Only JSON exports are supported for import.");
+    process.exit(1);
+  }
+
+  // Accept both v1 envelope { schemaVersion, memories } and legacy bare arrays
+  let items: unknown[];
+  if (Array.isArray(parsed)) {
+    items = parsed;
+  } else if (
+    parsed &&
+    typeof parsed === "object" &&
+    "memories" in (parsed as object) &&
+    Array.isArray((parsed as Record<string, unknown>).memories)
+  ) {
+    items = (parsed as Record<string, unknown>).memories as unknown[];
+  } else {
+    items = [parsed];
+  }
+  const db = openDb(resolveConfig().storage.dbPath);
+
+  let imported = 0;
+  let skipped = 0;
+  let invalid = 0;
+
+  for (const item of items) {
+    const memory = validateMemory(item);
+    if (!memory) {
+      invalid++;
+      continue;
+    }
+    const existing = getMemoryById(db, memory.id);
+    if (existing) {
+      skipped++;
+      continue;
+    }
+    saveMemory(db, memory);
+    imported++;
+  }
+
+  db.close();
+
+  console.log(`Import complete: ${imported} imported, ${skipped} skipped (already exist), ${invalid} invalid.`);
+}

package/src/commands/init.ts

@@ -0,0 +1,31 @@
+import fs from "fs";
+import path from "path";
+import { DATA_DIR, DB_PATH, CONFIG_PATH, AppConfig } from "../config.js";
+import { openDb } from "../db/connection.js";
+import { runMigrations } from "../db/migrations.js";
+
+type InitOptions = {
+  dataDir?: string;
+};
+
+export function runInit(options: InitOptions = {}): void {
+  const dataDir = options.dataDir ?? DATA_DIR;
+  const dbPath = options.dataDir ? path.join(options.dataDir, "memory.db") : DB_PATH;
+  const configPath = options.dataDir ? path.join(options.dataDir, "config.json") : CONFIG_PATH;
+
+  fs.mkdirSync(dataDir, { recursive: true });
+
+  if (!fs.existsSync(configPath)) {
+    const config: AppConfig = {
+      version: 1,
+      storage: { dbPath },
+    };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  }
+
+  const db = openDb(dbPath);
+  runMigrations(db);
+  db.close();
+
+  console.log(`Initialized whyline at ${dataDir}`);
+}

package/src/commands/install-claude.ts

@@ -0,0 +1,203 @@
+import fs from "fs";
+import path from "path";
+import { getRepoRoot } from "../git/git.js";
+import { getRepoName } from "../git/repoId.js";
+
+const MCP_TOOL_PERMISSIONS = [
+  "mcp__whyline__save_coding_memory",
+  "mcp__whyline__search_coding_memory",
+  "mcp__whyline__get_recent_memories",
+  "mcp__whyline__get_file_memories",
+  "mcp__whyline__get_commit_memory",
+];
+
+function claudeMdSection(repoPath: string): string {
+  return `
+## Whyline Memory
+
+You have access to a \`whyline\` MCP server. Use it every session.
+
+### When you start working on ANY task
+
+**Before asking any clarifying question or touching any file**, search for past context:
+
+- If the task is clearly described: call \`search_coding_memory\` with:
+  - \`repoPath\`: \`${repoPath}\`
+  - \`query\`: the task or feature the user just described
+  - \`files\`: any files you already know are relevant
+
+- If the task is vague or just starting out: call \`get_recent_memories\` with:
+  - \`repoPath\`: \`${repoPath}\`
+  - \`limit\`: 5
+
+**If memories come back**, you MUST:
+1. Show the user what was previously decided and why: _"I found a previous memory about this: [decision + reason]. Before I proceed — what's the reason for changing it now?"_
+2. Wait for the user to give a reason before asking implementation questions
+3. Record the new reason when saving the updated memory
+
+Do not skip straight to implementation questions when a past memory exists for the same area. The reason matters — it goes into the next memory.
+
+Treat memories as historical context — they explain past decisions, not current truth.
+
+### After you commit
+
+After \`git commit\` succeeds:
+
+1. Synthesize from the conversation:
+   - What was the goal? → \`intent\`
+   - What was the key decision? → \`decision\`
+   - Why that decision (not another)? → \`why\`
+   - What alternatives were rejected? → \`alternativesRejected\`
+   - What risks exist? → \`risks\`
+   - What should be done next? → \`followUps\`
+
+2. Show the summary to the user:
+   _"Here's what I'm saving as a coding memory — let me know if you want to add or correct anything:"_
+   Then display each field clearly.
+
+3. Wait a moment for the user to respond. If they add or correct something, apply it.
+
+4. Call \`save_coding_memory\` with:
+   - \`repoPath\`: \`${repoPath}\`
+   - \`commitSha\`: the commit SHA (use HEAD)
+   - \`files\`: files changed in this session
+   - \`source\`: \`"claude-code"\`
+   - all synthesized fields above
+
+5. If the response contains a non-empty \`warnings\` array, show each warning to the user and offer to update the memory with richer detail.
+
+### Memory quality rules
+
+Only save memories that would genuinely help a future session. Good memory:
+- Explains a non-obvious decision
+- Warns about a real risk
+- Records a rejected alternative that someone will try again
+
+Do NOT save:
+- Routine refactors with no tradeoffs
+- Things obvious from reading the code
+- Secrets or credentials
+`;
+}
+
+function writeMcpJson(repoRoot: string): "created" | "updated" | "unchanged" {
+  const mcpPath = path.join(repoRoot, ".mcp.json");
+  const whylineEntry = { command: "whyline", args: ["mcp"] };
+
+  let existing: Record<string, unknown> = {};
+  if (fs.existsSync(mcpPath)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(mcpPath, "utf-8")) as Record<string, unknown>;
+    } catch {
+      // invalid JSON — overwrite
+    }
+  }
+
+  const servers = (existing.mcpServers ?? {}) as Record<string, unknown>;
+  const alreadyThere =
+    JSON.stringify((servers.whyline ?? null)) === JSON.stringify(whylineEntry);
+
+  if (alreadyThere) return "unchanged";
+
+  servers.whyline = whylineEntry;
+  existing.mcpServers = servers;
+  fs.writeFileSync(mcpPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+  return fs.existsSync(mcpPath) && Object.keys(servers).length > 1 ? "updated" : "created";
+}
+
+function writeClaudeMd(repoRoot: string, repoPath: string): "created" | "updated" | "unchanged" {
+  const claudePath = path.join(repoRoot, "CLAUDE.md");
+  const section = claudeMdSection(repoPath);
+
+  if (!fs.existsSync(claudePath)) {
+    const repoName = getRepoName(repoRoot);
+    const header = `# Claude Instructions for ${repoName}\n`;
+    fs.writeFileSync(claudePath, header + section, "utf-8");
+    return "created";
+  }
+
+  const existing = fs.readFileSync(claudePath, "utf-8");
+
+  // Already has the section — update repoPath lines in place
+  if (/whyline/i.test(existing)) {
+    const updated = existing.replace(
+      /(`repoPath`:\s*`)([^`]+)(`)/g,
+      `$1${repoPath}$3`
+    );
+    if (updated === existing) return "unchanged";
+    fs.writeFileSync(claudePath, updated, "utf-8");
+    return "updated";
+  }
+
+  // Exists but no Whyline section — append
+  fs.writeFileSync(claudePath, existing.trimEnd() + "\n" + section, "utf-8");
+  return "updated";
+}
+
+function writeSettingsJson(repoRoot: string): "created" | "updated" | "unchanged" {
+  const settingsDir = path.join(repoRoot, ".claude");
+  const settingsPath = path.join(settingsDir, "settings.local.json");
+
+  let existing: Record<string, unknown> = {};
+  if (fs.existsSync(settingsPath)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(settingsPath, "utf-8")) as Record<string, unknown>;
+    } catch {
+      // invalid JSON — overwrite
+    }
+  }
+
+  const perms = (existing.permissions ?? {}) as Record<string, unknown>;
+  const allowed = Array.isArray(perms.allow) ? (perms.allow as string[]) : [];
+  const enabledServers = Array.isArray(existing.enabledMcpjsonServers)
+    ? (existing.enabledMcpjsonServers as string[])
+    : [];
+
+  const newAllowed = [...new Set([...allowed, ...MCP_TOOL_PERMISSIONS])];
+  const newEnabled = [...new Set([...enabledServers, "whyline"])];
+
+  const unchanged =
+    newAllowed.length === allowed.length && newEnabled.length === enabledServers.length;
+  if (unchanged) return "unchanged";
+
+  perms.allow = newAllowed;
+  existing.permissions = perms;
+  existing.enabledMcpjsonServers = newEnabled;
+
+  if (!fs.existsSync(settingsDir)) fs.mkdirSync(settingsDir, { recursive: true });
+  const wasNew = !fs.existsSync(settingsPath);
+  fs.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+  return wasNew ? "created" : "updated";
+}
+
+export async function runInstallClaude(options: { repoPath?: string }): Promise<void> {
+  const cwd = options.repoPath ?? process.cwd();
+  const repoRoot = getRepoRoot(cwd);
+
+  if (!repoRoot) {
+    console.error("Not inside a git repository. Run this command from your project root.");
+    process.exit(1);
+  }
+
+  const repoPath = repoRoot;
+
+  const mcpStatus = writeMcpJson(repoRoot);
+  const claudeStatus = writeClaudeMd(repoRoot, repoPath);
+  const settingsStatus = writeSettingsJson(repoRoot);
+
+  const label = (status: string, file: string) => {
+    const icon = status === "unchanged" ? "·" : "✓";
+    return `  ${icon}  ${file}  (${status})`;
+  };
+
+  console.log(label(mcpStatus, ".mcp.json"));
+  console.log(label(claudeStatus, "CLAUDE.md"));
+  console.log(label(settingsStatus, ".claude/settings.local.json"));
+  console.log("");
+
+  if (mcpStatus === "unchanged" && claudeStatus === "unchanged" && settingsStatus === "unchanged") {
+    console.log("Whyline is already configured in this repo.");
+  } else {
+    console.log("Done. Open this repo in Claude Code and run `whyline doctor` to verify.");
+  }
+}

package/src/commands/list.ts

@@ -0,0 +1,41 @@
+import { isInitialized, resolveConfig } from "../config.js";
+import { openDb } from "../db/connection.js";
+import { getRepoRoot } from "../git/git.js";
+import { getRepoId } from "../git/repoId.js";
+import { listMemories } from "../memory/saveMemory.js";
+import { formatMemory } from "../output/format.js";
+
+export async function runList(options: { repo: boolean; limit: string }): Promise<void> {
+  if (!isInitialized()) {
+    console.error("whyline is not initialized. Run `whyline init` first.");
+    process.exit(1);
+  }
+
+  const limit = parseInt(options.limit, 10) || 20;
+  let repoId: string | undefined;
+
+  if (options.repo) {
+    const repoRoot = getRepoRoot(process.cwd());
+    if (!repoRoot) {
+      console.error("Not inside a git repository.");
+      process.exit(1);
+    }
+    repoId = getRepoId(repoRoot);
+  }
+
+  const db = openDb(resolveConfig().storage.dbPath);
+  const memories = listMemories(db, { repoId, limit });
+  db.close();
+
+  if (memories.length === 0) {
+    console.log("No memories found.");
+    return;
+  }
+
+  for (const memory of memories) {
+    console.log(formatMemory(memory));
+    console.log("\n---");
+  }
+
+  console.log(`\n${memories.length} memory(s) shown.`);
+}

package/src/commands/mcp.ts

@@ -0,0 +1,12 @@
+import { isInitialized } from "../config.js";
+import { createMcpServer } from "../mcp/server.js";
+
+export async function runMcp(): Promise<void> {
+  if (!isInitialized()) {
+    process.stderr.write(
+      "coding-memory is not initialized. Run `coding-memory init` first.\n"
+    );
+    process.exit(1);
+  }
+  await createMcpServer();
+}

package/src/commands/save.ts

@@ -0,0 +1,85 @@
+import fs from "fs";
+import { isInitialized, resolveConfig } from "../config.js";
+import { openDb } from "../db/connection.js";
+import { getRepoContext } from "../memory/repoContext.js";
+import { parseSummary } from "../memory/parseSummary.js";
+import { redactSecrets } from "../memory/redactSecrets.js";
+import { saveMemory, generateMemoryId, buildEmbeddingText } from "../memory/saveMemory.js";
+import { checkQuality, checkDuplicates } from "../memory/qualityCheck.js";
+import type { CodingMemory } from "../memory/types.js";
+
+export async function runSave(options: { commit: string; summaryFile: string }): Promise<void> {
+  if (!isInitialized()) {
+    console.error("whyline is not initialized. Run `whyline init` first.");
+    process.exit(1);
+  }
+
+  const cwd = process.cwd();
+
+  let ctx;
+  try {
+    ctx = getRepoContext(cwd, options.commit);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(options.summaryFile)) {
+    console.error(`Error: summary file not found: ${options.summaryFile}`);
+    process.exit(1);
+  }
+
+  const rawMarkdown = fs.readFileSync(options.summaryFile, "utf-8");
+  const parsed = parseSummary(rawMarkdown);
+
+  const now = new Date().toISOString();
+  const id = generateMemoryId();
+
+  const memory: CodingMemory = {
+    id,
+    createdAt: now,
+    updatedAt: now,
+    repoId: ctx.repoId,
+    repoPath: ctx.repoPath,
+    repoName: ctx.repoName,
+    branch: ctx.branch ?? undefined,
+    commitSha: ctx.commitSha,
+    files: ctx.changedFiles,
+    tags: parsed.tags.map(redactSecrets),
+    task: parsed.task ? redactSecrets(parsed.task) : undefined,
+    intent: redactSecrets(parsed.intent),
+    summary: redactSecrets(parsed.summary),
+    decision: redactSecrets(parsed.decision),
+    why: redactSecrets(parsed.why),
+    alternativesRejected: parsed.alternativesRejected.map(redactSecrets),
+    risks: parsed.risks.map(redactSecrets),
+    followUps: parsed.followUps.map(redactSecrets),
+    source: "cli",
+    embeddingText: "",
+  };
+
+  memory.embeddingText = buildEmbeddingText(memory);
+
+  const db = openDb(resolveConfig().storage.dbPath);
+
+  const qualityWarnings = checkQuality(memory);
+  const duplicateWarnings = checkDuplicates(db, memory);
+
+  saveMemory(db, memory);
+  db.close();
+
+  console.log(`Saved memory ${memory.id}`);
+  console.log(`Repo: ${ctx.repoName}`);
+  console.log(`Commit: ${ctx.commitSha.slice(0, 8)}`);
+  console.log(`Files: ${ctx.changedFiles.length}`);
+
+  if (qualityWarnings.length > 0) {
+    console.log("\nQuality warnings:");
+    for (const w of qualityWarnings) console.warn(`  ⚠  ${w.message}`);
+  }
+
+  if (duplicateWarnings.length > 0) {
+    console.log("\nDuplicate warnings:");
+    for (const w of duplicateWarnings) console.warn(`  ⚠  ${w.message}`);
+  }
+}

package/src/commands/search.ts

@@ -0,0 +1,56 @@
+import { isInitialized, resolveConfig } from "../config.js";
+import { openDb } from "../db/connection.js";
+import { getRepoRoot } from "../git/git.js";
+import { getRepoId } from "../git/repoId.js";
+import { getFileRenameHistory } from "../git/diff.js";
+import { searchMemory } from "../memory/searchMemory.js";
+import { formatSearchResult } from "../output/format.js";
+
+export async function runSearch(
+  query: string,
+  options: { file?: string; tag?: string[]; since?: string; before?: string; limit: string }
+): Promise<void> {
+  if (!isInitialized()) {
+    console.error("whyline is not initialized. Run `whyline init` first.");
+    process.exit(1);
+  }
+
+  const limit = parseInt(options.limit, 10) || 10;
+  const cwd = process.cwd();
+
+  let repoId: string | undefined;
+  let repoPath: string | undefined;
+
+  const repoRoot = getRepoRoot(cwd);
+  if (repoRoot) {
+    repoId = getRepoId(repoRoot);
+    repoPath = repoRoot;
+  }
+
+  const files = options.file
+    ? (repoPath ? getFileRenameHistory(repoPath, options.file) : [options.file])
+    : [];
+
+  const db = openDb(resolveConfig().storage.dbPath);
+  const results = searchMemory(db, {
+    query,
+    repoId,
+    repoPath,
+    files,
+    tags: options.tag ?? [],
+    since: options.since,
+    before: options.before,
+    limit,
+  });
+  db.close();
+
+  if (results.length === 0) {
+    console.log("No memories found.");
+    return;
+  }
+
+  for (const result of results) {
+    console.log(formatSearchResult(result));
+    console.log("\n---");
+  }
+}

package/src/commands/show.ts

@@ -0,0 +1,37 @@
+import { isInitialized, resolveConfig } from "../config.js";
+import { openDb } from "../db/connection.js";
+import { getMemoryById, getMemoryByCommit } from "../memory/saveMemory.js";
+import { formatMemory } from "../output/format.js";
+
+export async function runShow(
+  id: string | undefined,
+  options: { commit?: string }
+): Promise<void> {
+  if (!isInitialized()) {
+    console.error("whyline is not initialized. Run `whyline init` first.");
+    process.exit(1);
+  }
+
+  const db = openDb(resolveConfig().storage.dbPath);
+
+  let memory = null;
+
+  if (options.commit) {
+    memory = getMemoryByCommit(db, options.commit);
+  } else if (id) {
+    memory = getMemoryById(db, id);
+  } else {
+    db.close();
+    console.error("Error: provide a memory ID or use --commit <sha>");
+    process.exit(1);
+  }
+
+  db.close();
+
+  if (!memory) {
+    console.error(`Memory not found: ${options.commit ?? id}`);
+    process.exit(1);
+  }
+
+  console.log(formatMemory(memory, true));
+}