@caliber-ai/cli 0.22.0 → 0.23.0

package/dist/bin.js

@@ -30,11 +30,15 @@ __export(constants_exports, {
   CALIBER_DIR: () => CALIBER_DIR,
   CLI_CALLBACK_PORT: () => CLI_CALLBACK_PORT,
   FRONTEND_URL: () => FRONTEND_URL,
+  LEARNING_DIR: () => LEARNING_DIR,
+  LEARNING_MAX_EVENTS: () => LEARNING_MAX_EVENTS,
+  LEARNING_SESSION_FILE: () => LEARNING_SESSION_FILE,
+  LEARNING_STATE_FILE: () => LEARNING_STATE_FILE,
   MANIFEST_FILE: () => MANIFEST_FILE
 });
 import path2 from "path";
 import os2 from "os";
-var API_URL, FRONTEND_URL, CLI_CALLBACK_PORT, AUTH_DIR, AUTH_FILE, CALIBER_DIR, MANIFEST_FILE, BACKUPS_DIR;
+var API_URL, FRONTEND_URL, CLI_CALLBACK_PORT, AUTH_DIR, AUTH_FILE, CALIBER_DIR, MANIFEST_FILE, BACKUPS_DIR, LEARNING_DIR, LEARNING_SESSION_FILE, LEARNING_STATE_FILE, LEARNING_MAX_EVENTS;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -46,6 +50,10 @@ var init_constants = __esm({
     CALIBER_DIR = ".caliber";
     MANIFEST_FILE = path2.join(CALIBER_DIR, "manifest.json");
     BACKUPS_DIR = path2.join(CALIBER_DIR, "backups");
+    LEARNING_DIR = path2.join(CALIBER_DIR, "learning");
+    LEARNING_SESSION_FILE = "current-session.jsonl";
+    LEARNING_STATE_FILE = "state.json";
+    LEARNING_MAX_EVENTS = 500;
   }
 });
 
@@ -75,8 +83,8 @@ if (dsn) {
 
 // src/cli.ts
 import { Command } from "commander";
-import fs22 from "fs";
-import path19 from "path";
+import fs25 from "fs";
+import path22 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/commands/init.ts
@@ -957,9 +965,9 @@ async function getValidToken() {
   }
   return refreshed;
 }
-async function apiRequest(path21, options = {}) {
+async function apiRequest(path24, options = {}) {
   let token = await getValidToken();
-  let resp = await fetch(`${API_URL}${path21}`, {
+  let resp = await fetch(`${API_URL}${path24}`, {
     method: options.method || "GET",
     headers: {
       "Content-Type": "application/json",
@@ -973,7 +981,7 @@ async function apiRequest(path21, options = {}) {
       throw new Error("Session expired. Run `caliber login` to re-authenticate.");
     }
     token = refreshed;
-    resp = await fetch(`${API_URL}${path21}`, {
+    resp = await fetch(`${API_URL}${path24}`, {
       method: options.method || "GET",
       headers: {
         "Content-Type": "application/json",
@@ -989,9 +997,9 @@ async function apiRequest(path21, options = {}) {
   const json = await resp.json();
   return json.data;
 }
-async function apiStream(path21, body, onChunk, onComplete, onError, onStatus) {
+async function apiStream(path24, body, onChunk, onComplete, onError, onStatus) {
   let token = await getValidToken();
-  let resp = await fetch(`${API_URL}${path21}`, {
+  let resp = await fetch(`${API_URL}${path24}`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -1005,7 +1013,7 @@ async function apiStream(path21, body, onChunk, onComplete, onError, onStatus) {
       throw new Error("Session expired. Run `caliber login` to re-authenticate.");
     }
     token = refreshed;
-    resp = await fetch(`${API_URL}${path21}`, {
+    resp = await fetch(`${API_URL}${path24}`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -3371,10 +3379,374 @@ async function reviewCommand(message, options) {
   await submitReview({ rating, bestPart, biggestGap, wouldRecommend });
 }
 
+// src/commands/learn.ts
+import chalk14 from "chalk";
+
+// src/learner/stdin.ts
+var STDIN_TIMEOUT_MS = 5e3;
+function readStdin() {
+  return new Promise((resolve2, reject) => {
+    if (process.stdin.isTTY) {
+      resolve2("");
+      return;
+    }
+    const chunks = [];
+    const timer = setTimeout(() => {
+      process.stdin.removeAllListeners();
+      process.stdin.destroy();
+      resolve2(Buffer.concat(chunks).toString("utf-8"));
+    }, STDIN_TIMEOUT_MS);
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      resolve2(Buffer.concat(chunks).toString("utf-8"));
+    });
+    process.stdin.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    process.stdin.resume();
+  });
+}
+
+// src/learner/storage.ts
+init_constants();
+import fs22 from "fs";
+import path19 from "path";
+var MAX_RESPONSE_LENGTH = 2e3;
+var DEFAULT_STATE = {
+  sessionId: null,
+  eventCount: 0,
+  lastAnalysisTimestamp: null
+};
+function ensureLearningDir() {
+  if (!fs22.existsSync(LEARNING_DIR)) {
+    fs22.mkdirSync(LEARNING_DIR, { recursive: true });
+  }
+}
+function sessionFilePath() {
+  return path19.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+}
+function stateFilePath() {
+  return path19.join(LEARNING_DIR, LEARNING_STATE_FILE);
+}
+function truncateResponse(response) {
+  const str = JSON.stringify(response);
+  if (str.length <= MAX_RESPONSE_LENGTH) return response;
+  return { _truncated: str.slice(0, MAX_RESPONSE_LENGTH) };
+}
+function appendEvent(event) {
+  ensureLearningDir();
+  const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
+  const filePath = sessionFilePath();
+  fs22.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  const count = getEventCount();
+  if (count > LEARNING_MAX_EVENTS) {
+    const lines = fs22.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
+    fs22.writeFileSync(filePath, kept.join("\n") + "\n");
+  }
+}
+function readAllEvents() {
+  const filePath = sessionFilePath();
+  if (!fs22.existsSync(filePath)) return [];
+  const lines = fs22.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  return lines.map((line) => JSON.parse(line));
+}
+function getEventCount() {
+  const filePath = sessionFilePath();
+  if (!fs22.existsSync(filePath)) return 0;
+  const content = fs22.readFileSync(filePath, "utf-8");
+  return content.split("\n").filter(Boolean).length;
+}
+function clearSession() {
+  const filePath = sessionFilePath();
+  if (fs22.existsSync(filePath)) fs22.unlinkSync(filePath);
+}
+function readState2() {
+  const filePath = stateFilePath();
+  if (!fs22.existsSync(filePath)) return { ...DEFAULT_STATE };
+  try {
+    return JSON.parse(fs22.readFileSync(filePath, "utf-8"));
+  } catch {
+    return { ...DEFAULT_STATE };
+  }
+}
+function writeState2(state) {
+  ensureLearningDir();
+  fs22.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+}
+function resetState() {
+  writeState2({ ...DEFAULT_STATE });
+}
+
+// src/learner/writer.ts
+import fs23 from "fs";
+import path20 from "path";
+var LEARNED_START = "<!-- caliber:learned -->";
+var LEARNED_END = "<!-- /caliber:learned -->";
+function writeLearnedContent(update) {
+  const written = [];
+  if (update.claudeMdLearnedSection) {
+    writeLearnedSection(update.claudeMdLearnedSection);
+    written.push("CLAUDE.md");
+  }
+  if (update.skills?.length) {
+    for (const skill of update.skills) {
+      const skillPath = writeLearnedSkill(skill);
+      written.push(skillPath);
+    }
+  }
+  return written;
+}
+function writeLearnedSection(content) {
+  const claudeMdPath = "CLAUDE.md";
+  let existing = "";
+  if (fs23.existsSync(claudeMdPath)) {
+    existing = fs23.readFileSync(claudeMdPath, "utf-8");
+  }
+  const section = `${LEARNED_START}
+${content}
+${LEARNED_END}`;
+  const startIdx = existing.indexOf(LEARNED_START);
+  const endIdx = existing.indexOf(LEARNED_END);
+  let updated;
+  if (startIdx !== -1 && endIdx !== -1) {
+    updated = existing.slice(0, startIdx) + section + existing.slice(endIdx + LEARNED_END.length);
+  } else {
+    const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
+    updated = existing + separator + "\n" + section + "\n";
+  }
+  fs23.writeFileSync(claudeMdPath, updated);
+}
+function writeLearnedSkill(skill) {
+  const skillDir = path20.join(".claude", "skills", skill.name);
+  if (!fs23.existsSync(skillDir)) fs23.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path20.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs23.existsSync(skillPath)) {
+    const existing = fs23.readFileSync(skillPath, "utf-8");
+    fs23.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  } else {
+    const frontmatter = [
+      "---",
+      `name: ${skill.name}`,
+      `description: ${skill.description}`,
+      "---",
+      ""
+    ].join("\n");
+    fs23.writeFileSync(skillPath, frontmatter + skill.content);
+  }
+  return skillPath;
+}
+function readLearnedSection() {
+  const claudeMdPath = "CLAUDE.md";
+  if (!fs23.existsSync(claudeMdPath)) return null;
+  const content = fs23.readFileSync(claudeMdPath, "utf-8");
+  const startIdx = content.indexOf(LEARNED_START);
+  const endIdx = content.indexOf(LEARNED_END);
+  if (startIdx === -1 || endIdx === -1) return null;
+  return content.slice(startIdx + LEARNED_START.length, endIdx).trim();
+}
+
+// src/lib/learning-hooks.ts
+import fs24 from "fs";
+import path21 from "path";
+var SETTINGS_PATH2 = path21.join(".claude", "settings.json");
+var HOOK_CONFIGS = [
+  {
+    event: "PostToolUse",
+    command: "caliber learn observe",
+    description: "Caliber: recording tool usage for session learning"
+  },
+  {
+    event: "PostToolUseFailure",
+    command: "caliber learn observe --failure",
+    description: "Caliber: recording tool failure for session learning"
+  },
+  {
+    event: "SessionEnd",
+    command: "caliber learn finalize",
+    description: "Caliber: finalizing session learnings"
+  }
+];
+function readSettings2() {
+  if (!fs24.existsSync(SETTINGS_PATH2)) return {};
+  try {
+    return JSON.parse(fs24.readFileSync(SETTINGS_PATH2, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeSettings2(settings) {
+  const dir = path21.dirname(SETTINGS_PATH2);
+  if (!fs24.existsSync(dir)) fs24.mkdirSync(dir, { recursive: true });
+  fs24.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
+}
+function hasLearningHook(matchers, command) {
+  return matchers.some((entry) => entry.hooks?.some((h) => h.command === command));
+}
+function areLearningHooksInstalled() {
+  const settings = readSettings2();
+  if (!settings.hooks) return false;
+  return HOOK_CONFIGS.every((cfg) => {
+    const matchers = settings.hooks[cfg.event];
+    return Array.isArray(matchers) && hasLearningHook(matchers, cfg.command);
+  });
+}
+function installLearningHooks() {
+  if (areLearningHooksInstalled()) {
+    return { installed: false, alreadyInstalled: true };
+  }
+  const settings = readSettings2();
+  if (!settings.hooks) settings.hooks = {};
+  for (const cfg of HOOK_CONFIGS) {
+    if (!Array.isArray(settings.hooks[cfg.event])) {
+      settings.hooks[cfg.event] = [];
+    }
+    if (!hasLearningHook(settings.hooks[cfg.event], cfg.command)) {
+      settings.hooks[cfg.event].push({
+        matcher: "",
+        hooks: [{ type: "command", command: cfg.command, description: cfg.description }]
+      });
+    }
+  }
+  writeSettings2(settings);
+  return { installed: true, alreadyInstalled: false };
+}
+function removeLearningHooks() {
+  const settings = readSettings2();
+  if (!settings.hooks) return { removed: false, notFound: true };
+  let removedAny = false;
+  for (const cfg of HOOK_CONFIGS) {
+    const matchers = settings.hooks[cfg.event];
+    if (!Array.isArray(matchers)) continue;
+    const idx = matchers.findIndex((entry) => entry.hooks?.some((h) => h.command === cfg.command));
+    if (idx !== -1) {
+      matchers.splice(idx, 1);
+      removedAny = true;
+      if (matchers.length === 0) delete settings.hooks[cfg.event];
+    }
+  }
+  if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+  if (!removedAny) return { removed: false, notFound: true };
+  writeSettings2(settings);
+  return { removed: true, notFound: false };
+}
+
+// src/commands/learn.ts
+async function learnObserveCommand(options) {
+  try {
+    const raw = await readStdin();
+    if (!raw.trim()) return;
+    const hookData = JSON.parse(raw);
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      session_id: hookData.session_id || "unknown",
+      hook_event_name: options.failure ? "PostToolUseFailure" : "PostToolUse",
+      tool_name: hookData.tool_name || "unknown",
+      tool_input: hookData.tool_input || {},
+      tool_response: hookData.tool_response || {},
+      tool_use_id: hookData.tool_use_id || "",
+      cwd: hookData.cwd || process.cwd()
+    };
+    appendEvent(event);
+    const state = readState2();
+    state.eventCount++;
+    if (!state.sessionId) state.sessionId = event.session_id;
+    writeState2(state);
+  } catch {
+  }
+}
+async function learnFinalizeCommand() {
+  try {
+    const auth2 = getStoredAuth();
+    if (!auth2) {
+      clearSession();
+      resetState();
+      return;
+    }
+    const events = readAllEvents();
+    if (!events.length) {
+      clearSession();
+      resetState();
+      return;
+    }
+    const existingConfigs = readExistingConfigs(process.cwd());
+    const existingLearnedSection = readLearnedSection();
+    const existingSkills = existingConfigs.claudeSkills || [];
+    const response = await apiRequest("/api/learn/analyze", {
+      method: "POST",
+      body: {
+        events,
+        existingClaudeMd: existingConfigs.claudeMd || "",
+        existingLearnedSection,
+        existingSkills
+      }
+    });
+    if (response.claudeMdLearnedSection || response.skills?.length) {
+      writeLearnedContent({
+        claudeMdLearnedSection: response.claudeMdLearnedSection,
+        skills: response.skills
+      });
+    }
+  } catch {
+  } finally {
+    clearSession();
+    resetState();
+  }
+}
+async function learnInstallCommand() {
+  const result = installLearningHooks();
+  if (result.alreadyInstalled) {
+    console.log(chalk14.dim("Learning hooks already installed."));
+    return;
+  }
+  console.log(chalk14.green("\u2713") + " Learning hooks installed in .claude/settings.json");
+  console.log(chalk14.dim("  PostToolUse, PostToolUseFailure, and SessionEnd hooks active."));
+  console.log(chalk14.dim("  Session learnings will be written to CLAUDE.md and skills."));
+}
+async function learnRemoveCommand() {
+  const result = removeLearningHooks();
+  if (result.notFound) {
+    console.log(chalk14.dim("Learning hooks not found."));
+    return;
+  }
+  console.log(chalk14.green("\u2713") + " Learning hooks removed from .claude/settings.json");
+}
+async function learnStatusCommand() {
+  const installed = areLearningHooksInstalled();
+  const state = readState2();
+  const eventCount = getEventCount();
+  console.log(chalk14.bold("Session Learning Status"));
+  console.log();
+  if (installed) {
+    console.log(chalk14.green("\u2713") + " Learning hooks are " + chalk14.green("installed"));
+  } else {
+    console.log(chalk14.dim("\u2717") + " Learning hooks are " + chalk14.yellow("not installed"));
+    console.log(chalk14.dim("  Run `caliber learn install` to enable session learning."));
+  }
+  console.log();
+  console.log(`Events recorded: ${chalk14.cyan(String(eventCount))}`);
+  console.log(`Total this session: ${chalk14.cyan(String(state.eventCount))}`);
+  if (state.lastAnalysisTimestamp) {
+    console.log(`Last analysis: ${chalk14.cyan(state.lastAnalysisTimestamp)}`);
+  } else {
+    console.log(`Last analysis: ${chalk14.dim("none")}`);
+  }
+  const learnedSection = readLearnedSection();
+  if (learnedSection) {
+    const lineCount = learnedSection.split("\n").filter(Boolean).length;
+    console.log(`
+Learned items in CLAUDE.md: ${chalk14.cyan(String(lineCount))}`);
+  }
+}
+
 // src/cli.ts
-var __dirname2 = path19.dirname(fileURLToPath3(import.meta.url));
+var __dirname2 = path22.dirname(fileURLToPath3(import.meta.url));
 var pkg3 = JSON.parse(
-  fs22.readFileSync(path19.resolve(__dirname2, "..", "package.json"), "utf-8")
+  fs25.readFileSync(path22.resolve(__dirname2, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg3.version}-local` : pkg3.version;
@@ -3394,24 +3766,30 @@ var hooks = program.command("hooks").description("Manage Claude Code session hoo
 hooks.command("install").description("Install auto-refresh SessionEnd hook").action(hooksInstallCommand);
 hooks.command("remove").description("Remove auto-refresh SessionEnd hook").action(hooksRemoveCommand);
 hooks.command("status").description("Check if auto-refresh hook is installed").action(hooksStatusCommand);
+var learn = program.command("learn").description("Session learning \u2014 observe tool usage and extract reusable instructions");
+learn.command("observe").description("Record a tool event from stdin (called by hooks)").option("--failure", "Mark event as a tool failure").action(learnObserveCommand);
+learn.command("finalize").description("Analyze session events and update CLAUDE.md (called on SessionEnd)").action(learnFinalizeCommand);
+learn.command("install").description("Install learning hooks into .claude/settings.json").action(learnInstallCommand);
+learn.command("remove").description("Remove learning hooks from .claude/settings.json").action(learnRemoveCommand);
+learn.command("status").description("Show learning system status").action(learnStatusCommand);
 
 // src/utils/version-check.ts
-import fs23 from "fs";
-import path20 from "path";
+import fs26 from "fs";
+import path23 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { execSync as execSync5 } from "child_process";
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 import ora10 from "ora";
 import confirm3 from "@inquirer/confirm";
-var __dirname_vc = path20.dirname(fileURLToPath4(import.meta.url));
+var __dirname_vc = path23.dirname(fileURLToPath4(import.meta.url));
 var pkg4 = JSON.parse(
-  fs23.readFileSync(path20.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs26.readFileSync(path23.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getInstalledVersion() {
   try {
     const globalRoot = execSync5("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const pkgPath = path20.join(globalRoot, "@caliber-ai", "cli", "package.json");
-    return JSON.parse(fs23.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = path23.join(globalRoot, "@caliber-ai", "cli", "package.json");
+    return JSON.parse(fs26.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -3434,17 +3812,17 @@ async function checkForUpdates() {
     const isInteractive = process.stdin.isTTY === true;
     if (!isInteractive) {
       console.log(
-        chalk14.yellow(
+        chalk15.yellow(
           `
 Update available: ${current} -> ${latest}
-Run ${chalk14.bold("npm install -g @caliber-ai/cli")} to upgrade.
+Run ${chalk15.bold("npm install -g @caliber-ai/cli")} to upgrade.
 `
         )
       );
       return;
     }
     console.log(
-      chalk14.yellow(`
+      chalk15.yellow(`
 Update available: ${current} -> ${latest}`)
     );
     const shouldUpdate = await confirm3({ message: "Would you like to update now? (Y/n)", default: true });
@@ -3458,13 +3836,13 @@ Update available: ${current} -> ${latest}`)
       const installed = getInstalledVersion();
       if (installed !== latest) {
         spinner.fail(`Update incomplete \u2014 got ${installed ?? "unknown"}, expected ${latest}`);
-        console.log(chalk14.yellow(`Run ${chalk14.bold(`npm install -g @caliber-ai/cli@${latest}`)} manually.
+        console.log(chalk15.yellow(`Run ${chalk15.bold(`npm install -g @caliber-ai/cli@${latest}`)} manually.
 `));
         return;
       }
-      spinner.succeed(chalk14.green(`Updated to ${latest}`));
+      spinner.succeed(chalk15.green(`Updated to ${latest}`));
       const args = process.argv.slice(2);
-      console.log(chalk14.dim(`
+      console.log(chalk15.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
       execSync5(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
@@ -3475,10 +3853,10 @@ Restarting: caliber ${args.join(" ")}
     } catch (err) {
       spinner.fail("Update failed");
       const msg = err instanceof Error ? err.message : "";
-      if (msg && !msg.includes("SIGTERM")) console.log(chalk14.dim(`  ${msg.split("\n")[0]}`));
+      if (msg && !msg.includes("SIGTERM")) console.log(chalk15.dim(`  ${msg.split("\n")[0]}`));
       console.log(
-        chalk14.yellow(
-          `Run ${chalk14.bold(`npm install -g @caliber-ai/cli@${latest}`)} manually to upgrade.
+        chalk15.yellow(
+          `Run ${chalk15.bold(`npm install -g @caliber-ai/cli@${latest}`)} manually to upgrade.
 `
         )
       );