@malindar/whyline 0.1.0

package/src/commands/stats.ts

@@ -0,0 +1,31 @@
+import { isInitialized, resolveConfig } from "../config.js";
+import { openDb } from "../db/connection.js";
+import { getStats } from "../memory/saveMemory.js";
+
+export async function runStats(): Promise<void> {
+  if (!isInitialized()) {
+    console.error("whyline is not initialized. Run `whyline init` first.");
+    process.exit(1);
+  }
+
+  const db = openDb(resolveConfig().storage.dbPath);
+  const stats = getStats(db);
+  db.close();
+
+  if (stats.total === 0) {
+    console.log("No memories stored yet.");
+    return;
+  }
+
+  console.log(`Total memories:  ${stats.total}`);
+  console.log(`Repos tracked:   ${stats.repos}`);
+  console.log(`Oldest memory:   ${stats.oldest}`);
+  console.log(`Newest memory:   ${stats.newest}`);
+
+  if (stats.topFiles.length > 0) {
+    console.log("\nMost referenced files:");
+    for (const { filePath, count } of stats.topFiles) {
+      console.log(`  ${count}x  ${filePath}`);
+    }
+  }
+}

package/src/commands/summarize.ts

@@ -0,0 +1,183 @@
+import https from "https";
+import readline from "readline";
+import { isInitialized, resolveConfig } from "../config.js";
+import { openDb } from "../db/connection.js";
+import { getMemoryById, updateMemory, buildEmbeddingText } from "../memory/saveMemory.js";
+
+type ImprovedMemory = {
+  intent: string;
+  summary: string;
+  decision: string;
+  why: string;
+  alternativesRejected: string[];
+  risks: string[];
+  followUps: string[];
+  tags: string[];
+};
+
+function buildPrompt(memory: {
+  intent: string;
+  summary: string;
+  decision: string;
+  why: string;
+  alternativesRejected: string[];
+  risks: string[];
+  followUps: string[];
+  tags: string[];
+}): string {
+  return `You are improving a coding memory record. Rewrite each field to be clearer, more specific, and more useful for a future developer session. Do not invent details that aren't implied by the original. Keep each field concise. Return ONLY valid JSON with these exact keys: intent, summary, decision, why, alternativesRejected (array), risks (array), followUps (array), tags (array).
+
+Original memory:
+${JSON.stringify(memory, null, 2)}`;
+}
+
+async function callClaudeApi(prompt: string, apiKey: string): Promise<ImprovedMemory> {
+  const body = JSON.stringify({
+    model: "claude-haiku-4-5-20251001",
+    max_tokens: 1024,
+    messages: [{ role: "user", content: prompt }],
+  });
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      {
+        hostname: "api.anthropic.com",
+        path: "/v1/messages",
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+        },
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk: Buffer) => { data += chunk.toString(); });
+        res.on("end", () => {
+          try {
+            const parsed = JSON.parse(data) as {
+              content?: Array<{ type: string; text: string }>;
+              error?: { message: string };
+            };
+            if (parsed.error) {
+              reject(new Error(`Claude API error: ${parsed.error.message}`));
+              return;
+            }
+            const text = parsed.content?.find((c) => c.type === "text")?.text ?? "";
+            // Extract JSON from the response (may be wrapped in markdown code block)
+            const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/) ?? [null, text];
+            const improved = JSON.parse(jsonMatch[1].trim()) as ImprovedMemory;
+            resolve(improved);
+          } catch (e) {
+            reject(new Error(`Failed to parse Claude response: ${String(e)}\nRaw: ${data}`));
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+function diffField(label: string, before: string | string[], after: string | string[]): string {
+  const b = Array.isArray(before) ? before.join(", ") : before;
+  const a = Array.isArray(after) ? after.join(", ") : after;
+  if (b === a) return "";
+  return `  ${label}:\n    before: ${b}\n    after:  ${a}`;
+}
+
+function showDiff(original: ImprovedMemory, improved: ImprovedMemory): void {
+  const diffs = [
+    diffField("intent", original.intent, improved.intent),
+    diffField("summary", original.summary, improved.summary),
+    diffField("decision", original.decision, improved.decision),
+    diffField("why", original.why, improved.why),
+    diffField("alternativesRejected", original.alternativesRejected, improved.alternativesRejected),
+    diffField("risks", original.risks, improved.risks),
+    diffField("followUps", original.followUps, improved.followUps),
+    diffField("tags", original.tags, improved.tags),
+  ].filter(Boolean);
+
+  if (diffs.length === 0) {
+    console.log("No changes suggested — memory is already well-written.");
+  } else {
+    console.log("\nProposed improvements:\n");
+    console.log(diffs.join("\n\n"));
+  }
+}
+
+async function confirm(question: string): Promise<boolean> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y");
+    });
+  });
+}
+
+export async function runSummarize(id: string, options: { force: boolean }): Promise<void> {
+  if (!isInitialized()) {
+    console.error("whyline is not initialized. Run `whyline init` first.");
+    process.exit(1);
+  }
+
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    console.error("ANTHROPIC_API_KEY environment variable is not set.");
+    console.error("Export it before running: export ANTHROPIC_API_KEY=your_key");
+    process.exit(1);
+  }
+
+  const db = openDb(resolveConfig().storage.dbPath);
+  const memory = getMemoryById(db, id);
+  db.close();
+
+  if (!memory) {
+    console.error(`Memory not found: ${id}`);
+    process.exit(1);
+  }
+
+  const original: ImprovedMemory = {
+    intent: memory.intent,
+    summary: memory.summary,
+    decision: memory.decision,
+    why: memory.why,
+    alternativesRejected: memory.alternativesRejected,
+    risks: memory.risks,
+    followUps: memory.followUps,
+    tags: memory.tags,
+  };
+
+  console.log(`Summarizing memory ${id}...`);
+  const improved = await callClaudeApi(buildPrompt(original), apiKey);
+
+  showDiff(original, improved);
+
+  const hasChanges =
+    JSON.stringify(original) !== JSON.stringify(improved);
+
+  if (!hasChanges) {
+    return;
+  }
+
+  const shouldSave = options.force || (await confirm("\nApply improvements? [y/N] "));
+
+  if (!shouldSave) {
+    console.log("Cancelled.");
+    return;
+  }
+
+  const db2 = openDb(resolveConfig().storage.dbPath);
+  const embeddingText = buildEmbeddingText({
+    ...memory,
+    ...improved,
+    commitSha: memory.commitSha,
+    files: memory.files,
+  });
+  updateMemory(db2, id, { ...improved, embeddingText });
+  db2.close();
+
+  console.log(`Updated memory ${id}.`);
+}

package/src/config.ts

@@ -0,0 +1,26 @@
+import os from "os";
+import path from "path";
+import fs from "fs";
+
+export const DATA_DIR = path.join(os.homedir(), ".whyline");
+export const DB_PATH = path.join(DATA_DIR, "memory.db");
+export const CONFIG_PATH = path.join(DATA_DIR, "config.json");
+
+export type AppConfig = {
+  version: number;
+  storage: {
+    dbPath: string;
+  };
+};
+
+export function resolveConfig(): AppConfig {
+  if (fs.existsSync(CONFIG_PATH)) {
+    const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
+    return JSON.parse(raw) as AppConfig;
+  }
+  return { version: 1, storage: { dbPath: DB_PATH } };
+}
+
+export function isInitialized(): boolean {
+  return fs.existsSync(DB_PATH);
+}

package/src/db/connection.ts

@@ -0,0 +1,8 @@
+import Database from "better-sqlite3";
+
+export function openDb(dbPath: string): Database.Database {
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  return db;
+}

package/src/db/migrations.ts

@@ -0,0 +1,26 @@
+import type Database from "better-sqlite3";
+import { MIGRATIONS } from "./schema.js";
+
+export function runMigrations(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS migrations (
+      version INTEGER PRIMARY KEY,
+      applied_at TEXT NOT NULL
+    );
+  `);
+
+  const applied = db
+    .prepare<[], { version: number }>("SELECT version FROM migrations ORDER BY version")
+    .all()
+    .map((r) => r.version);
+
+  const pending = MIGRATIONS.filter((m) => !applied.includes(m.version));
+
+  for (const migration of pending) {
+    db.exec(migration.sql);
+    db.prepare("INSERT INTO migrations (version, applied_at) VALUES (?, ?)").run(
+      migration.version,
+      new Date().toISOString()
+    );
+  }
+}

package/src/db/schema.ts

@@ -0,0 +1,68 @@
+export type Migration = {
+  version: number;
+  sql: string;
+};
+
+export const MIGRATIONS: Migration[] = [
+  {
+    version: 1,
+    sql: `
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        repo_id TEXT NOT NULL,
+        repo_path TEXT,
+        repo_name TEXT,
+        branch TEXT,
+        commit_sha TEXT,
+        task TEXT,
+        intent TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        decision TEXT NOT NULL,
+        why TEXT NOT NULL,
+        source TEXT NOT NULL,
+        raw_transcript_path TEXT,
+        embedding_text TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS memory_files (
+        memory_id TEXT NOT NULL,
+        file_path TEXT NOT NULL,
+        PRIMARY KEY (memory_id, file_path),
+        FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS memory_tags (
+        memory_id TEXT NOT NULL,
+        tag TEXT NOT NULL,
+        PRIMARY KEY (memory_id, tag),
+        FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS memory_alternatives (
+        memory_id TEXT NOT NULL,
+        value TEXT NOT NULL,
+        UNIQUE(memory_id, value)
+      );
+
+      CREATE TABLE IF NOT EXISTS memory_risks (
+        memory_id TEXT NOT NULL,
+        value TEXT NOT NULL,
+        UNIQUE(memory_id, value)
+      );
+
+      CREATE TABLE IF NOT EXISTS memory_followups (
+        memory_id TEXT NOT NULL,
+        value TEXT NOT NULL,
+        UNIQUE(memory_id, value)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memories_repo_id ON memories(repo_id);
+      CREATE INDEX IF NOT EXISTS idx_memories_repo_path ON memories(repo_path);
+      CREATE INDEX IF NOT EXISTS idx_memories_commit_sha ON memories(commit_sha);
+      CREATE INDEX IF NOT EXISTS idx_memory_files_file_path ON memory_files(file_path);
+      CREATE INDEX IF NOT EXISTS idx_memory_tags_tag ON memory_tags(tag);
+    `,
+  },
+];

package/src/git/diff.ts

@@ -0,0 +1,43 @@
+import { execSync } from "child_process";
+
+export function getChangedFilesForCommit(repoRoot: string, commitSha: string): string[] {
+  try {
+    // --name-status gives type + paths; we parse renames to include both old and new paths
+    const output = execSync(`git diff-tree --no-commit-id -r --name-status ${commitSha}`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+    });
+    const paths = new Set<string>();
+    for (const line of output.trim().split("\n").filter(Boolean)) {
+      const parts = line.split("\t");
+      const status = parts[0];
+      if (status.startsWith("R") || status.startsWith("C")) {
+        // Rename or copy: parts[1] = old path, parts[2] = new path
+        if (parts[1]) paths.add(parts[1]);
+        if (parts[2]) paths.add(parts[2]);
+      } else {
+        // Added, modified, deleted: parts[1] = path
+        if (parts[1]) paths.add(parts[1]);
+      }
+    }
+    return [...paths];
+  } catch {
+    return [];
+  }
+}
+
+export function getFileRenameHistory(repoRoot: string, filePath: string): string[] {
+  try {
+    const output = execSync(
+      `git log --follow --name-only --format="" -- ${filePath}`,
+      { cwd: repoRoot, encoding: "utf-8" }
+    );
+    const paths = new Set<string>([filePath]);
+    for (const line of output.trim().split("\n").filter(Boolean)) {
+      paths.add(line.trim());
+    }
+    return [...paths];
+  } catch {
+    return [filePath];
+  }
+}

package/src/git/git.ts

@@ -0,0 +1,25 @@
+import { execSync } from "child_process";
+
+export function getRepoRoot(cwd: string): string | null {
+  try {
+    return execSync("git rev-parse --show-toplevel", { cwd, encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+
+export function getCurrentBranch(repoRoot: string): string | null {
+  try {
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd: repoRoot,
+      encoding: "utf-8",
+    }).trim();
+    return branch === "HEAD" ? null : branch;
+  } catch {
+    return null;
+  }
+}
+
+export function resolveCommit(repoRoot: string, ref: string): string {
+  return execSync(`git rev-parse ${ref}`, { cwd: repoRoot, encoding: "utf-8" }).trim();
+}

package/src/git/repoId.ts

@@ -0,0 +1,49 @@
+import { execSync } from "child_process";
+import crypto from "crypto";
+import path from "path";
+
+export function normalizeRemoteUrl(url: string): string {
+  return url
+    .trim()
+    .toLowerCase()
+    .replace(/\.git$/, "")
+    .replace(/^git@([^:]+):(.+)$/, "https://$1/$2");
+}
+
+export function getRepoId(repoRoot: string): string {
+  try {
+    const remote = execSync("git config --get remote.origin.url", {
+      cwd: repoRoot,
+      encoding: "utf-8",
+    }).trim();
+    if (remote) {
+      return crypto
+        .createHash("sha256")
+        .update(normalizeRemoteUrl(remote))
+        .digest("hex")
+        .slice(0, 32);
+    }
+  } catch {
+    // no remote — fall through
+  }
+  return crypto
+    .createHash("sha256")
+    .update(path.resolve(repoRoot))
+    .digest("hex")
+    .slice(0, 32);
+}
+
+export function getRepoName(repoRoot: string): string {
+  try {
+    const remote = execSync("git config --get remote.origin.url", {
+      cwd: repoRoot,
+      encoding: "utf-8",
+    }).trim();
+    if (remote) {
+      return path.basename(normalizeRemoteUrl(remote));
+    }
+  } catch {
+    // no remote
+  }
+  return path.basename(repoRoot);
+}

package/src/hooks/post-commit.sample.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if command -v whyline >/dev/null 2>&1; then
+  echo ""
+  echo "You can save AI coding memory for this commit:"
+  echo "  whyline save --commit HEAD --summary-file memory.md"
+  echo ""
+fi