claude-ketchup 0.7.0 → 0.8.1

package/dist/bundle/scripts/auto-continue.js

@@ -0,0 +1,215 @@
+#!/usr/bin/env npx tsx
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// scripts/auto-continue.ts
+var fs3 = __toESM(require("node:fs"));
+var path3 = __toESM(require("node:path"));
+
+// src/hook-logger.ts
+var fs = __toESM(require("node:fs"));
+var path = __toESM(require("node:path"));
+function sanitizeForFilename(hookName) {
+  return hookName.replace(/[^a-zA-Z0-9-]/g, "-").toLowerCase();
+}
+function writeHookLog(claudeDir2, entry) {
+  const logsDir = path.join(claudeDir2, "logs", "hooks");
+  if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true });
+  }
+  const sanitizedName = sanitizeForFilename(entry.hookName);
+  const logFilename = `${sanitizedName}-${entry.timestamp}.log`;
+  const logPath = path.join(logsDir, logFilename);
+  const lines = [];
+  lines.push(`=== ${entry.hookName} hook log ===`);
+  lines.push(`Timestamp: ${entry.timestamp}`);
+  if (entry.durationMs !== void 0) {
+    lines.push(`Duration: ${entry.durationMs}ms`);
+  }
+  lines.push("");
+  lines.push("--- Input ---");
+  lines.push(JSON.stringify(entry.input, null, 2));
+  lines.push("");
+  if (entry.resolvedPaths) {
+    lines.push("--- Resolved Paths ---");
+    for (const [key, value] of Object.entries(entry.resolvedPaths)) {
+      lines.push(`  ${key}: ${String(value)}`);
+    }
+    lines.push("");
+  }
+  if (entry.reminderFiles) {
+    lines.push(`--- Reminder Files Found (${entry.reminderFiles.length}) ---`);
+    for (const file of entry.reminderFiles) {
+      lines.push(`  ${file}`);
+    }
+    lines.push("");
+  }
+  if (entry.matchedReminders) {
+    lines.push(`--- Matched Reminders (${entry.matchedReminders.length}) ---`);
+    for (const r of entry.matchedReminders) {
+      lines.push(`  ${r.name} (priority: ${r.priority})`);
+    }
+    lines.push("");
+  }
+  if (entry.error) {
+    lines.push("--- Error ---");
+    lines.push(entry.error);
+    lines.push("");
+  }
+  lines.push("--- Output ---");
+  lines.push(JSON.stringify(entry.output, null, 2));
+  lines.push("");
+  fs.writeFileSync(logPath, lines.join("\n"));
+}
+
+// src/hook-state.ts
+var fs2 = __toESM(require("node:fs"));
+var path2 = __toESM(require("node:path"));
+var DEFAULT_HOOK_STATE = {
+  autoContinue: {
+    mode: "smart",
+    maxIterations: 0,
+    iteration: 0,
+    skipModes: ["plan"]
+  },
+  validateCommit: {
+    mode: "strict"
+  },
+  denyList: {
+    enabled: true,
+    extraPatterns: []
+  },
+  promptReminder: {
+    enabled: true
+  },
+  subagentHooks: {
+    validateCommitOnExplore: false,
+    validateCommitOnWork: true,
+    validateCommitOnUnknown: true
+  },
+  updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+  updatedBy: "default"
+};
+function createHookState(projectDir2) {
+  const stateFile = path2.join(projectDir2, ".claude.hooks.json");
+  function read() {
+    if (!fs2.existsSync(stateFile)) {
+      const state = { ...DEFAULT_HOOK_STATE, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), updatedBy: "init" };
+      fs2.writeFileSync(stateFile, `${JSON.stringify(state, null, 2)}
+`);
+      return state;
+    }
+    const content = fs2.readFileSync(stateFile, "utf-8");
+    const partial = JSON.parse(content);
+    return {
+      autoContinue: { ...DEFAULT_HOOK_STATE.autoContinue, ...partial.autoContinue },
+      validateCommit: { ...DEFAULT_HOOK_STATE.validateCommit, ...partial.validateCommit },
+      denyList: { ...DEFAULT_HOOK_STATE.denyList, ...partial.denyList },
+      promptReminder: { ...DEFAULT_HOOK_STATE.promptReminder, ...partial.promptReminder },
+      subagentHooks: { ...DEFAULT_HOOK_STATE.subagentHooks, ...partial.subagentHooks },
+      updatedAt: partial.updatedAt ?? DEFAULT_HOOK_STATE.updatedAt,
+      updatedBy: partial.updatedBy
+    };
+  }
+  function write(state) {
+    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    fs2.writeFileSync(stateFile, `${JSON.stringify(state, null, 2)}
+`);
+  }
+  function update(updates, updatedBy) {
+    const current = read();
+    const newState = {
+      ...current,
+      ...updates,
+      autoContinue: { ...current.autoContinue, ...updates.autoContinue },
+      validateCommit: { ...current.validateCommit, ...updates.validateCommit },
+      denyList: { ...current.denyList, ...updates.denyList },
+      promptReminder: { ...current.promptReminder, ...updates.promptReminder },
+      subagentHooks: { ...current.subagentHooks, ...updates.subagentHooks },
+      updatedBy: updatedBy ?? "unknown",
+      updatedAt: current.updatedAt
+    };
+    write(newState);
+    return newState;
+  }
+  function incrementIteration() {
+    const state = read();
+    state.autoContinue.iteration = state.autoContinue.iteration + 1;
+    write(state);
+    return state.autoContinue.iteration;
+  }
+  function resetIteration() {
+    const state = read();
+    state.autoContinue.iteration = 0;
+    write(state);
+  }
+  return {
+    read,
+    write,
+    update,
+    incrementIteration,
+    resetIteration
+  };
+}
+
+// src/hooks/auto-continue.ts
+function handleStop(projectDir2, input2) {
+  const stateManager = createHookState(projectDir2);
+  const state = stateManager.read();
+  const { mode, skipModes } = state.autoContinue;
+  if (mode === "off") {
+    return { decision: "allow", reason: "auto-continue disabled" };
+  }
+  if (input2.stop_hook_active) {
+    return { decision: "allow", reason: "stop hook already active" };
+  }
+  const modesToSkip = skipModes ?? ["plan"];
+  if (input2.permission_mode && modesToSkip.includes(input2.permission_mode)) {
+    return { decision: "allow", reason: `skipping mode: ${input2.permission_mode}` };
+  }
+  return { decision: "allow", reason: "no work remaining" };
+}
+
+// scripts/auto-continue.ts
+var projectDir = process.cwd();
+var claudeDir = path3.resolve(projectDir, ".claude");
+var stdin = fs3.readFileSync(0, "utf8").trim();
+if (!stdin) {
+  process.exit(0);
+}
+var input = JSON.parse(stdin);
+var startTime = Date.now();
+var result = handleStop(projectDir, input);
+var output = result.decision === "block" ? { stopReason: result.reason, forceResult: { behaviour: "block" } } : null;
+writeHookLog(claudeDir, {
+  hookName: "auto-continue",
+  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+  input,
+  output: output ?? { decision: result.decision, reason: result.reason },
+  durationMs: Date.now() - startTime
+});
+if (output) {
+  console.log(JSON.stringify(output));
+}
+process.exit(0);