@riconext/hermes-repo 0.1.0 → 0.2.5

package/dist/cli.js

@@ -1,41 +1,1199 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { readFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
+import { Command } from "commander";
+
+// src/capture/claude-code/resolveSession.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { basename, join, resolve } from "path";
+function encodeClaudeProjectDir(absPath) {
+  return resolve(absPath).replace(/\//g, "-");
+}
+function resolveSessionJsonlPath(repoRoot, options = {}) {
+  const override = process.env.HERMES_SESSION_JSONL;
+  if (override && existsSync(override)) {
+    return resolve(override);
+  }
+  const fromHook = options.transcriptPath;
+  if (fromHook && existsSync(fromHook)) {
+    return resolve(fromHook);
+  }
+  const sessionId = process.env.CLAUDE_SESSION_ID ?? process.env.CLAUDE_CODE_SESSION_ID ?? process.env.SESSION_ID;
+  const claudeHome = process.env.CLAUDE_CONFIG_DIR ? resolve(process.env.CLAUDE_CONFIG_DIR) : join(homedir(), ".claude");
+  const projectsRoot = join(claudeHome, "projects");
+  if (!existsSync(projectsRoot)) {
+    return null;
+  }
+  const cwd = resolve(options.cwd ?? repoRoot);
+  const preferredProjectDir = encodeClaudeProjectDir(cwd);
+  const preferredPath = join(projectsRoot, preferredProjectDir);
+  if (existsSync(preferredPath)) {
+    const hit = pickNewestJsonl(preferredPath, sessionId);
+    if (hit) {
+      return hit;
+    }
+    const legacySessions = join(preferredPath, "sessions");
+    if (existsSync(legacySessions)) {
+      const legacyHit = pickNewestJsonl(legacySessions, sessionId);
+      if (legacyHit) {
+        return legacyHit;
+      }
+    }
+  }
+  const candidates = [];
+  for (const projectDir of readdirSync(projectsRoot, { withFileTypes: true })) {
+    if (!projectDir.isDirectory()) continue;
+    const projectPath = join(projectsRoot, projectDir.name);
+    collectJsonlCandidates(projectPath, sessionId, candidates);
+    const legacySessions = join(projectPath, "sessions");
+    if (existsSync(legacySessions)) {
+      collectJsonlCandidates(legacySessions, sessionId, candidates);
+    }
+  }
+  if (candidates.length === 0) {
+    return null;
+  }
+  candidates.sort((a, b) => b.mtime - a.mtime);
+  return candidates[0]?.path ?? null;
+}
+function readHookTranscriptPathSync() {
+  if (process.stdin.isTTY) {
+    return null;
+  }
+  try {
+    const raw = readFileSync(0, "utf8").trim();
+    if (!raw) {
+      return null;
+    }
+    const parsed = JSON.parse(raw);
+    const p = parsed.transcript_path;
+    if (typeof p === "string" && existsSync(p)) {
+      return resolve(p);
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function pickNewestJsonl(dir, sessionId) {
+  const candidates = [];
+  collectJsonlCandidates(dir, sessionId, candidates);
+  if (candidates.length === 0) {
+    return null;
+  }
+  candidates.sort((a, b) => b.mtime - a.mtime);
+  return candidates[0]?.path ?? null;
+}
+function collectJsonlCandidates(dir, sessionId, out) {
+  if (!existsSync(dir)) {
+    return;
+  }
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+      continue;
+    }
+    const fullPath = join(dir, entry.name);
+    if (sessionId && !entry.name.includes(sessionId) && basename(entry.name, ".jsonl") !== sessionId) {
+      continue;
+    }
+    try {
+      const st = statSync(fullPath);
+      out.push({ path: fullPath, mtime: st.mtimeMs });
+    } catch {
+    }
+  }
+}
+
+// src/config/debugLog.ts
+import { appendFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+
+// src/init/paths.ts
+import { join as join2 } from "path";
+var MEMORY_DIR = ".memory";
+var MEMORY_SUBDIRS = [
+  "captures/semantic",
+  "captures/episodic",
+  "captures/procedural",
+  "personal",
+  "sessions",
+  "refs",
+  "topics",
+  "skills",
+  "team/decisions",
+  "team/conflict-resolutions",
+  "templates",
+  ".archive"
+];
+var GITKEEP_DIRS = [
+  "topics",
+  "skills",
+  "team/decisions",
+  "team/conflict-resolutions"
+];
+var EXAMPLE_TEMPLATE_FILES = [
+  "capture-semantic.example.md",
+  "capture-episodic.example.md",
+  "capture-procedural.example.md",
+  "PROMOTE_PR.md"
+];
+function memoryPath(root, ...segments) {
+  return join2(root, MEMORY_DIR, ...segments);
+}
+
+// src/config/debugLog.ts
+var DEBUG_LOG_FILE = "hermes-debug.log";
+var logFilePath = null;
+function configureDebugLogging(repoRoot, enabled) {
+  if (!enabled || !repoRoot) {
+    logFilePath = null;
+    return;
+  }
+  logFilePath = memoryPath(repoRoot, DEBUG_LOG_FILE);
+}
+function formatLine(phase, message) {
+  return `${(/* @__PURE__ */ new Date()).toISOString()} hermes-repo [${phase}] ${message}`;
+}
+function writeToLogFile(line) {
+  if (!logFilePath) {
+    return;
+  }
+  mkdirSync(dirname(logFilePath), { recursive: true });
+  appendFileSync(logFilePath, `${line}
+`, "utf8");
+}
+function debugLog(enabled, phase, message) {
+  if (!enabled) {
+    return;
+  }
+  const line = formatLine(phase, message);
+  console.error(line);
+  writeToLogFile(line);
+}
+function debugFromContext(ctx, phase, message) {
+  debugLog(ctx?.config.debug === true, phase, message);
+}
+
+// src/config/readConfig.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join4 } from "path";
+
+// src/config/findRepoRoot.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+var CONFIG_REL = join3(".memory", "config.json");
+function findRepoRoot(startDir) {
+  let dir = resolve2(startDir ?? process.cwd());
+  while (true) {
+    if (existsSync2(join3(dir, CONFIG_REL))) {
+      return dir;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+
+// src/config/readConfig.ts
+function isAssistantId(value) {
+  return typeof value === "string";
+}
+function readConfigAtRepo(repoRoot) {
+  const configPath = join4(repoRoot, ".memory", "config.json");
+  try {
+    const raw = JSON.parse(readFileSync2(configPath, "utf8"));
+    if (raw.version !== 1 || raw.storage?.backend !== "file") {
+      return null;
+    }
+    const assistants = Array.isArray(raw.assistants) ? raw.assistants.filter(isAssistantId) : [];
+    return {
+      version: 1,
+      storage: { backend: "file" },
+      assistants,
+      debug: raw.debug === true
+    };
+  } catch {
+    return null;
+  }
+}
+function loadRepoContext(cwd) {
+  const repoRoot = findRepoRoot(cwd);
+  if (!repoRoot) {
+    return null;
+  }
+  const config = readConfigAtRepo(repoRoot);
+  if (!config) {
+    return null;
+  }
+  return { repoRoot, config };
+}
+
+// src/capture/shouldCapture.ts
+var STRONG_SIGNALS = [
+  "\u4FEE\u590D",
+  "\u56E0\u4E3A",
+  "\u6539\u6210",
+  "\u6CE8\u610F",
+  "\u7EA6\u5B9A",
+  "\u4E0D\u8981",
+  "\u5FC5\u987B",
+  "\u6700\u4F73\u5B9E\u8DF5",
+  "\u6839\u56E0",
+  "\u539F\u56E0",
+  "fix",
+  "because",
+  "change to",
+  "note",
+  "convention",
+  "never",
+  "always",
+  "root cause",
+  "pattern",
+  "\u67B6\u6784",
+  "\u51B3\u7B56"
+];
+var CORRECTION_RE = /不对|错了|不是这样|不应该|别用|stop|wrong|incorrect|改成|修正/i;
+var SEMANTIC_SIGNAL_RE = /约定|必须|架构|决策|规范|convention|pattern|always|never/i;
+function shouldCapture(session) {
+  if (session.messages.length < 3) {
+    return false;
+  }
+  const hasStrongSignal = STRONG_SIGNALS.some(
+    (w) => session.text.toLowerCase().includes(w.toLowerCase())
+  );
+  const hasUserCorrection = session.messages.some(
+    (m) => m.role === "user" && CORRECTION_RE.test(m.text)
+  );
+  const hasComplexTask = session.toolCalls > 5;
+  return hasStrongSignal || hasUserCorrection || hasComplexTask;
+}
+function inferCaptureType(session) {
+  if (SEMANTIC_SIGNAL_RE.test(session.text)) {
+    return "semantic";
+  }
+  return "episodic";
+}
+
+// src/capture/sessionsIndex.ts
+import { readFileSync as readFileSync3, writeFileSync } from "fs";
+import { join as join5 } from "path";
+function readSessionsIndex(repoRoot) {
+  const indexPath = memoryPath(repoRoot, "sessions", "index.json");
+  try {
+    const data = JSON.parse(readFileSync3(indexPath, "utf8"));
+    if (data.version === 1 && Array.isArray(data.sessions)) {
+      return data;
+    }
+  } catch {
+  }
+  return { version: 1, sessions: [] };
+}
+function appendSessionIndex(repoRoot, entry) {
+  const index = readSessionsIndex(repoRoot);
+  index.sessions.push(entry);
+  const indexPath = memoryPath(repoRoot, "sessions", "index.json");
+  writeFileSync(indexPath, `${JSON.stringify(index, null, 2)}
+`, "utf8");
+}
+function relativeCapturePath(type, filename) {
+  return join5(".memory", "captures", type, filename).replace(/\\/g, "/");
+}
+
+// src/capture/writeCapture.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
+function todayString() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function nextCaptureFilename(repoRoot, type) {
+  const dir = memoryPath(repoRoot, "captures", type);
+  mkdirSync2(dir, { recursive: true });
+  const date = todayString();
+  const prefix = `capture-${date}-`;
+  let max = 0;
+  if (existsSync3(dir)) {
+    for (const name of readdirSync2(dir)) {
+      if (name.startsWith(prefix) && name.endsWith(".md")) {
+        const num = Number.parseInt(name.slice(prefix.length, -3), 10);
+        if (!Number.isNaN(num) && num > max) {
+          max = num;
+        }
+      }
+    }
+  }
+  const seq = String(max + 1).padStart(3, "0");
+  return `capture-${date}-${seq}.md`;
+}
+function buildBody(session) {
+  const recent = session.messages.slice(-6);
+  const context = recent.map((m) => `**${m.role}**: ${m.text.slice(0, 500)}`).join("\n\n");
+  return `## \u4E0A\u4E0B\u6587
+
+\u81EA\u52A8\u6355\u83B7\u81EA Claude Code \u4F1A\u8BDD \`${session.sessionId}\`\u3002
+
+## \u53D1\u73B0
+
+${context || "\uFF08\u65E0\u63D0\u53D6\u5185\u5BB9\uFF09"}
+
+## \u5F71\u54CD
+
+\uFF08\u5F85 consolidate \u6216\u4EBA\u5DE5\u8865\u5145\uFF09
+`;
+}
+function writeCaptureFile(repoRoot, session, type) {
+  const filename = nextCaptureFilename(repoRoot, type);
+  const absolutePath = memoryPath(repoRoot, "captures", type, filename);
+  const date = todayString();
+  const content = `---
+type: ${type}
+date: ${date}
+session: ${session.sessionId}
+tags: [auto-capture, claude-code]
+scope: all
+confidence: pending
+---
+
+${buildBody(session)}
+`;
+  writeFileSync2(absolutePath, content, "utf8");
+  return { absolutePath, filename };
+}
+
+// src/capture/claude-code/parseJsonl.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { basename as basename2 } from "path";
+var FILE_CHANGE_TOOLS = /^(Write|Edit|MultiEdit|NotebookEdit|write|edit)$/i;
+function extractText(record) {
+  if (typeof record.content === "string") {
+    return record.content;
+  }
+  const message = record.message;
+  if (message && typeof message === "object") {
+    const msg = message;
+    if (typeof msg.content === "string") {
+      return msg.content;
+    }
+    if (Array.isArray(msg.content)) {
+      return msg.content.map((part) => {
+        if (part && typeof part === "object" && "text" in part) {
+          return String(part.text);
+        }
+        return "";
+      }).join("\n");
+    }
+  }
+  return "";
+}
+function inferRole(record) {
+  if (typeof record.role === "string") {
+    return record.role;
+  }
+  if (typeof record.type === "string") {
+    const t = record.type.toLowerCase();
+    if (t === "user" || t === "human") return "user";
+    if (t === "assistant") return "assistant";
+  }
+  return "unknown";
+}
+function isToolUse(record) {
+  const t = String(record.type ?? "").toLowerCase();
+  return t === "tool_use" || t === "tool";
+}
+function toolName(record) {
+  if (typeof record.name === "string") return record.name;
+  const tool = record.tool;
+  if (tool && typeof tool === "object" && "name" in tool) {
+    return String(tool.name);
+  }
+  return "";
+}
+function parseJsonlFile(jsonlPath) {
+  const sessionId = basename2(jsonlPath, ".jsonl");
+  const raw = readFileSync4(jsonlPath, "utf8");
+  const messages = [];
+  let fileChanges = 0;
+  let toolCalls = 0;
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const record = JSON.parse(trimmed);
+      if (isToolUse(record)) {
+        toolCalls += 1;
+        const name = toolName(record);
+        if (FILE_CHANGE_TOOLS.test(name)) {
+          fileChanges += 1;
+        }
+        continue;
+      }
+      const role = inferRole(record);
+      const text2 = extractText(record);
+      if (text2) {
+        messages.push({ role, text: text2 });
+      }
+    } catch {
+    }
+  }
+  const text = messages.map((m) => m.text).join("\n");
+  return {
+    sessionId,
+    messages,
+    text,
+    fileChanges,
+    toolCalls
+  };
+}
+
+// src/capture/claude-code/run.ts
+function runClaudeCodeCapture(repoRoot, cwd, dryRun, options) {
+  const jsonlPath = resolveSessionJsonlPath(repoRoot, {
+    cwd,
+    transcriptPath: options?.transcriptPath
+  });
+  if (!jsonlPath) {
+    return { written: false, reason: "no session jsonl found" };
+  }
+  const session = parseJsonlFile(jsonlPath);
+  if (!shouldCapture(session)) {
+    return {
+      written: false,
+      reason: `heuristic rejected (messages=${session.messages.length}, toolCalls=${session.toolCalls})`,
+      jsonlPath
+    };
+  }
+  const type = inferCaptureType(session);
+  if (dryRun) {
+    debugLog(
+      options?.debug === true,
+      "capture",
+      `[dry-run] would capture ${type} session=${session.sessionId} from ${jsonlPath}`
+    );
+    return { written: false, reason: "dry-run", jsonlPath };
+  }
+  const { filename } = writeCaptureFile(repoRoot, session, type);
+  const captureFile = relativeCapturePath(type, filename);
+  appendSessionIndex(repoRoot, {
+    id: session.sessionId,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    captureFile,
+    assistant: "claude-code"
+  });
+  return { written: true, capturePath: captureFile };
+}
+
+// src/capture/router.ts
+function routeCapture(ctx, options) {
+  if (!ctx.config.assistants.includes("claude-code")) {
+    return { written: false, reason: "claude-code not in assistants" };
+  }
+  return runClaudeCodeCapture(ctx.repoRoot, options.cwd, options.dryRun, {
+    transcriptPath: options.transcriptPath,
+    debug: ctx.config.debug === true
+  });
+}
+
+// src/capture/runCapture.ts
+function logCaptureResult(debug, result) {
+  if (!debug) {
+    return;
+  }
+  if (result.written && result.capturePath) {
+    debugLog(true, "capture", `ok: ${result.capturePath}`);
+    return;
+  }
+  const parts = [result.reason ?? "unknown"];
+  if (result.jsonlPath) {
+    parts.push(`jsonl=${result.jsonlPath}`);
+  }
+  debugLog(true, "capture", `skip: ${parts.join(", ")}`);
+}
+function runCapture(options = {}) {
+  const ctx = loadRepoContext(options.cwd);
+  if (!ctx) {
+    return { written: false, reason: "not initialized" };
+  }
+  const result = routeCapture(ctx, {
+    cwd: options.cwd,
+    dryRun: options.dryRun,
+    transcriptPath: options.transcriptPath
+  });
+  logCaptureResult(ctx.config.debug, result);
+  return result;
+}
+
+// src/hookExit.ts
+function finalizeHookCommand(fn, strict, debug) {
+  void (async () => {
+    try {
+      await fn();
+      process.exit(0);
+    } catch (error) {
+      debugLog(debug === true, "hook", error instanceof Error ? error.message : String(error));
+      process.exit(strict ? 1 : 0);
+    }
+  })();
+}
+
+// src/commands/capture.ts
+function runCaptureCommand(opts) {
+  const ctx = loadRepoContext(opts.cwd);
+  const debug = ctx?.config.debug === true;
+  configureDebugLogging(ctx?.repoRoot ?? null, debug);
+  const transcriptPath = readHookTranscriptPathSync();
+  finalizeHookCommand(() => {
+    runCapture({
+      cwd: opts.cwd,
+      dryRun: opts.dryRun,
+      strict: opts.strict,
+      transcriptPath: transcriptPath ?? void 0
+    });
+  }, opts.strict, debug);
+}
+
+// src/inject/runInject.ts
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+
+// src/inject/constants.ts
+var INJECT_MAX_CHARS = 2200;
+
+// src/inject/runInject.ts
+function runInject(cwd) {
+  const ctx = loadRepoContext(cwd);
+  if (!ctx) {
+    return { injected: false, chars: 0 };
+  }
+  const memoryFile = memoryPathOnDisk(ctx.repoRoot);
+  if (!existsSync4(memoryFile)) {
+    debugFromContext(ctx, "inject", "skip: MEMORY.md missing");
+    return { injected: false, chars: 0 };
+  }
+  const contentRaw = readFileSync5(memoryFile, "utf8");
+  if (!contentRaw.trim()) {
+    debugFromContext(ctx, "inject", "skip: MEMORY.md empty");
+    return { injected: false, chars: 0 };
+  }
+  let content = contentRaw;
+  if (content.length > INJECT_MAX_CHARS) {
+    content = `${content.slice(0, INJECT_MAX_CHARS)}
+
+...(truncated)`;
+  }
+  process.stdout.write(content);
+  if (!content.endsWith("\n")) {
+    process.stdout.write("\n");
+  }
+  debugFromContext(ctx, "inject", `ok: injected ${content.length} chars`);
+  return { injected: true, chars: content.length };
+}
+function memoryPathOnDisk(repoRoot) {
+  return memoryPath(repoRoot, "MEMORY.md");
+}
+
+// src/commands/inject.ts
+function runInjectCommand(opts) {
+  const ctx = loadRepoContext(opts.cwd);
+  const debug = ctx?.config.debug === true;
+  configureDebugLogging(ctx?.repoRoot ?? null, debug);
+  finalizeHookCommand(() => {
+    runInject(opts.cwd);
+  }, opts.strict, debug);
+}
+
+// src/init/runInit.ts
+import { spawnSync } from "child_process";
+import { resolve as resolve4 } from "path";
+
+// src/init/assistants/claude-code.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join9 } from "path";
+
+// src/init/mergeClaudeSettings.ts
+import { existsSync as existsSync6, readFileSync as readFileSync8 } from "fs";
+import { join as join8 } from "path";
+
+// src/init/templateDir.ts
+import { existsSync as existsSync5, readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname4, join as join7 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/index.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname3, join as join6 } from "path";
+import { fileURLToPath } from "url";
 var PACKAGE_NAME = "@riconext/hermes-repo";
-
-// src/cli.ts
+var __dirname = dirname3(fileURLToPath(import.meta.url));
 function readPkgVersion() {
-  const root = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-  const raw = readFileSync(root, "utf8");
-  const pkg = JSON.parse(raw);
-  return typeof pkg.version === "string" ? pkg.version : "0.0.0";
-}
-var version = readPkgVersion();
-var argv = process.argv.slice(2);
-var cmd = argv[0];
-if (cmd === "-v" || cmd === "--version") {
-  process.stdout.write(`${version}
-`);
-  process.exit(0);
+  const pkgPath = join6(__dirname, "..", "package.json");
+  const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
+  return pkg.version;
+}
+
+// src/init/templateDir.ts
+function resolveTemplateDir() {
+  const here = dirname4(fileURLToPath2(import.meta.url));
+  const candidates = [
+    join7(here, "templates"),
+    join7(here, "..", "..", "templates")
+  ];
+  for (const dir of candidates) {
+    if (existsSync5(dir)) {
+      return dir;
+    }
+  }
+  return join7(here, "templates");
+}
+var templateDir = resolveTemplateDir();
+function resolveTemplatePath(name) {
+  return join7(templateDir, name);
+}
+function readTemplate(name) {
+  return readFileSync7(resolveTemplatePath(name), "utf8");
+}
+function renderTemplate(name) {
+  const raw = readTemplate(name);
+  return raw.replaceAll("__PACKAGE_NAME__", PACKAGE_NAME);
 }
-if (cmd === "-h" || cmd === "--help" || cmd === void 0) {
-  process.stdout.write(`${PACKAGE_NAME} v${version}
 
-\u7528\u6CD5:
-  hermes-repo              \u663E\u793A\u672C\u5E2E\u52A9
-  hermes-repo --version    \u663E\u793A\u7248\u672C
+// src/init/mergeClaudeSettings.ts
+var CLAUDE_SETTINGS_LOCAL_REL = ".claude/settings.local.json";
+function claudeSettingsLocalPath(repoRoot) {
+  return join8(repoRoot, ".claude", "settings.local.json");
+}
+function mergeClaudeLocalSettings(repoRoot) {
+  const settingsPath = claudeSettingsLocalPath(repoRoot);
+  const existed = existsSync6(settingsPath);
+  const templateParsed = JSON.parse(renderTemplate("hooks.json.tpl"));
+  let existing = {};
+  if (existed) {
+    try {
+      existing = JSON.parse(readFileSync8(settingsPath, "utf8"));
+    } catch {
+      existing = {};
+    }
+  }
+  const prevHooks = existing.hooks && typeof existing.hooks === "object" && !Array.isArray(existing.hooks) ? existing.hooks : {};
+  const merged = {
+    ...existing,
+    hooks: {
+      ...prevHooks,
+      Stop: templateParsed.hooks.Stop,
+      SessionStart: templateParsed.hooks.SessionStart
+    }
+  };
+  return {
+    content: `${JSON.stringify(merged, null, 2)}
+`,
+    action: existed ? "overwritten" : "created"
+  };
+}
 
-\u540E\u7EED\u5C06\u63D0\u4F9B init / validate / doctor \u7B49\u5B50\u547D\u4EE4\uFF08\u89C1\u4ED3\u5E93 docs\uFF09\u3002
-`);
-  process.exit(cmd === void 0 ? 0 : 0);
+// src/init/assistants/claude-code.ts
+var claudeCodeAdapter = {
+  id: "claude-code",
+  label: "Claude Code\uFF08Stop / SessionStart hooks\uFF09",
+  available: true,
+  scaffoldPaths: [CLAUDE_SETTINGS_LOCAL_REL],
+  write(ctx) {
+    mkdirSync3(join9(ctx.repoRoot, ".claude"), { recursive: true });
+    const { content, action } = mergeClaudeLocalSettings(ctx.repoRoot);
+    writeFileSync3(claudeSettingsLocalPath(ctx.repoRoot), content, "utf8");
+    ctx.report.files.push({ path: CLAUDE_SETTINGS_LOCAL_REL, action });
+  }
+};
+
+// src/init/assistants/cursor.ts
+var cursorAdapter = {
+  id: "cursor",
+  label: "Cursor",
+  available: false,
+  scaffoldPaths: [],
+  write(_ctx) {
+  }
+};
+
+// src/init/assistants/registry.ts
+var DEFAULT_ASSISTANT_IDS = ["claude-code"];
+var ALL_ADAPTERS = [claudeCodeAdapter, cursorAdapter];
+var ADAPTER_BY_ID = new Map(
+  ALL_ADAPTERS.map((a) => [a.id, a])
+);
+function getAdapter(id) {
+  const adapter = ADAPTER_BY_ID.get(id);
+  if (!adapter) {
+    throw new Error(`Unknown assistant id: ${id}`);
+  }
+  return adapter;
+}
+function listAvailable() {
+  return ALL_ADAPTERS.filter((a) => a.available);
+}
+function isKnownAssistantId(id) {
+  return ADAPTER_BY_ID.has(id);
+}
+function parseToolsArg(tools) {
+  const ids = tools.split(",").map((s) => s.trim()).filter(Boolean);
+  if (ids.length === 0) {
+    throw new Error("init --tools requires at least one assistant id");
+  }
+  const result = [];
+  for (const id of ids) {
+    if (!isKnownAssistantId(id)) {
+      throw new Error(`Unknown assistant id: ${id}`);
+    }
+    const adapter = getAdapter(id);
+    if (!adapter.available) {
+      throw new Error(`Assistant not available yet: ${id}`);
+    }
+    result.push(id);
+  }
+  return result;
+}
+function validateAssistantSelection(ids) {
+  if (ids.length === 0) {
+    throw new Error("At least one assistant must be selected");
+  }
+  for (const id of ids) {
+    const adapter = getAdapter(id);
+    if (!adapter.available) {
+      throw new Error(`Assistant not available yet: ${id}`);
+    }
+  }
+}
+
+// src/init/ensureDirs.ts
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join10 } from "path";
+function ensureMemoryTree(repoRoot) {
+  const memoryRoot = join10(repoRoot, MEMORY_DIR);
+  mkdirSync4(memoryRoot, { recursive: true });
+  for (const sub of MEMORY_SUBDIRS) {
+    mkdirSync4(join10(memoryRoot, sub), { recursive: true });
+  }
+  mkdirSync4(join10(repoRoot, ".claude"), { recursive: true });
+  for (const sub of GITKEEP_DIRS) {
+    const keepPath = join10(memoryRoot, sub, ".gitkeep");
+    writeFileSync4(keepPath, "", { flag: "a" });
+  }
 }
-process.stderr.write(`\u672A\u77E5\u547D\u4EE4: ${cmd}
-\u8BF7\u4F7F\u7528 hermes-repo --help
+
+// src/init/mergeAssistants.ts
+import { existsSync as existsSync7, readFileSync as readFileSync9 } from "fs";
+function readExistingAssistants(repoRoot) {
+  const configPath = memoryPath(repoRoot, "config.json");
+  if (!existsSync7(configPath)) {
+    return [];
+  }
+  try {
+    const config = JSON.parse(readFileSync9(configPath, "utf8"));
+    if (!Array.isArray(config.assistants)) {
+      return [];
+    }
+    return config.assistants.filter((id) => typeof id === "string");
+  } catch {
+    return [];
+  }
+}
+function mergeAssistants(repoRoot, selected) {
+  const existing = readExistingAssistants(repoRoot);
+  return [.../* @__PURE__ */ new Set([...existing, ...selected])];
+}
+
+// src/init/mergeGitignore.ts
+import { existsSync as existsSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
+import { join as join11 } from "path";
+var START_MARKER = "# >>> hermes-repo memory (do not edit this block manually)";
+var END_MARKER = "# <<< hermes-repo memory";
+function mergeHermesGitignore(repoRoot) {
+  const block = readTemplate("gitignore-block.txt").trimEnd() + "\n";
+  const gitignorePath = join11(repoRoot, ".gitignore");
+  const contentBefore = existsSync8(gitignorePath) ? readFileSync10(gitignorePath, "utf8") : "";
+  const warnBroadMemoryIgnore = contentBefore.length > 0 && !contentBefore.includes(START_MARKER) && /(^|\n)\.memory\/\s*$/m.test(contentBefore);
+  if (!existsSync8(gitignorePath)) {
+    writeFileSync5(gitignorePath, `${block}
+`, "utf8");
+    return { action: "created", warnBroadMemoryIgnore: false };
+  }
+  const startIdx = contentBefore.indexOf(START_MARKER);
+  const endIdx = contentBefore.indexOf(END_MARKER);
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    const before = contentBefore.slice(0, startIdx);
+    const after = contentBefore.slice(endIdx + END_MARKER.length);
+    const next = `${before}${block}${after}`.replace(/\n{3,}/g, "\n\n");
+    writeFileSync5(gitignorePath, next.endsWith("\n") ? next : `${next}
+`, "utf8");
+    return { action: "replaced", warnBroadMemoryIgnore };
+  }
+  if (startIdx !== -1) {
+    const before = contentBefore.slice(0, startIdx);
+    const next = `${before}${block}
+`;
+    writeFileSync5(gitignorePath, next, "utf8");
+    return { action: "updated", warnBroadMemoryIgnore };
+  }
+  const separator = contentBefore.endsWith("\n") || contentBefore.length === 0 ? "\n" : "\n\n";
+  writeFileSync5(gitignorePath, `${contentBefore}${separator}${block}
+`, "utf8");
+  return { action: "appended", warnBroadMemoryIgnore };
+}
+
+// src/init/prompts.ts
+import { checkbox, confirm, input } from "@inquirer/prompts";
+import { existsSync as existsSync9, readFileSync as readFileSync11 } from "fs";
+import { resolve as resolve3 } from "path";
+function isInitialized(targetDir) {
+  const configPath = memoryPath(targetDir, "config.json");
+  if (!existsSync9(configPath)) {
+    return false;
+  }
+  try {
+    const config = JSON.parse(readFileSync11(configPath, "utf8"));
+    return config.version === 1;
+  } catch {
+    return false;
+  }
+}
+async function gatherInitOptions(opts) {
+  const defaultDir = resolve3(opts.cwd ?? process.cwd());
+  const targetInput = await input({
+    message: "\u76EE\u6807\u76EE\u5F55\uFF08Git \u4ED3\u5E93\u6839\uFF09",
+    default: defaultDir
+  });
+  const targetDir = resolve3(targetInput);
+  const assistants = await checkbox({
+    message: "\u9009\u62E9\u8981\u63A5\u5165\u7684\u7F16\u7A0B\u52A9\u624B\uFF08\u53EF\u591A\u9009\uFF09",
+    choices: listAvailable().map((a) => ({
+      name: a.label,
+      value: a.id,
+      checked: a.id === "claude-code"
+    })),
+    validate: (value) => value.length > 0 || "\u8BF7\u81F3\u5C11\u9009\u62E9\u4E00\u9879"
+  });
+  const includeExampleTemplates = await confirm({
+    message: "\u662F\u5426\u5199\u5165 capture \u793A\u4F8B\u6A21\u677F\u5230 .memory/templates/\uFF1F",
+    default: true
+  });
+  if (isInitialized(targetDir)) {
+    const continueInit = await confirm({
+      message: "\u68C0\u6D4B\u5230\u5DF2\u6709 .memory/config.json\uFF0C\u662F\u5426\u4EC5\u8865\u5168\u7F3A\u5931\u9879\uFF1F",
+      default: true
+    });
+    if (!continueInit) {
+      return {
+        targetDir,
+        force: false,
+        includeExampleTemplates,
+        assistants,
+        cancelled: true
+      };
+    }
+  }
+  return {
+    targetDir,
+    force: Boolean(opts.force),
+    includeExampleTemplates,
+    assistants,
+    cancelled: false
+  };
+}
+
+// src/init/writeScaffoldFile.ts
+import { copyFileSync, writeFileSync as writeFileSync7 } from "fs";
+import { join as join12 } from "path";
+
+// src/init/mergeConfig.ts
+import { existsSync as existsSync10, readFileSync as readFileSync12 } from "fs";
+function mergeConfigForInit(repoRoot, assistants) {
+  const configPath = memoryPath(repoRoot, "config.json");
+  const existed = existsSync10(configPath);
+  let existing = {};
+  if (existed) {
+    try {
+      existing = JSON.parse(readFileSync12(configPath, "utf8"));
+    } catch {
+      existing = {};
+    }
+  }
+  const prevStorage = existing.storage && typeof existing.storage === "object" && !Array.isArray(existing.storage) ? existing.storage : {};
+  const merged = {
+    ...existing,
+    version: 1,
+    storage: {
+      ...prevStorage,
+      backend: "file"
+    },
+    assistants,
+    debug: existing.debug === true
+  };
+  return {
+    content: `${JSON.stringify(merged, null, 2)}
+`,
+    action: existed ? "overwritten" : "created"
+  };
+}
+
+// src/init/scaffoldWrite.ts
+import { existsSync as existsSync11, writeFileSync as writeFileSync6 } from "fs";
+function shouldWriteFile(absolutePath, force) {
+  if (!existsSync11(absolutePath)) {
+    return { write: true, action: "created" };
+  }
+  if (force) {
+    return { write: true, action: "overwritten" };
+  }
+  return { write: false, action: "skipped" };
+}
+function writeIfAllowed(report, absolutePath, relativePath, content, force) {
+  const { write, action } = shouldWriteFile(absolutePath, force);
+  if (!write) {
+    report.files.push({ path: relativePath, action });
+    return;
+  }
+  writeFileSync6(absolutePath, content, "utf8");
+  report.files.push({ path: relativePath, action });
+}
+
+// src/init/writeScaffoldFile.ts
+function writeConfigJson(report, repoRoot, assistants) {
+  const { content, action } = mergeConfigForInit(repoRoot, assistants);
+  const absolutePath = memoryPath(repoRoot, "config.json");
+  writeFileSync7(absolutePath, content, "utf8");
+  report.files.push({ path: ".memory/config.json", action });
+}
+function copyTemplateIfAllowed(report, templateName, destAbsolute, relativePath, force) {
+  const { write, action } = shouldWriteFile(destAbsolute, force);
+  if (!write) {
+    report.files.push({ path: relativePath, action });
+    return;
+  }
+  copyFileSync(resolveTemplatePath(templateName), destAbsolute);
+  report.files.push({ path: relativePath, action });
+}
+function writeScaffoldFiles(repoRoot, opts, report) {
+  const { force, includeExampleTemplates, assistants } = opts;
+  writeConfigJson(report, repoRoot, assistants);
+  writeIfAllowed(
+    report,
+    memoryPath(repoRoot, "MEMORY.md"),
+    ".memory/MEMORY.md",
+    renderTemplate("MEMORY.md.tpl"),
+    force
+  );
+  writeIfAllowed(
+    report,
+    memoryPath(repoRoot, "sessions", "index.json"),
+    ".memory/sessions/index.json",
+    `${JSON.stringify({ version: 1, sessions: [] }, null, 2)}
+`,
+    force
+  );
+  writeIfAllowed(
+    report,
+    memoryPath(repoRoot, "team", "steward-log.md"),
+    ".memory/team/steward-log.md",
+    renderTemplate("steward-log.md.tpl"),
+    force
+  );
+  writeIfAllowed(
+    report,
+    join12(repoRoot, "AGENTS.md"),
+    "AGENTS.md",
+    renderTemplate("AGENTS.md.tpl"),
+    force
+  );
+  for (const id of assistants) {
+    getAdapter(id).write({ repoRoot, force, report });
+  }
+  if (includeExampleTemplates) {
+    for (const name of EXAMPLE_TEMPLATE_FILES) {
+      const dest = memoryPath(repoRoot, "templates", name);
+      copyTemplateIfAllowed(
+        report,
+        name,
+        dest,
+        `.memory/templates/${name}`,
+        force
+      );
+    }
+  }
+}
+
+// src/init/runInit.ts
+function resolveTargetDir(cwd) {
+  const targetDir = resolve4(cwd ?? process.cwd());
+  const gitCheck = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], {
+    cwd: targetDir,
+    encoding: "utf8"
+  });
+  if (gitCheck.status !== 0) {
+    console.warn(
+      "warn: \u5F53\u524D\u76EE\u5F55\u53EF\u80FD\u4E0D\u662F Git \u4ED3\u5E93\uFF0Cinit \u4ECD\u4F1A\u7EE7\u7EED\uFF08\u5EFA\u8BAE\u5728\u6709 git \u7684\u9879\u76EE\u6839\u76EE\u5F55\u6267\u884C\uFF09"
+    );
+  }
+  return targetDir;
+}
+function resolveSelectedAssistants(opts) {
+  if (opts.assistants) {
+    validateAssistantSelection(opts.assistants);
+    return opts.assistants;
+  }
+  if (opts.tools) {
+    if (!opts.yes) {
+      console.error("init --tools requires -y in non-interactive mode");
+      process.exit(1);
+    }
+    return parseToolsArg(opts.tools);
+  }
+  if (opts.yes) {
+    return [...DEFAULT_ASSISTANT_IDS];
+  }
+  return [];
+}
+function printInitReport(report) {
+  const created = report.files.filter((f) => f.action === "created");
+  const skipped = report.files.filter((f) => f.action === "skipped");
+  const overwritten = report.files.filter((f) => f.action === "overwritten");
+  console.log(`
+hermes-repo init \u5B8C\u6210 \u2192 ${report.targetDir}
 `);
-process.exit(1);
+  console.log(`\u5DF2\u542F\u7528\u52A9\u624B: ${report.assistants.join(", ")}
+`);
+  if (created.length > 0) {
+    console.log(`\u5DF2\u521B\u5EFA (${created.length}):`);
+    for (const f of created) {
+      console.log(`  + ${f.path}`);
+    }
+  }
+  if (overwritten.length > 0) {
+    console.log(`\u5DF2\u8986\u76D6 (${overwritten.length}):`);
+    for (const f of overwritten) {
+      console.log(`  ~ ${f.path}`);
+    }
+  }
+  if (skipped.length > 0) {
+    console.log(`\u5DF2\u8DF3\u8FC7 (${skipped.length}):`);
+    for (const f of skipped) {
+      console.log(`  - ${f.path}`);
+    }
+  }
+  if (report.gitignoreAction) {
+    console.log(`
+.gitignore: ${report.gitignoreAction} hermes-repo \u6807\u8BB0\u5757`);
+  }
+  for (const warning of report.warnings) {
+    console.warn(`warn: ${warning}`);
+  }
+  console.log("");
+}
+async function runInit(opts) {
+  if (!process.stdin.isTTY && !opts.yes) {
+    console.error("init requires -y in non-interactive environments");
+    process.exit(1);
+  }
+  if (opts.tools && !opts.yes) {
+    console.error("init --tools requires -y");
+    process.exit(1);
+  }
+  let resolved;
+  if (opts.yes) {
+    const targetDir = resolveTargetDir(opts.cwd);
+    const selected = resolveSelectedAssistants(opts);
+    resolved = {
+      targetDir,
+      force: Boolean(opts.force),
+      includeExampleTemplates: opts.includeExampleTemplates ?? true,
+      assistants: mergeAssistants(targetDir, selected),
+      cancelled: false
+    };
+  } else {
+    const gathered = await gatherInitOptions(opts);
+    if (gathered.cancelled) {
+      console.log("init \u5DF2\u53D6\u6D88");
+      process.exit(0);
+    }
+    resolved = {
+      ...gathered,
+      assistants: mergeAssistants(gathered.targetDir, gathered.assistants)
+    };
+  }
+  const report = {
+    targetDir: resolved.targetDir,
+    assistants: resolved.assistants,
+    files: [],
+    warnings: []
+  };
+  ensureMemoryTree(resolved.targetDir);
+  writeScaffoldFiles(resolved.targetDir, resolved, report);
+  const gitignore = mergeHermesGitignore(resolved.targetDir);
+  report.gitignoreAction = gitignore.action;
+  if (gitignore.warnBroadMemoryIgnore) {
+    report.warnings.push(
+      ".gitignore \u4E2D\u5B58\u5728\u5BF9\u6574\u4E2A .memory/ \u7684\u5FFD\u7565\u89C4\u5219\uFF0C\u53EF\u80FD\u4E0E\u56E2\u961F\u5C42\u653E\u884C\u51B2\u7A81\uFF0C\u8BF7\u624B\u52A8\u68C0\u67E5"
+    );
+  }
+  printInitReport(report);
+  return report;
+}
+
+// src/commands/init.ts
+async function runInitCommand(opts) {
+  try {
+    await runInit(opts);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+var MIN_NODE_MAJOR = 20;
+function assertNodeVersion() {
+  const major = Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
+  if (major < MIN_NODE_MAJOR) {
+    console.error(
+      `hermes-repo requires Node.js >= ${MIN_NODE_MAJOR}. Current: ${process.versions.node}`
+    );
+    process.exit(1);
+  }
+}
+function main() {
+  assertNodeVersion();
+  const program = new Command();
+  program.name("hermes-repo").description(
+    "\u8DE8\u7F16\u7A0B\u52A9\u624B\u7684\u9879\u76EE\u7EA7\u8BB0\u5FC6\u7CFB\u7EDF\uFF1A\u5728 Git \u4ED3\u5E93\u4E2D\u6C89\u6DC0\u7EA6\u5B9A\u3001\u8E29\u5751\u4E0E\u53EF\u590D\u7528\u6D41\u7A0B"
+  ).version(readPkgVersion(), "-V, --version", "\u663E\u793A\u7248\u672C\u53F7");
+  program.command("init").description("\u5728\u5F53\u524D Git \u4ED3\u5E93\u521D\u59CB\u5316 .memory/ \u8BB0\u5FC6\u811A\u624B\u67B6").option("-y, --yes", "\u975E\u4EA4\u4E92\u6A21\u5F0F\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u9009\u9879").option("-f, --force", "\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u811A\u624B\u67B6\u6587\u4EF6\uFF08\u4E0D\u5220\u9664 captures \u7B49\u5185\u5BB9\uFF09").option("-C, --cwd <dir>", "\u76EE\u6807\u76EE\u5F55\uFF0C\u9ED8\u8BA4 process.cwd()").option(
+    "--tools <ids>",
+    "\u9017\u53F7\u5206\u9694\u7684\u52A9\u624B id\uFF0C\u5982 claude-code\uFF08\u987B\u4E0E -y \u5408\u7528\uFF09"
+  ).action(
+    (options) => {
+      void runInitCommand({
+        yes: options.yes,
+        force: options.force,
+        cwd: options.cwd,
+        tools: options.tools
+      });
+    }
+  );
+  program.command("capture").description("Stop hook\uFF1A\u6355\u83B7\u5F53\u524D Claude Code \u4F1A\u8BDD\u5230 .memory/captures/").option("-C, --cwd <dir>", "\u76EE\u6807\u4ED3\u5E93\u6839\u76EE\u5F55").option("--dry-run", "\u4EC5\u9884\u89C8\uFF0C\u4E0D\u5199\u5165\u6587\u4EF6").option("--strict", "\u5931\u8D25\u65F6 exit 1\uFF08hook \u9ED8\u8BA4 exit 0\uFF09").action((options) => {
+    runCaptureCommand({
+      cwd: options.cwd,
+      dryRun: options.dryRun,
+      strict: options.strict
+    });
+  });
+  program.command("inject").description("SessionStart hook\uFF1A\u5C06 MEMORY.md \u6458\u8981\u8F93\u51FA\u5230 stdout").option("-C, --cwd <dir>", "\u76EE\u6807\u4ED3\u5E93\u6839\u76EE\u5F55").option("--strict", "\u5931\u8D25\u65F6 exit 1\uFF08hook \u9ED8\u8BA4 exit 0\uFF09").action((options) => {
+    runInjectCommand({
+      cwd: options.cwd,
+      strict: options.strict
+    });
+  });
+  if (process.argv.length <= 2) {
+    program.outputHelp();
+    process.exit(0);
+  }
+  program.parse(process.argv);
+}
+main();
 //# sourceMappingURL=cli.js.map