learning-agent 0.1.0

package/dist/cli.js

@@ -0,0 +1,1045 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { statSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import * as fs from 'fs/promises';
+import { mkdir, appendFile, readFile, writeFile, rename } from 'fs/promises';
+import { createHash } from 'crypto';
+import Database from 'better-sqlite3';
+import { z } from 'zod';
+import 'node-llama-cpp';
+import { homedir } from 'os';
+
+var SourceSchema = z.enum([
+  "user_correction",
+  "self_correction",
+  "test_failure",
+  "manual"
+]);
+var ContextSchema = z.object({
+  tool: z.string(),
+  intent: z.string()
+});
+var PatternSchema = z.object({
+  bad: z.string(),
+  good: z.string()
+});
+var SeveritySchema = z.enum(["high", "medium", "low"]);
+var LessonTypeSchema = z.enum(["quick", "full"]);
+var LessonSchema = z.object({
+  // Core identity (required)
+  id: z.string(),
+  type: LessonTypeSchema,
+  trigger: z.string(),
+  insight: z.string(),
+  // Metadata (required)
+  tags: z.array(z.string()),
+  source: SourceSchema,
+  context: ContextSchema,
+  created: z.string(),
+  // ISO8601
+  confirmed: z.boolean(),
+  // Relationships (required, can be empty arrays)
+  supersedes: z.array(z.string()),
+  related: z.array(z.string()),
+  // Extended fields (optional - typically present for 'full' type)
+  evidence: z.string().optional(),
+  severity: SeveritySchema.optional(),
+  pattern: PatternSchema.optional(),
+  // Lifecycle fields (optional)
+  deleted: z.boolean().optional(),
+  retrievalCount: z.number().optional()
+});
+z.object({
+  id: z.string(),
+  deleted: z.literal(true),
+  deletedAt: z.string()
+  // ISO8601
+});
+function generateId(insight) {
+  const hash = createHash("sha256").update(insight).digest("hex");
+  return `L${hash.slice(0, 8)}`;
+}
+
+// src/storage/jsonl.ts
+var LESSONS_PATH = ".claude/lessons/index.jsonl";
+async function appendLesson(repoRoot, lesson) {
+  const filePath = join(repoRoot, LESSONS_PATH);
+  await mkdir(dirname(filePath), { recursive: true });
+  const line = JSON.stringify(lesson) + "\n";
+  await appendFile(filePath, line, "utf-8");
+}
+function parseJsonLine(line, lineNumber, strict, onParseError) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch (err) {
+    const parseError = {
+      line: lineNumber,
+      message: `Invalid JSON: ${err.message}`,
+      cause: err
+    };
+    if (strict) {
+      throw new Error(`Parse error on line ${lineNumber}: ${parseError.message}`);
+    }
+    onParseError?.(parseError);
+    return null;
+  }
+  const result = LessonSchema.safeParse(parsed);
+  if (!result.success) {
+    const parseError = {
+      line: lineNumber,
+      message: `Schema validation failed: ${result.error.message}`,
+      cause: result.error
+    };
+    if (strict) {
+      throw new Error(`Parse error on line ${lineNumber}: ${parseError.message}`);
+    }
+    onParseError?.(parseError);
+    return null;
+  }
+  return result.data;
+}
+async function readLessons(repoRoot, options = {}) {
+  const { strict = false, onParseError } = options;
+  const filePath = join(repoRoot, LESSONS_PATH);
+  let content;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { lessons: [], skippedCount: 0 };
+    }
+    throw err;
+  }
+  const lessons = /* @__PURE__ */ new Map();
+  let skippedCount = 0;
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed) continue;
+    const lesson = parseJsonLine(trimmed, i + 1, strict, onParseError);
+    if (!lesson) {
+      skippedCount++;
+      continue;
+    }
+    if (lesson.deleted) {
+      lessons.delete(lesson.id);
+    } else {
+      lessons.set(lesson.id, lesson);
+    }
+  }
+  return { lessons: Array.from(lessons.values()), skippedCount };
+}
+
+// src/storage/sqlite.ts
+var DB_PATH = ".claude/.cache/lessons.sqlite";
+var SCHEMA_SQL = `
+  -- Main lessons table
+  CREATE TABLE IF NOT EXISTS lessons (
+    id TEXT PRIMARY KEY,
+    type TEXT NOT NULL,
+    trigger TEXT NOT NULL,
+    insight TEXT NOT NULL,
+    evidence TEXT,
+    severity TEXT,
+    tags TEXT NOT NULL DEFAULT '',
+    source TEXT NOT NULL,
+    context TEXT NOT NULL DEFAULT '{}',
+    supersedes TEXT NOT NULL DEFAULT '[]',
+    related TEXT NOT NULL DEFAULT '[]',
+    created TEXT NOT NULL,
+    confirmed INTEGER NOT NULL DEFAULT 0,
+    deleted INTEGER NOT NULL DEFAULT 0,
+    retrieval_count INTEGER NOT NULL DEFAULT 0,
+    last_retrieved TEXT,
+    embedding BLOB,
+    content_hash TEXT
+  );
+
+  -- FTS5 virtual table for full-text search
+  CREATE VIRTUAL TABLE IF NOT EXISTS lessons_fts USING fts5(
+    id,
+    trigger,
+    insight,
+    tags,
+    content='lessons',
+    content_rowid='rowid'
+  );
+
+  -- Trigger to sync FTS on INSERT
+  CREATE TRIGGER IF NOT EXISTS lessons_ai AFTER INSERT ON lessons BEGIN
+    INSERT INTO lessons_fts(rowid, id, trigger, insight, tags)
+    VALUES (new.rowid, new.id, new.trigger, new.insight, new.tags);
+  END;
+
+  -- Trigger to sync FTS on DELETE
+  CREATE TRIGGER IF NOT EXISTS lessons_ad AFTER DELETE ON lessons BEGIN
+    INSERT INTO lessons_fts(lessons_fts, rowid, id, trigger, insight, tags)
+    VALUES ('delete', old.rowid, old.id, old.trigger, old.insight, old.tags);
+  END;
+
+  -- Trigger to sync FTS on UPDATE
+  CREATE TRIGGER IF NOT EXISTS lessons_au AFTER UPDATE ON lessons BEGIN
+    INSERT INTO lessons_fts(lessons_fts, rowid, id, trigger, insight, tags)
+    VALUES ('delete', old.rowid, old.id, old.trigger, old.insight, old.tags);
+    INSERT INTO lessons_fts(rowid, id, trigger, insight, tags)
+    VALUES (new.rowid, new.id, new.trigger, new.insight, new.tags);
+  END;
+
+  -- Index for common queries
+  CREATE INDEX IF NOT EXISTS idx_lessons_created ON lessons(created);
+  CREATE INDEX IF NOT EXISTS idx_lessons_confirmed ON lessons(confirmed);
+  CREATE INDEX IF NOT EXISTS idx_lessons_severity ON lessons(severity);
+
+  -- Metadata table for sync tracking
+  CREATE TABLE IF NOT EXISTS metadata (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+`;
+function createSchema(database) {
+  database.exec(SCHEMA_SQL);
+}
+var db = null;
+function contentHash(trigger, insight) {
+  return createHash("sha256").update(`${trigger} ${insight}`).digest("hex");
+}
+function openDb(repoRoot) {
+  if (db) return db;
+  const dbPath = join(repoRoot, DB_PATH);
+  const dir = dirname(dbPath);
+  mkdirSync(dir, { recursive: true });
+  db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  createSchema(db);
+  return db;
+}
+function rowToLesson(row) {
+  const lesson = {
+    id: row.id,
+    type: row.type,
+    trigger: row.trigger,
+    insight: row.insight,
+    tags: row.tags ? row.tags.split(",").filter(Boolean) : [],
+    source: row.source,
+    context: JSON.parse(row.context),
+    supersedes: JSON.parse(row.supersedes),
+    related: JSON.parse(row.related),
+    created: row.created,
+    confirmed: row.confirmed === 1
+  };
+  if (row.evidence !== null) {
+    lesson.evidence = row.evidence;
+  }
+  if (row.severity !== null) {
+    lesson.severity = row.severity;
+  }
+  if (row.deleted === 1) {
+    lesson.deleted = true;
+  }
+  if (row.retrieval_count > 0) {
+    lesson.retrievalCount = row.retrieval_count;
+  }
+  return lesson;
+}
+function collectCachedEmbeddings(database) {
+  const cache = /* @__PURE__ */ new Map();
+  const rows = database.prepare("SELECT id, embedding, content_hash FROM lessons WHERE embedding IS NOT NULL").all();
+  for (const row of rows) {
+    if (row.embedding && row.content_hash) {
+      cache.set(row.id, { embedding: row.embedding, contentHash: row.content_hash });
+    }
+  }
+  return cache;
+}
+var INSERT_LESSON_SQL = `
+  INSERT INTO lessons (id, type, trigger, insight, evidence, severity, tags, source, context, supersedes, related, created, confirmed, deleted, retrieval_count, last_retrieved, embedding, content_hash)
+  VALUES (@id, @type, @trigger, @insight, @evidence, @severity, @tags, @source, @context, @supersedes, @related, @created, @confirmed, @deleted, @retrieval_count, @last_retrieved, @embedding, @content_hash)
+`;
+function getJsonlMtime(repoRoot) {
+  const jsonlPath = join(repoRoot, LESSONS_PATH);
+  try {
+    const stat = statSync(jsonlPath);
+    return stat.mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function getLastSyncMtime(database) {
+  const row = database.prepare("SELECT value FROM metadata WHERE key = ?").get("last_sync_mtime");
+  return row ? parseFloat(row.value) : null;
+}
+function setLastSyncMtime(database, mtime) {
+  database.prepare("INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)").run("last_sync_mtime", mtime.toString());
+}
+async function rebuildIndex(repoRoot) {
+  const database = openDb(repoRoot);
+  const { lessons } = await readLessons(repoRoot);
+  const cachedEmbeddings = collectCachedEmbeddings(database);
+  database.exec("DELETE FROM lessons");
+  if (lessons.length === 0) {
+    const mtime2 = getJsonlMtime(repoRoot);
+    if (mtime2 !== null) {
+      setLastSyncMtime(database, mtime2);
+    }
+    return;
+  }
+  const insert = database.prepare(INSERT_LESSON_SQL);
+  const insertMany = database.transaction((items) => {
+    for (const lesson of items) {
+      const newHash = contentHash(lesson.trigger, lesson.insight);
+      const cached = cachedEmbeddings.get(lesson.id);
+      const hasValidCache = cached && cached.contentHash === newHash;
+      insert.run({
+        id: lesson.id,
+        type: lesson.type,
+        trigger: lesson.trigger,
+        insight: lesson.insight,
+        evidence: lesson.evidence ?? null,
+        severity: lesson.severity ?? null,
+        tags: lesson.tags.join(","),
+        source: lesson.source,
+        context: JSON.stringify(lesson.context),
+        supersedes: JSON.stringify(lesson.supersedes),
+        related: JSON.stringify(lesson.related),
+        created: lesson.created,
+        confirmed: lesson.confirmed ? 1 : 0,
+        deleted: lesson.deleted ? 1 : 0,
+        retrieval_count: lesson.retrievalCount ?? 0,
+        last_retrieved: null,
+        // Reset on rebuild since we're rebuilding from source
+        embedding: hasValidCache ? cached.embedding : null,
+        content_hash: hasValidCache ? cached.contentHash : null
+      });
+    }
+  });
+  insertMany(lessons);
+  const mtime = getJsonlMtime(repoRoot);
+  if (mtime !== null) {
+    setLastSyncMtime(database, mtime);
+  }
+}
+async function syncIfNeeded(repoRoot, options = {}) {
+  const { force = false } = options;
+  const jsonlMtime = getJsonlMtime(repoRoot);
+  if (jsonlMtime === null && !force) {
+    return false;
+  }
+  const database = openDb(repoRoot);
+  const lastSyncMtime = getLastSyncMtime(database);
+  const needsRebuild = force || lastSyncMtime === null || jsonlMtime !== null && jsonlMtime > lastSyncMtime;
+  if (needsRebuild) {
+    await rebuildIndex(repoRoot);
+    return true;
+  }
+  return false;
+}
+async function searchKeyword(repoRoot, query, limit) {
+  const database = openDb(repoRoot);
+  const countResult = database.prepare("SELECT COUNT(*) as cnt FROM lessons").get();
+  if (countResult.cnt === 0) return [];
+  const rows = database.prepare(
+    `
+      SELECT l.*
+      FROM lessons l
+      JOIN lessons_fts fts ON l.rowid = fts.rowid
+      WHERE lessons_fts MATCH ?
+      LIMIT ?
+    `
+  ).all(query, limit);
+  if (rows.length > 0) {
+    incrementRetrievalCount(repoRoot, rows.map((r) => r.id));
+  }
+  return rows.map(rowToLesson);
+}
+function incrementRetrievalCount(repoRoot, lessonIds) {
+  if (lessonIds.length === 0) return;
+  const database = openDb(repoRoot);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const update = database.prepare(`
+    UPDATE lessons
+    SET retrieval_count = retrieval_count + 1,
+        last_retrieved = ?
+    WHERE id = ?
+  `);
+  const updateMany = database.transaction((ids) => {
+    for (const id of ids) {
+      update.run(now, id);
+    }
+  });
+  updateMany(lessonIds);
+}
+function getRetrievalStats(repoRoot) {
+  const database = openDb(repoRoot);
+  const rows = database.prepare("SELECT id, retrieval_count, last_retrieved FROM lessons").all();
+  return rows.map((row) => ({
+    id: row.id,
+    count: row.retrieval_count,
+    lastRetrieved: row.last_retrieved
+  }));
+}
+
+// src/capture/quality.ts
+var DEFAULT_SIMILARITY_THRESHOLD = 0.8;
+async function isNovel(repoRoot, insight, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_SIMILARITY_THRESHOLD;
+  await syncIfNeeded(repoRoot);
+  const words = insight.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 3).slice(0, 3);
+  if (words.length === 0) {
+    return { novel: true };
+  }
+  const searchQuery = words.join(" OR ");
+  const results = await searchKeyword(repoRoot, searchQuery, 10);
+  if (results.length === 0) {
+    return { novel: true };
+  }
+  const insightWords = new Set(insight.toLowerCase().split(/\s+/));
+  for (const lesson of results) {
+    const lessonWords = new Set(lesson.insight.toLowerCase().split(/\s+/));
+    const intersection = [...insightWords].filter((w) => lessonWords.has(w)).length;
+    const union = (/* @__PURE__ */ new Set([...insightWords, ...lessonWords])).size;
+    const similarity = union > 0 ? intersection / union : 0;
+    if (similarity >= threshold) {
+      return {
+        novel: false,
+        reason: `Found similar existing lesson: "${lesson.insight.slice(0, 50)}..."`,
+        existingId: lesson.id
+      };
+    }
+    if (lesson.insight.toLowerCase() === insight.toLowerCase()) {
+      return {
+        novel: false,
+        reason: `Exact duplicate found`,
+        existingId: lesson.id
+      };
+    }
+  }
+  return { novel: true };
+}
+var MIN_WORD_COUNT = 4;
+var VAGUE_PATTERNS = [
+  /\bwrite better\b/i,
+  /\bbe careful\b/i,
+  /\bremember to\b/i,
+  /\bmake sure\b/i,
+  /\btry to\b/i,
+  /\bdouble check\b/i
+];
+var GENERIC_IMPERATIVE_PATTERN = /^(always|never)\s+\w+(\s+\w+){0,2}$/i;
+function isSpecific(insight) {
+  const words = insight.trim().split(/\s+/).filter((w) => w.length > 0);
+  if (words.length < MIN_WORD_COUNT) {
+    return { specific: false, reason: "Insight is too short to be actionable" };
+  }
+  for (const pattern of VAGUE_PATTERNS) {
+    if (pattern.test(insight)) {
+      return { specific: false, reason: "Insight matches a vague pattern" };
+    }
+  }
+  if (GENERIC_IMPERATIVE_PATTERN.test(insight)) {
+    return { specific: false, reason: "Insight matches a vague pattern" };
+  }
+  return { specific: true };
+}
+var ACTION_PATTERNS = [
+  /\buse\s+.+\s+instead\s+of\b/i,
+  // "use X instead of Y"
+  /\bprefer\s+.+\s+(over|to)\b/i,
+  // "prefer X over Y" or "prefer X to Y"
+  /\balways\s+.+\s+when\b/i,
+  // "always X when Y"
+  /\bnever\s+.+\s+without\b/i,
+  // "never X without Y"
+  /\bavoid\s+(using\s+)?\w+/i,
+  // "avoid X" or "avoid using X"
+  /\bcheck\s+.+\s+before\b/i,
+  // "check X before Y"
+  /^(run|use|add|remove|install|update|configure|set|enable|disable)\s+/i
+  // Imperative commands at start
+];
+function isActionable(insight) {
+  for (const pattern of ACTION_PATTERNS) {
+    if (pattern.test(insight)) {
+      return { actionable: true };
+    }
+  }
+  return { actionable: false, reason: "Insight lacks clear action guidance" };
+}
+async function shouldPropose(repoRoot, insight) {
+  const specificResult = isSpecific(insight);
+  if (!specificResult.specific) {
+    return { shouldPropose: false, reason: specificResult.reason };
+  }
+  const actionableResult = isActionable(insight);
+  if (!actionableResult.actionable) {
+    return { shouldPropose: false, reason: actionableResult.reason };
+  }
+  const noveltyResult = await isNovel(repoRoot, insight);
+  if (!noveltyResult.novel) {
+    return { shouldPropose: false, reason: noveltyResult.reason };
+  }
+  return { shouldPropose: true };
+}
+
+// src/capture/triggers.ts
+var USER_CORRECTION_PATTERNS = [
+  /\bno\b[,.]?\s/i,
+  // "no, ..." or "no ..."
+  /\bwrong\b/i,
+  // "wrong"
+  /\bactually\b/i,
+  // "actually..."
+  /\bnot that\b/i,
+  // "not that"
+  /\bi meant\b/i
+  // "I meant"
+];
+function detectUserCorrection(signals) {
+  const { messages, context } = signals;
+  if (messages.length < 2) {
+    return null;
+  }
+  for (let i = 1; i < messages.length; i++) {
+    const message = messages[i];
+    if (!message) continue;
+    for (const pattern of USER_CORRECTION_PATTERNS) {
+      if (pattern.test(message)) {
+        return {
+          trigger: `User correction during ${context.intent}`,
+          correctionMessage: message,
+          context
+        };
+      }
+    }
+  }
+  return null;
+}
+function detectSelfCorrection(history) {
+  const { edits } = history;
+  if (edits.length < 3) {
+    return null;
+  }
+  for (let i = 0; i <= edits.length - 3; i++) {
+    const first = edits[i];
+    const second = edits[i + 1];
+    const third = edits[i + 2];
+    if (!first || !second || !third) continue;
+    if (first.file === second.file && second.file === third.file && first.success && !second.success && third.success) {
+      return {
+        file: first.file,
+        trigger: `Self-correction on ${first.file}`
+      };
+    }
+  }
+  return null;
+}
+function detectTestFailure(testResult) {
+  if (testResult.passed) {
+    return null;
+  }
+  const lines = testResult.output.split("\n").filter((line) => line.trim().length > 0);
+  const errorLine = lines.find((line) => /error|fail|assert/i.test(line)) ?? lines[0] ?? "";
+  return {
+    testFile: testResult.testFile,
+    errorOutput: testResult.output,
+    trigger: `Test failure in ${testResult.testFile}: ${errorLine.slice(0, 100)}`
+  };
+}
+
+// src/capture/integration.ts
+async function detectAndPropose(repoRoot, input) {
+  const detected = runDetector(input);
+  if (!detected) {
+    return null;
+  }
+  const { trigger, source, proposedInsight } = detected;
+  const quality = await shouldPropose(repoRoot, proposedInsight);
+  if (!quality.shouldPropose) {
+    return null;
+  }
+  return { trigger, source, proposedInsight };
+}
+function runDetector(input) {
+  switch (input.type) {
+    case "user":
+      return detectUserCorrectionFlow(input.data);
+    case "self":
+      return detectSelfCorrectionFlow(input.data);
+    case "test":
+      return detectTestFailureFlow(input.data);
+  }
+}
+function detectUserCorrectionFlow(data) {
+  const result = detectUserCorrection(data);
+  if (!result) {
+    return null;
+  }
+  return {
+    trigger: result.trigger,
+    source: "user_correction",
+    proposedInsight: result.correctionMessage
+  };
+}
+function detectSelfCorrectionFlow(data) {
+  const result = detectSelfCorrection(data);
+  if (!result) {
+    return null;
+  }
+  return {
+    trigger: result.trigger,
+    source: "self_correction",
+    // Self-corrections need context to form useful insights
+    proposedInsight: `Check ${result.file} for common errors before editing`
+  };
+}
+function detectTestFailureFlow(data) {
+  const result = detectTestFailure(data);
+  if (!result) {
+    return null;
+  }
+  return {
+    trigger: result.trigger,
+    source: "test_failure",
+    proposedInsight: result.errorOutput
+  };
+}
+var VALID_TYPES = /* @__PURE__ */ new Set(["user", "self", "test"]);
+async function parseInputFile(filePath) {
+  const content = await fs.readFile(filePath, "utf-8");
+  const data = JSON.parse(content);
+  if (!VALID_TYPES.has(data.type)) {
+    throw new Error(`Invalid detection type: ${data.type}. Must be one of: user, self, test`);
+  }
+  return data;
+}
+
+// src/cli-utils.ts
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  if (bytes < 1024) return `${bytes} B`;
+  const kb = bytes / 1024;
+  if (kb < 1024) return `${kb.toFixed(1)} KB`;
+  const mb = kb / 1024;
+  return `${mb.toFixed(1)} MB`;
+}
+function parseLimit(value, name) {
+  const parsed = parseInt(value, 10);
+  if (Number.isNaN(parsed) || parsed <= 0) {
+    throw new Error(`Invalid ${name}: must be a positive integer`);
+  }
+  return parsed;
+}
+function getRepoRoot() {
+  return process.env["LEARNING_AGENT_ROOT"] ?? process.cwd();
+}
+join(homedir(), ".node-llama-cpp", "models");
+
+// src/index.ts
+var VERSION = "0.1.0";
+var ARCHIVE_DIR = ".claude/lessons/archive";
+var TOMBSTONE_THRESHOLD = 100;
+var ARCHIVE_AGE_DAYS = 90;
+var MS_PER_DAY = 1e3 * 60 * 60 * 24;
+var MONTH_INDEX_OFFSET = 1;
+var MONTH_PAD_LENGTH = 2;
+function getArchivePath(repoRoot, date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + MONTH_INDEX_OFFSET).padStart(MONTH_PAD_LENGTH, "0");
+  return join(repoRoot, ARCHIVE_DIR, `${year}-${month}.jsonl`);
+}
+async function parseRawJsonlLines(repoRoot) {
+  const filePath = join(repoRoot, LESSONS_PATH);
+  let content;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      results.push({ line: trimmed, parsed });
+    } catch {
+      results.push({ line: trimmed, parsed: null });
+    }
+  }
+  return results;
+}
+async function countTombstones(repoRoot) {
+  const lines = await parseRawJsonlLines(repoRoot);
+  let count = 0;
+  for (const { parsed } of lines) {
+    if (parsed && parsed["deleted"] === true) {
+      count++;
+    }
+  }
+  return count;
+}
+async function needsCompaction(repoRoot) {
+  const count = await countTombstones(repoRoot);
+  return count >= TOMBSTONE_THRESHOLD;
+}
+async function rewriteWithoutTombstones(repoRoot) {
+  const filePath = join(repoRoot, LESSONS_PATH);
+  const tempPath = filePath + ".tmp";
+  const { lessons } = await readLessons(repoRoot);
+  const tombstoneCount = await countTombstones(repoRoot);
+  await mkdir(dirname(filePath), { recursive: true });
+  const lines = lessons.map((lesson) => JSON.stringify(lesson) + "\n");
+  await writeFile(tempPath, lines.join(""), "utf-8");
+  await rename(tempPath, filePath);
+  return tombstoneCount;
+}
+function shouldArchive(lesson, now) {
+  const created = new Date(lesson.created);
+  const ageMs = now.getTime() - created.getTime();
+  const ageDays = ageMs / MS_PER_DAY;
+  return ageDays > ARCHIVE_AGE_DAYS && (lesson.retrievalCount === void 0 || lesson.retrievalCount === 0);
+}
+async function archiveOldLessons(repoRoot) {
+  const { lessons } = await readLessons(repoRoot);
+  const now = /* @__PURE__ */ new Date();
+  const toArchive = [];
+  const toKeep = [];
+  for (const lesson of lessons) {
+    if (shouldArchive(lesson, now)) {
+      toArchive.push(lesson);
+    } else {
+      toKeep.push(lesson);
+    }
+  }
+  if (toArchive.length === 0) {
+    return 0;
+  }
+  const archiveGroups = /* @__PURE__ */ new Map();
+  for (const lesson of toArchive) {
+    const created = new Date(lesson.created);
+    const archivePath = getArchivePath(repoRoot, created);
+    const group = archiveGroups.get(archivePath) ?? [];
+    group.push(lesson);
+    archiveGroups.set(archivePath, group);
+  }
+  const archiveDir = join(repoRoot, ARCHIVE_DIR);
+  await mkdir(archiveDir, { recursive: true });
+  for (const [archivePath, archiveLessons] of archiveGroups) {
+    const lines2 = archiveLessons.map((l) => JSON.stringify(l) + "\n").join("");
+    await appendFile(archivePath, lines2, "utf-8");
+  }
+  const filePath = join(repoRoot, LESSONS_PATH);
+  const tempPath = filePath + ".tmp";
+  await mkdir(dirname(filePath), { recursive: true });
+  const lines = toKeep.map((lesson) => JSON.stringify(lesson) + "\n");
+  await writeFile(tempPath, lines.join(""), "utf-8");
+  await rename(tempPath, filePath);
+  return toArchive.length;
+}
+async function compact(repoRoot) {
+  const tombstonesBefore = await countTombstones(repoRoot);
+  const archived = await archiveOldLessons(repoRoot);
+  const tombstonesAfterArchive = await countTombstones(repoRoot);
+  await rewriteWithoutTombstones(repoRoot);
+  const tombstonesRemoved = archived > 0 ? tombstonesBefore : tombstonesAfterArchive;
+  const { lessons } = await readLessons(repoRoot);
+  return {
+    archived,
+    tombstonesRemoved,
+    lessonsRemaining: lessons.length
+  };
+}
+
+// src/cli.ts
+var out = {
+  success: (msg) => console.log(chalk.green("[ok]"), msg),
+  error: (msg) => console.error(chalk.red("[error]"), msg),
+  info: (msg) => console.log(chalk.blue("[info]"), msg),
+  warn: (msg) => console.log(chalk.yellow("[warn]"), msg)
+};
+function getGlobalOpts(cmd) {
+  const opts = cmd.optsWithGlobals();
+  return {
+    verbose: opts.verbose ?? false,
+    quiet: opts.quiet ?? false
+  };
+}
+var DEFAULT_SEARCH_LIMIT = "10";
+var DEFAULT_LIST_LIMIT = "20";
+var program = new Command();
+program.option("-v, --verbose", "Show detailed output").option("-q, --quiet", "Suppress non-essential output");
+program.name("learning-agent").description("Repository-scoped learning system for Claude Code").version(VERSION);
+program.command("learn <insight>").description("Capture a new lesson").option("-t, --trigger <text>", "What triggered this lesson").option("--tags <tags>", "Comma-separated tags", "").option("-y, --yes", "Skip confirmation").action(async function(insight, options) {
+  const repoRoot = getRepoRoot();
+  const { quiet } = getGlobalOpts(this);
+  const lesson = {
+    id: generateId(insight),
+    type: "quick",
+    trigger: options.trigger ?? "Manual capture",
+    insight,
+    tags: options.tags ? options.tags.split(",").map((t) => t.trim()) : [],
+    source: "manual",
+    context: {
+      tool: "cli",
+      intent: "manual learning"
+    },
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    confirmed: options.yes ?? false,
+    supersedes: [],
+    related: []
+  };
+  await appendLesson(repoRoot, lesson);
+  out.success(`Learned: ${insight}`);
+  if (!quiet) {
+    console.log(`ID: ${chalk.dim(lesson.id)}`);
+  }
+});
+program.command("search <query>").description("Search lessons by keyword").option("-n, --limit <number>", "Maximum results", DEFAULT_SEARCH_LIMIT).action(async function(query, options) {
+  const repoRoot = getRepoRoot();
+  const limit = parseLimit(options.limit, "limit");
+  const { verbose, quiet } = getGlobalOpts(this);
+  await syncIfNeeded(repoRoot);
+  const results = await searchKeyword(repoRoot, query, limit);
+  if (results.length === 0) {
+    console.log('No lessons match your search. Try a different query or use "list" to see all lessons.');
+    return;
+  }
+  if (!quiet) {
+    out.info(`Found ${results.length} lesson(s):
+`);
+  }
+  for (const lesson of results) {
+    console.log(`[${chalk.cyan(lesson.id)}] ${lesson.insight}`);
+    console.log(`  Trigger: ${lesson.trigger}`);
+    if (verbose && lesson.context) {
+      console.log(`  Context: ${lesson.context.tool} - ${lesson.context.intent}`);
+      console.log(`  Created: ${lesson.created}`);
+    }
+    if (lesson.tags.length > 0) {
+      console.log(`  Tags: ${lesson.tags.join(", ")}`);
+    }
+    console.log();
+  }
+});
+program.command("list").description("List all lessons").option("-n, --limit <number>", "Maximum results", DEFAULT_LIST_LIMIT).action(async function(options) {
+  const repoRoot = getRepoRoot();
+  const limit = parseLimit(options.limit, "limit");
+  const { verbose, quiet } = getGlobalOpts(this);
+  const { lessons, skippedCount } = await readLessons(repoRoot);
+  if (lessons.length === 0) {
+    console.log('No lessons found. Get started with: learn "Your first lesson"');
+    if (skippedCount > 0) {
+      out.warn(`${skippedCount} corrupted lesson(s) skipped.`);
+    }
+    return;
+  }
+  const toShow = lessons.slice(0, limit);
+  if (!quiet) {
+    out.info(`Showing ${toShow.length} of ${lessons.length} lesson(s):
+`);
+  }
+  for (const lesson of toShow) {
+    console.log(`[${chalk.cyan(lesson.id)}] ${lesson.insight}`);
+    if (verbose) {
+      console.log(`  Type: ${lesson.type} | Source: ${lesson.source}`);
+      console.log(`  Created: ${lesson.created}`);
+      if (lesson.context) {
+        console.log(`  Context: ${lesson.context.tool} - ${lesson.context.intent}`);
+      }
+    } else {
+      console.log(`  Type: ${lesson.type} | Source: ${lesson.source}`);
+    }
+    if (lesson.tags.length > 0) {
+      console.log(`  Tags: ${lesson.tags.join(", ")}`);
+    }
+    console.log();
+  }
+  if (skippedCount > 0) {
+    out.warn(`${skippedCount} corrupted lesson(s) skipped.`);
+  }
+});
+program.command("rebuild").description("Rebuild SQLite index from JSONL").option("-f, --force", "Force rebuild even if unchanged").action(async (options) => {
+  const repoRoot = getRepoRoot();
+  if (options.force) {
+    console.log("Forcing index rebuild...");
+    await rebuildIndex(repoRoot);
+    console.log("Index rebuilt.");
+  } else {
+    const rebuilt = await syncIfNeeded(repoRoot);
+    if (rebuilt) {
+      console.log("Index rebuilt (JSONL changed).");
+    } else {
+      console.log("Index is up to date.");
+    }
+  }
+});
+program.command("detect").description("Detect learning triggers from input").requiredOption("--input <file>", "Path to JSON input file").option("--save", "Automatically save proposed lesson").option("--json", "Output result as JSON").action(
+  async (options) => {
+    const repoRoot = getRepoRoot();
+    const input = await parseInputFile(options.input);
+    const result = await detectAndPropose(repoRoot, input);
+    if (!result) {
+      if (options.json) {
+        console.log(JSON.stringify({ detected: false }));
+      } else {
+        console.log("No learning trigger detected.");
+      }
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify({ detected: true, ...result }));
+      return;
+    }
+    console.log("Learning trigger detected!");
+    console.log(`  Trigger: ${result.trigger}`);
+    console.log(`  Source: ${result.source}`);
+    console.log(`  Proposed: ${result.proposedInsight}`);
+    if (options.save) {
+      const lesson = {
+        id: generateId(result.proposedInsight),
+        type: "quick",
+        trigger: result.trigger,
+        insight: result.proposedInsight,
+        tags: [],
+        source: result.source,
+        context: { tool: "detect", intent: "auto-capture" },
+        created: (/* @__PURE__ */ new Date()).toISOString(),
+        confirmed: false,
+        supersedes: [],
+        related: []
+      };
+      await appendLesson(repoRoot, lesson);
+      console.log(`
+Saved as lesson: ${lesson.id}`);
+    }
+  }
+);
+program.command("compact").description("Compact lessons: archive old lessons and remove tombstones").option("-f, --force", "Run compaction even if below threshold").option("--dry-run", "Show what would be done without making changes").action(async (options) => {
+  const repoRoot = getRepoRoot();
+  const tombstones = await countTombstones(repoRoot);
+  const needs = await needsCompaction(repoRoot);
+  if (options.dryRun) {
+    console.log("Dry run - no changes will be made.\n");
+    console.log(`Tombstones found: ${tombstones}`);
+    console.log(`Compaction needed: ${needs ? "yes" : "no"}`);
+    return;
+  }
+  if (!needs && !options.force) {
+    console.log(`Compaction not needed (${tombstones} tombstones, threshold is ${TOMBSTONE_THRESHOLD}).`);
+    console.log("Use --force to compact anyway.");
+    return;
+  }
+  console.log("Running compaction...");
+  const result = await compact(repoRoot);
+  console.log("\nCompaction complete:");
+  console.log(`  Archived: ${result.archived} lesson(s)`);
+  console.log(`  Tombstones removed: ${result.tombstonesRemoved}`);
+  console.log(`  Lessons remaining: ${result.lessonsRemaining}`);
+  await rebuildIndex(repoRoot);
+  console.log("  Index rebuilt.");
+});
+program.command("export").description("Export lessons as JSON to stdout").option("--since <date>", "Only include lessons created after this date (ISO8601)").option("--tags <tags>", "Filter by tags (comma-separated, OR logic)").action(async (options) => {
+  const repoRoot = getRepoRoot();
+  const { lessons } = await readLessons(repoRoot);
+  let filtered = lessons;
+  if (options.since) {
+    const sinceDate = new Date(options.since);
+    if (Number.isNaN(sinceDate.getTime())) {
+      console.error(`Invalid date format: ${options.since}. Use ISO8601 format (e.g., 2024-01-15).`);
+      process.exit(1);
+    }
+    filtered = filtered.filter((lesson) => new Date(lesson.created) >= sinceDate);
+  }
+  if (options.tags) {
+    const filterTags = options.tags.split(",").map((t) => t.trim());
+    filtered = filtered.filter((lesson) => lesson.tags.some((tag) => filterTags.includes(tag)));
+  }
+  console.log(JSON.stringify(filtered, null, 2));
+});
+program.command("import <file>").description("Import lessons from a JSONL file").action(async (file) => {
+  const repoRoot = getRepoRoot();
+  let content;
+  try {
+    const { readFile: readFile4 } = await import('fs/promises');
+    content = await readFile4(file, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      console.error(`Error: File not found: ${file}`);
+    } else {
+      console.error(`Error reading file: ${err.message}`);
+    }
+    process.exit(1);
+  }
+  const { lessons: existingLessons } = await readLessons(repoRoot);
+  const existingIds = new Set(existingLessons.map((l) => l.id));
+  const lines = content.split("\n");
+  let imported = 0;
+  let skipped = 0;
+  let invalid = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      invalid++;
+      continue;
+    }
+    const result = LessonSchema.safeParse(parsed);
+    if (!result.success) {
+      invalid++;
+      continue;
+    }
+    const lesson = result.data;
+    if (existingIds.has(lesson.id)) {
+      skipped++;
+      continue;
+    }
+    await appendLesson(repoRoot, lesson);
+    existingIds.add(lesson.id);
+    imported++;
+  }
+  const lessonWord = imported === 1 ? "lesson" : "lessons";
+  const parts = [];
+  if (skipped > 0) parts.push(`${skipped} skipped`);
+  if (invalid > 0) parts.push(`${invalid} invalid`);
+  if (parts.length > 0) {
+    console.log(`Imported ${imported} ${lessonWord} (${parts.join(", ")})`);
+  } else {
+    console.log(`Imported ${imported} ${lessonWord}`);
+  }
+});
+program.command("stats").description("Show database health and statistics").action(async () => {
+  const repoRoot = getRepoRoot();
+  await syncIfNeeded(repoRoot);
+  const { lessons } = await readLessons(repoRoot);
+  const deletedCount = await countTombstones(repoRoot);
+  const totalLessons = lessons.length;
+  const retrievalStats = getRetrievalStats(repoRoot);
+  const totalRetrievals = retrievalStats.reduce((sum, s) => sum + s.count, 0);
+  const avgRetrievals = totalLessons > 0 ? (totalRetrievals / totalLessons).toFixed(1) : "0.0";
+  const jsonlPath = join(repoRoot, LESSONS_PATH);
+  const dbPath = join(repoRoot, DB_PATH);
+  let dataSize = 0;
+  let indexSize = 0;
+  try {
+    dataSize = statSync(jsonlPath).size;
+  } catch {
+  }
+  try {
+    indexSize = statSync(dbPath).size;
+  } catch {
+  }
+  const totalSize = dataSize + indexSize;
+  const deletedInfo = deletedCount > 0 ? ` (${deletedCount} deleted)` : "";
+  console.log(`Lessons: ${totalLessons} total${deletedInfo}`);
+  console.log(`Retrievals: ${totalRetrievals} total, ${avgRetrievals} avg per lesson`);
+  console.log(`Storage: ${formatBytes(totalSize)} (index: ${formatBytes(indexSize)}, data: ${formatBytes(dataSize)})`);
+});
+program.parse();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map