@lucapimenta/copy-chief-black 1.0.0

package/framework/.aios-core/copy-chief/recovery/recovery-handler.js

@@ -0,0 +1,437 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var recovery_handler_exports = {};
+__export(recovery_handler_exports, {
+  attemptEscalate: () => attemptEscalate,
+  attemptRecoveryWorkflow: () => attemptRecoveryWorkflow,
+  attemptRetry: () => attemptRetry,
+  attemptRollback: () => attemptRollback,
+  attemptSkip: () => attemptSkip,
+  classifyError: () => classifyError,
+  detectCircular: () => detectCircular,
+  executeRecovery: () => executeRecovery,
+  isAutoRecoverable: () => isAutoRecoverable,
+  logRecoveryAttempt: () => logRecoveryAttempt,
+  recoverHandoffTask: () => recoverHandoffTask
+});
+module.exports = __toCommonJS(recovery_handler_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_child_process = require("child_process");
+var import_os = require("os");
+const import_meta = {};
+const HOME = (0, import_os.homedir)();
+const ECOSYSTEM_ROOT = (0, import_path.join)(HOME, "copywriting-ecosystem");
+const RECOVERY_LOG_FILE = "recovery-log.yaml";
+const MAX_RETRIES = 3;
+const MAX_BACKOFF_MS = 3e4;
+const CIRCULAR_THRESHOLD = 3;
+const TRANSIENT_PATTERNS = [
+  /timeout/i,
+  /ETIMEDOUT/i,
+  /ECONNRESET/i,
+  /ECONNREFUSED/i,
+  /rate.?limit/i,
+  /429/i,
+  /503/i,
+  /502/i,
+  /mcp.*connection/i,
+  /session.*not.*found/i,
+  /EPIPE/i,
+  /socket.*hang.*up/i
+];
+const PERMANENT_PATTERNS = [
+  /not.*found/i,
+  /ENOENT/i,
+  /permission.*denied/i,
+  /EACCES/i,
+  /invalid.*input/i,
+  /validation.*fail/i,
+  /schema.*error/i,
+  /mecanismo.*not.*validated/i,
+  /gate.*blocked/i
+];
+function classifyError(error) {
+  for (const pattern of PERMANENT_PATTERNS) {
+    if (pattern.test(error)) return "PERMANENT";
+  }
+  for (const pattern of TRANSIENT_PATTERNS) {
+    if (pattern.test(error)) return "TRANSIENT";
+  }
+  return "TRANSIENT";
+}
+function detectCircular(history) {
+  const retries = history.filter((a) => a.strategy === "RETRY" && !a.success);
+  return retries.length >= CIRCULAR_THRESHOLD;
+}
+function logRecoveryAttempt(offerPath, attempt) {
+  const logPath = (0, import_path.join)(ECOSYSTEM_ROOT, offerPath, RECOVERY_LOG_FILE);
+  const logDir = (0, import_path.dirname)(logPath);
+  if (!(0, import_fs.existsSync)(logDir)) {
+    (0, import_fs.mkdirSync)(logDir, { recursive: true });
+  }
+  const entry = [
+    `  - timestamp: "${attempt.timestamp}"`,
+    `    error: "${escapeYaml(attempt.error)}"`,
+    `    tool: "${escapeYaml(attempt.tool)}"`,
+    `    strategy: "${attempt.strategy}"`,
+    `    attempts: ${attempt.attempts_total}`,
+    `    resolved: ${attempt.resolved}`,
+    `    action: "${escapeYaml(attempt.action)}"`
+  ].join("\n");
+  if ((0, import_fs.existsSync)(logPath)) {
+    const existing = (0, import_fs.readFileSync)(logPath, "utf-8");
+    (0, import_fs.writeFileSync)(logPath, existing.trimEnd() + "\n" + entry + "\n");
+  } else {
+    const header = `# Recovery log for ${offerPath}
+# Auto-generated by recovery-handler.ts
+recoveries:
+`;
+    (0, import_fs.writeFileSync)(logPath, header + entry + "\n");
+  }
+}
+function escapeYaml(s) {
+  return s.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}
+function attemptRetry(ctx) {
+  const errorClass = classifyError(ctx.error);
+  if (errorClass === "PERMANENT") return null;
+  if (detectCircular(ctx.attempt_history)) return null;
+  const pastRetries = ctx.attempt_history.filter((a) => a.strategy === "RETRY");
+  if (pastRetries.length >= MAX_RETRIES) return null;
+  const attemptNum = pastRetries.length + 1;
+  const backoffMs = Math.min(1e3 * Math.pow(2, pastRetries.length), MAX_BACKOFF_MS);
+  try {
+    (0, import_child_process.execSync)(`sleep ${backoffMs / 1e3}`, { stdio: "ignore" });
+  } catch {
+  }
+  const record = {
+    strategy: "RETRY",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    success: false,
+    // caller determines actual success
+    details: `Retry attempt ${attemptNum}/${MAX_RETRIES} after ${backoffMs}ms backoff for ${ctx.tool}`
+  };
+  ctx.attempt_history.push(record);
+  return {
+    resolved: false,
+    strategy_used: "RETRY",
+    attempts: attemptNum,
+    action_taken: `Waited ${backoffMs}ms, ready for retry attempt ${attemptNum}`,
+    should_continue_pipeline: false
+  };
+}
+function attemptRollback(ctx) {
+  try {
+    const idsPath = (0, import_path.join)((0, import_path.dirname)(new URL(import_meta.url).pathname), "ids.ts");
+    if (!(0, import_fs.existsSync)(idsPath)) {
+      return null;
+    }
+    const idsDir = (0, import_path.join)(HOME, ".claude", "ids");
+    const decisionsFile = (0, import_path.join)(idsDir, "decisions.json");
+    if (!(0, import_fs.existsSync)(decisionsFile)) return null;
+    const registry = JSON.parse((0, import_fs.readFileSync)(decisionsFile, "utf-8"));
+    const decisions = registry.decisions || [];
+    const relevant = decisions.filter(
+      (d) => d.status === "APPLIED" && d.files_affected?.some((f) => f.includes(ctx.offer_path))
+    );
+    if (relevant.length === 0) return null;
+    const lastDecision = relevant[relevant.length - 1];
+    let restored = 0;
+    for (const [filePath, content] of Object.entries(lastDecision.snapshots || {})) {
+      try {
+        if (content === null) {
+          continue;
+        }
+        const dir = (0, import_path.dirname)(filePath);
+        if (!(0, import_fs.existsSync)(dir)) (0, import_fs.mkdirSync)(dir, { recursive: true });
+        (0, import_fs.writeFileSync)(filePath, content);
+        restored++;
+      } catch {
+      }
+    }
+    lastDecision.status = "ROLLED_BACK";
+    lastDecision.rolled_back_at = (/* @__PURE__ */ new Date()).toISOString();
+    registry.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    (0, import_fs.writeFileSync)(decisionsFile, JSON.stringify(registry, null, 2));
+    const record = {
+      strategy: "ROLLBACK",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      success: restored > 0,
+      details: `Rolled back IDS decision ${lastDecision.id}, restored ${restored} file(s)`
+    };
+    ctx.attempt_history.push(record);
+    return {
+      resolved: restored > 0,
+      strategy_used: "ROLLBACK",
+      attempts: ctx.attempt_history.filter((a) => a.strategy === "ROLLBACK").length,
+      action_taken: `Rolled back decision ${lastDecision.id} (${restored} files restored)`,
+      should_continue_pipeline: restored > 0
+    };
+  } catch (err) {
+    const record = {
+      strategy: "ROLLBACK",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      success: false,
+      details: `Rollback failed: ${err}`
+    };
+    ctx.attempt_history.push(record);
+    return null;
+  }
+}
+function attemptSkip(ctx) {
+  const skipReason = `Error in ${ctx.tool} during ${ctx.phase}: ${ctx.error.slice(0, 200)}`;
+  const deliverableInfo = ctx.deliverable ? ` (deliverable: ${ctx.deliverable})` : "";
+  const record = {
+    strategy: "SKIP",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    success: true,
+    details: `Skipped${deliverableInfo}. Reason: ${skipReason}`
+  };
+  ctx.attempt_history.push(record);
+  return {
+    resolved: true,
+    strategy_used: "SKIP",
+    attempts: 1,
+    action_taken: `Skipped ${ctx.tool}${deliverableInfo}, flagged for human review`,
+    should_continue_pipeline: true
+  };
+}
+function attemptEscalate(ctx) {
+  try {
+    const queuePath = (0, import_path.join)(ECOSYSTEM_ROOT, ctx.offer_path, "pending-decisions.yaml");
+    const queueDir = (0, import_path.dirname)(queuePath);
+    if (!(0, import_fs.existsSync)(queueDir)) (0, import_fs.mkdirSync)(queueDir, { recursive: true });
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const tsClean = ts.replace(/[-:T]/g, "").slice(0, 14);
+    const rand = Math.random().toString(36).substring(2, 6);
+    const decisionId = `dec-${tsClean}-${rand}`;
+    const historyStr = ctx.attempt_history.map((a) => `${a.strategy}(${a.success ? "ok" : "fail"})`).join(" -> ");
+    const entry = [
+      `  - id: "${decisionId}"`,
+      `    offer_id: "${escapeYaml(ctx.offer_path)}"`,
+      `    criterion_id: "recovery-escalation"`,
+      `    type: "help_request"`,
+      `    priority: "HIGH"`,
+      `    status: "PENDING"`,
+      `    blocking: true`,
+      `    title: "Recovery failed: ${escapeYaml(ctx.tool)} in ${escapeYaml(ctx.phase)}"`,
+      `    context: "Error: ${escapeYaml(ctx.error.slice(0, 300))}\\nHistory: ${escapeYaml(historyStr)}"`,
+      `    created_at: "${ts}"`
+    ].join("\n");
+    if ((0, import_fs.existsSync)(queuePath)) {
+      const existing = (0, import_fs.readFileSync)(queuePath, "utf-8");
+      (0, import_fs.writeFileSync)(queuePath, existing.trimEnd() + "\n" + entry + "\n");
+    } else {
+      const header = `version: "1.0.0"
+updated_at: "${ts}"
+decisions:
+`;
+      (0, import_fs.writeFileSync)(queuePath, header + entry + "\n");
+    }
+    const record = {
+      strategy: "ESCALATE",
+      timestamp: ts,
+      success: true,
+      details: `Escalated to decision queue as ${decisionId}`
+    };
+    ctx.attempt_history.push(record);
+    return {
+      resolved: false,
+      strategy_used: "ESCALATE",
+      attempts: 1,
+      action_taken: `Escalated to human decision queue (${decisionId}). Pipeline paused for this deliverable.`,
+      should_continue_pipeline: false
+    };
+  } catch (err) {
+    const record = {
+      strategy: "ESCALATE",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      success: false,
+      details: `Escalation failed: ${err}`
+    };
+    ctx.attempt_history.push(record);
+    return null;
+  }
+}
+const RECOVERY_WORKFLOWS = {
+  // MCP connection failures: restart MCP server
+  "mcp_connection": (ctx) => {
+    try {
+      (0, import_child_process.execSync)("claude mcp list 2>/dev/null", { timeout: 5e3, stdio: "pipe" });
+      return "MCP server list refreshed; connection may recover on next call";
+    } catch {
+      return null;
+    }
+  },
+  // Gate blocked: show what's missing
+  "gate_blocked": (ctx) => {
+    try {
+      const statePath = (0, import_path.join)(ECOSYSTEM_ROOT, ctx.offer_path, "helix-state.yaml");
+      if ((0, import_fs.existsSync)(statePath)) {
+        const state = (0, import_fs.readFileSync)(statePath, "utf-8");
+        return `Gate blocked. Current helix-state:
+${state.slice(0, 500)}`;
+      }
+      return "Gate blocked but no helix-state.yaml found. Create it first.";
+    } catch {
+      return null;
+    }
+  },
+  // Validation score too low: suggest rewrite
+  "low_score": (_ctx) => {
+    return "Validation score below threshold. Deliverable should be rewritten with stronger specificity and VOC alignment.";
+  }
+};
+function attemptRecoveryWorkflow(ctx) {
+  let workflowKey = null;
+  const errorLower = ctx.error.toLowerCase();
+  if (/mcp.*connection|session.*not.*found/i.test(ctx.error)) {
+    workflowKey = "mcp_connection";
+  } else if (/gate.*blocked/i.test(ctx.error)) {
+    workflowKey = "gate_blocked";
+  } else if (/score.*\d|below.*threshold/i.test(ctx.error)) {
+    workflowKey = "low_score";
+  }
+  if (!workflowKey || !RECOVERY_WORKFLOWS[workflowKey]) return null;
+  const result = RECOVERY_WORKFLOWS[workflowKey](ctx);
+  if (!result) return null;
+  const record = {
+    strategy: "RECOVERY_WORKFLOW",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    success: true,
+    details: `Executed workflow '${workflowKey}': ${result}`
+  };
+  ctx.attempt_history.push(record);
+  return {
+    resolved: true,
+    strategy_used: `RECOVERY_WORKFLOW:${workflowKey}`,
+    attempts: 1,
+    action_taken: result,
+    should_continue_pipeline: true
+  };
+}
+function executeRecovery(ctx) {
+  const errorClass = classifyError(ctx.error);
+  const isCircular = detectCircular(ctx.attempt_history);
+  const strategies = [];
+  if (errorClass === "TRANSIENT" && !isCircular) {
+    strategies.push(attemptRetry, attemptRecoveryWorkflow, attemptRollback, attemptSkip, attemptEscalate);
+  } else if (errorClass === "PERMANENT") {
+    strategies.push(attemptRecoveryWorkflow, attemptRollback, attemptSkip, attemptEscalate);
+  } else {
+    strategies.push(attemptRollback, attemptRecoveryWorkflow, attemptSkip, attemptEscalate);
+  }
+  let totalAttempts = ctx.attempt_history.length;
+  for (const strategy of strategies) {
+    const result = strategy(ctx);
+    if (result) {
+      totalAttempts = ctx.attempt_history.length;
+      const lastRecord = ctx.attempt_history[ctx.attempt_history.length - 1];
+      if (lastRecord) {
+        logRecoveryAttempt(ctx.offer_path, {
+          ...lastRecord,
+          error: ctx.error,
+          tool: ctx.tool,
+          attempts_total: totalAttempts,
+          resolved: result.resolved,
+          action: result.action_taken
+        });
+      }
+      if (result.resolved || result.strategy_used === "ESCALATE") {
+        return { ...result, attempts: totalAttempts };
+      }
+      if (result.strategy_used === "RETRY") {
+        return { ...result, attempts: totalAttempts };
+      }
+    }
+  }
+  const fallback = {
+    resolved: false,
+    strategy_used: "EXHAUSTED",
+    attempts: ctx.attempt_history.length,
+    action_taken: `All 5 recovery strategies exhausted for ${ctx.tool} in ${ctx.phase}. Manual intervention required.`,
+    should_continue_pipeline: false
+  };
+  logRecoveryAttempt(ctx.offer_path, {
+    strategy: "ESCALATE",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    success: false,
+    details: "All strategies exhausted",
+    error: ctx.error,
+    tool: ctx.tool,
+    attempts_total: ctx.attempt_history.length,
+    resolved: false,
+    action: fallback.action_taken
+  });
+  return fallback;
+}
+function recoverHandoffTask(params) {
+  const ctx = {
+    error: params.error,
+    tool: params.task_type,
+    offer_path: params.offer_path,
+    phase: params.phase,
+    deliverable: params.deliverable,
+    attempt_history: params.attempt_history || []
+  };
+  const result = executeRecovery(ctx);
+  let recommendation;
+  if (result.strategy_used === "RETRY" && !result.resolved) {
+    recommendation = "retry";
+  } else if (result.resolved && result.should_continue_pipeline) {
+    recommendation = "skip";
+  } else {
+    recommendation = "pause";
+  }
+  try {
+    const logDir = (0, import_path.join)(HOME, ".claude/logs");
+    if (!(0, import_fs.existsSync)(logDir)) (0, import_fs.mkdirSync)(logDir, { recursive: true });
+    const event = {
+      type: "recovery_attempted",
+      deliverable: params.deliverable,
+      task_id: params.task_id,
+      offer_path: params.offer_path,
+      strategy: result.strategy_used,
+      resolved: result.resolved,
+      recommendation,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    (0, import_fs.appendFileSync)((0, import_path.join)(logDir, "handoff-events.jsonl"), JSON.stringify(event) + "\n");
+  } catch {
+  }
+  return { ...result, recommendation };
+}
+function isAutoRecoverable(error) {
+  const errorClass = classifyError(error);
+  return errorClass === "TRANSIENT";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  attemptEscalate,
+  attemptRecoveryWorkflow,
+  attemptRetry,
+  attemptRollback,
+  attemptSkip,
+  classifyError,
+  detectCircular,
+  executeRecovery,
+  isAutoRecoverable,
+  logRecoveryAttempt,
+  recoverHandoffTask
+});