aiwcli 0.10.2 → 0.11.0

package/dist/templates/_shared/hooks-ts/session_end.ts

@@ -0,0 +1,104 @@
+#!/usr/bin/env bun
+/**
+ * SessionEnd hook: Save session state, assign plan fields (fallback),
+ * stage has_plan/has_handoff for next session.
+ */
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+
+import { getProjectRoot } from "../lib-ts/base/constants.js";
+import { getGitState } from "../lib-ts/base/git-state.js";
+import {
+  loadHookInput, logDebug, logDiagnostic, logError, logInfo, logWarn as _logWarn, runHook,
+} from "../lib-ts/base/hook-utils.js";
+import { nowIso } from "../lib-ts/base/utils.js";
+import { getContextBySessionId, saveState } from "../lib-ts/context/context-store.js";
+import {
+  extractPlanAnchors, findLatestPlan, generatePlanId, normalizePlanContent,
+} from "../lib-ts/context/plan-manager.js";
+
+function main(): void {
+  const payload = loadHookInput();
+  if (!payload) return;
+
+  const sessionId = payload.session_id;
+  if (!sessionId) {
+    logDebug("session_end", "No session_id, skipping");
+    return;
+  }
+
+  const projectRoot = getProjectRoot(payload.cwd);
+  const source = payload.source ?? "unknown";
+  const permissionMode = payload.permission_mode ?? "";
+
+  const state = getContextBySessionId(sessionId, projectRoot);
+  if (!state) {
+    logDebug("session_end", `No context bound to session ${sessionId}`);
+    return;
+  }
+
+  // Capture git state
+  const gitState = getGitState(projectRoot);
+
+  // Save session metadata
+  state.last_session = {
+    session_id: sessionId,
+    save_reason: source,
+    saved_at: nowIso(),
+    transcript_path: payload.transcript_path ?? undefined,
+    git_state: gitState,
+  };
+  state.last_active = nowIso();
+
+  // Plan fallback assignment (skip in plan mode — rejected plans shouldn't stage)
+  if (permissionMode !== "plan") {
+    // Step 1: Assign plan fields if missing
+    if (!state.plan_hash) {
+      const latestPlanPath = findLatestPlan(state.id, projectRoot);
+      if (latestPlanPath) {
+        try {
+          const content = fs.readFileSync(latestPlanPath, "utf8");
+          const normalized = normalizePlanContent(content);
+          const planHash = crypto.createHash("sha256")
+            .update(normalized, "utf-8")
+            .digest("hex")
+            .slice(0, 12);
+
+          state.plan_hash = planHash;
+          state.plan_path = latestPlanPath;
+          state.plan_signature = content.slice(0, 200);
+          state.plan_id = generatePlanId();
+          state.plan_anchors = extractPlanAnchors(content);
+          state.plan_consumed = false;
+
+          logInfo("session_end", `Assigned plan fallback: hash=${planHash}, path=${latestPlanPath}`);
+        } catch (error) {
+          logError("session_end", `Failed to read plan: ${error}`);
+        }
+      }
+    }
+
+    // Step 2: Stage has_plan if conditions met
+    if (state.plan_hash && state.mode === "active" && !state.plan_consumed) {
+      state.mode = "has_plan";
+      logInfo("session_end", `Staged ${state.id}: active → has_plan`);
+    }
+    // If plan_consumed, skip — already consumed, don't re-stage
+  }
+
+  // Handoff staging (only if mode is still "active" — plan check may have changed it)
+  if (state.handoff_path && state.mode === "active" && !state.handoff_consumed) {
+    state.mode = "has_handoff";
+    logInfo("session_end", `Staged ${state.id}: active → has_handoff`);
+  }
+
+  // Save final state
+  const [ok, err] = saveState(state.id, state, projectRoot);
+  if (ok) {
+    logDiagnostic("session_end", "saved", `${state.id} mode=${state.mode}`);
+  } else {
+    logError("session_end", `Failed to save state: ${err}`);
+  }
+}
+
+runHook(main, "session_end");

package/dist/templates/_shared/hooks-ts/session_start.ts

@@ -0,0 +1,144 @@
+#!/usr/bin/env bun
+/**
+ * SessionStart hook: Restore context after /clear (plan/handoff) or compaction.
+ * Routes by source field to appropriate handler.
+ */
+import { getProjectRoot } from "../lib-ts/base/constants.js";
+import {
+  emitContext, loadHookInput, logDebug,
+  logDiagnostic, logError as _logError, logInfo, runHook,
+} from "../lib-ts/base/hook-utils.js";
+import {
+  buildRestoreSections, formatHandoffContinuation, getModeDisplay,
+} from "../lib-ts/context/context-formatter.js";
+import {
+  bindSession, getAllContexts, getContextBySessionId, updateMode,
+} from "../lib-ts/context/context-store.js";
+import type { ContextState as _ContextState } from "../lib-ts/types.js";
+
+/**
+ * Handle post-compaction restore: re-inject context that was lost during compaction.
+ * Plan content is inlined because Claude doesn't auto-paste after compact.
+ */
+function handleCompactRestore(sessionId: string, projectRoot: string): void {
+  const state = getContextBySessionId(sessionId, projectRoot);
+  if (!state) {
+    logDebug("session_start", `No context for session ${sessionId} (compact)`);
+    return;
+  }
+
+  const sections: string[] = [
+    `## Resuming Context After Compaction: ${state.id}`,
+    "",
+    `**Summary:** ${state.summary}`,
+    `**Mode:** ${getModeDisplay(state.mode) || state.mode}`,
+    "",
+  ];
+
+  // Inline plan = true (plan not auto-pasted after compact)
+  const restore = buildRestoreSections(state, projectRoot, true);
+  if (restore) sections.push(restore);
+
+  sections.push(
+    "",
+    "---",
+    "*Context was compacted to free up space. The above restores your working state.*",
+  );
+
+  emitContext(sections.join("\n"));
+  logInfo("session_start", `Compact restore for ${state.id}`);
+}
+
+/**
+ * Handle post-clear restore: find staged has_plan or has_handoff context,
+ * bind session, transition to active, inject context.
+ */
+function handleClearRestore(sessionId: string, projectRoot: string): void {
+  const allContexts = getAllContexts("active", projectRoot);
+
+  // Priority 1: has_plan contexts
+  const hasPlan = allContexts.filter(c => c.mode === "has_plan");
+  if (hasPlan.length > 0) {
+    // Pick most recently active (getAllContexts sorts by last_active desc)
+    const ctx = hasPlan[0]!;
+
+    bindSession(ctx.id, sessionId, projectRoot);
+    updateMode(ctx.id, "active", projectRoot, { plan_consumed: true });
+
+    logInfo("session_start", `Clear restore: ${ctx.id} has_plan → active (plan_consumed=true)`);
+
+    const sections: string[] = [
+      `## Resuming Context After Plan Clear: ${ctx.id}`,
+      "",
+      `**Summary:** ${ctx.summary}`,
+      `**Mode:** Active (Plan Restored)`,
+      "",
+    ];
+
+    // inline_plan=false — Claude auto-pastes plan content after /clear
+    const restore = buildRestoreSections(ctx, projectRoot, false);
+    if (restore) sections.push(restore);
+
+    sections.push(
+      "",
+      "---",
+      "*Plan has been accepted. The plan content was auto-pasted above. Implement according to the plan.*",
+    );
+
+    emitContext(sections.join("\n"));
+    return;
+  }
+
+  // Priority 2: has_handoff contexts
+  const hasHandoff = allContexts.filter(c => c.mode === "has_handoff");
+  if (hasHandoff.length > 0) {
+    const ctx = hasHandoff[0]!;
+
+    bindSession(ctx.id, sessionId, projectRoot);
+    updateMode(ctx.id, "active", projectRoot, { handoff_consumed: true });
+
+    logInfo("session_start", `Clear restore: ${ctx.id} has_handoff → active (handoff_consumed=true)`);
+
+    const handoffContent = formatHandoffContinuation(ctx, projectRoot);
+    emitContext(handoffContent);
+    return;
+  }
+
+  // Nothing to restore
+  logDebug("session_start", "No has_plan or has_handoff contexts found");
+}
+
+function main(): void {
+  const payload = loadHookInput();
+  if (!payload) return;
+
+  const sessionId = payload.session_id;
+  if (!sessionId) {
+    logDebug("session_start", "No session_id");
+    return;
+  }
+
+  const projectRoot = getProjectRoot(payload.cwd);
+  const source = payload.source ?? "";
+
+  logDiagnostic("session_start", "entry", `source=${source}, session=${sessionId}`);
+
+  switch (source) {
+    case "clear": {
+      handleClearRestore(sessionId, projectRoot);
+      break;
+    }
+
+    case "compact": {
+      handleCompactRestore(sessionId, projectRoot);
+      break;
+    }
+
+    default: {
+      logDebug("session_start", `Unhandled source: ${source}`);
+      break;
+    }
+  }
+}
+
+runHook(main, "session_start");

package/dist/templates/_shared/hooks-ts/task_create_capture.ts

@@ -0,0 +1,48 @@
+#!/usr/bin/env bun
+/**
+ * PostToolUse:TaskCreate hook: Persist Claude's TaskCreate calls to state.json.
+ */
+import { getProjectRoot } from "../lib-ts/base/constants.js";
+import {
+  checkSkipPersistence, getToolInput, loadHookInput, logDebug,
+  logError, logInfo, logWarn, runHook, validateHookEvent,
+} from "../lib-ts/base/hook-utils.js";
+import { getContextBySessionId } from "../lib-ts/context/context-store.js";
+import { addTask } from "../lib-ts/context/task-tracker.js";
+
+function main(): void {
+  const payload = loadHookInput();
+  if (!payload) return;
+  if (!validateHookEvent(payload, "PostToolUse", "TaskCreate")) return;
+
+  const toolInput = getToolInput(payload);
+  if (!toolInput) return;
+  if (checkSkipPersistence(payload, "task_create_capture")) return;
+
+  const projectRoot = getProjectRoot(payload.cwd);
+  const sessionId = payload.session_id ?? "unknown";
+
+  const state = getContextBySessionId(sessionId, projectRoot);
+  if (!state) {
+    logDebug("task_create_capture", `No context for session ${sessionId}`);
+    return;
+  }
+
+  const subject = toolInput.subject as string | undefined;
+  if (!subject) {
+    logWarn("task_create_capture", "TaskCreate missing subject field");
+    return;
+  }
+
+  const description = (toolInput.description as string) ?? "";
+  const activeForm = (toolInput.activeForm as string) ?? "";
+
+  const task = addTask(state.id, subject, description, activeForm, sessionId, projectRoot);
+  if (task) {
+    logInfo("task_create_capture", `Persisted task ${task.id}: ${subject}`);
+  } else {
+    logError("task_create_capture", `Failed to persist task: ${subject}`);
+  }
+}
+
+runHook(main, "task_create_capture");

package/dist/templates/_shared/hooks-ts/task_update_capture.ts

@@ -0,0 +1,74 @@
+#!/usr/bin/env bun
+/**
+ * PostToolUse:TaskUpdate hook: Persist Claude's TaskUpdate calls to state.json.
+ * Maps Claude's ephemeral task IDs to persistent aiw-N IDs.
+ */
+import { getProjectRoot } from "../lib-ts/base/constants.js";
+import {
+  checkSkipPersistence, getToolInput, loadHookInput, logDebug,
+  logError as _logError, logInfo, logWarn, runHook, validateHookEvent,
+} from "../lib-ts/base/hook-utils.js";
+import { getContextBySessionId } from "../lib-ts/context/context-store.js";
+import { deleteTask, updateTask } from "../lib-ts/context/task-tracker.js";
+
+function main(): void {
+  const payload = loadHookInput();
+  if (!payload) return;
+  if (!validateHookEvent(payload, "PostToolUse", "TaskUpdate")) return;
+
+  const toolInput = getToolInput(payload);
+  if (!toolInput) return;
+  if (checkSkipPersistence(payload, "task_update_capture")) return;
+
+  const projectRoot = getProjectRoot(payload.cwd);
+  const sessionId = payload.session_id ?? "unknown";
+
+  const state = getContextBySessionId(sessionId, projectRoot);
+  if (!state) {
+    logDebug("task_update_capture", `No context for session ${sessionId}`);
+    return;
+  }
+
+  const claudeTaskId = toolInput.taskId as string | undefined;
+  if (!claudeTaskId) {
+    logWarn("task_update_capture", "TaskUpdate missing taskId");
+    return;
+  }
+
+  // Map Claude's ephemeral ID to persistent ID
+  const metadata = (toolInput.metadata ?? {}) as Record<string, any>;
+  const persistentId = (metadata.persistent_id as string) ?? `aiw-${claudeTaskId}`;
+
+  const status = toolInput.status as string | undefined;
+
+  if (status === "deleted") {
+    const ok = deleteTask(state.id, persistentId, projectRoot);
+    if (ok) {
+      logInfo("task_update_capture", `Deleted task ${persistentId}`);
+    } else {
+      logWarn("task_update_capture", `Task ${persistentId} not found for deletion`);
+    }
+
+    return;
+  }
+
+  if (status) {
+    const opts: Record<string, any> = { status };
+    if (metadata.evidence) opts.evidence = metadata.evidence;
+    if (metadata.work_summary) opts.work_summary = metadata.work_summary;
+    if (metadata.files_changed && Array.isArray(metadata.files_changed)) {
+      opts.files_changed = metadata.files_changed;
+    }
+
+    opts.session_id = sessionId;
+
+    const ok = updateTask(state.id, persistentId, opts, projectRoot);
+    if (ok) {
+      logInfo("task_update_capture", `Updated task ${persistentId} → ${status}`);
+    } else {
+      logWarn("task_update_capture", `Task ${persistentId} not found for update`);
+    }
+  }
+}
+
+runHook(main, "task_update_capture");

package/dist/templates/_shared/hooks-ts/user_prompt_submit.ts

@@ -0,0 +1,83 @@
+#!/usr/bin/env bun
+/**
+ * UserPromptSubmit hook: Context enforcement — ensures every prompt belongs
+ * to a tracked context. The most complex shared hook.
+ *
+ * Uses emitContext() for output — context text is passed via hookSpecificOutput JSON.
+ * Catches BlockRequest and exits with code 2 to block the prompt.
+ */
+import { getProjectRoot } from "../lib-ts/base/constants.js";
+import {
+  emitContext, hookLog, loadHookInput, logBlocking, logDebug, logDiagnostic as _logDiagnostic, logInfo, logWarn as _logWarn, runHookAsync,
+} from "../lib-ts/base/hook-utils.js";
+import { BlockRequest, determineContext } from "../lib-ts/context/context-selector.js";
+import {
+  bindSession, getContextBySessionId, maybeActivate, saveState,
+} from "../lib-ts/context/context-store.js";
+
+async function asyncMain(): Promise<void> {
+  const payload = loadHookInput();
+  if (!payload) return;
+
+  const prompt = (payload as any).prompt as string | undefined;
+  const sessionId = payload.session_id;
+  const permissionMode = payload.permission_mode ?? "";
+  const projectRoot = getProjectRoot(payload.cwd);
+
+  if (!sessionId) {
+    logDebug("user_prompt_submit", "No session_id");
+    return;
+  }
+
+  const outputs: string[] = [];
+
+  // Check if session is already bound to a context
+  const existingCtx = getContextBySessionId(sessionId, projectRoot);
+
+  if (existingCtx) {
+    // Returning user — context already bound (stderr: false to avoid "hook error" display)
+    try {
+      maybeActivate(existingCtx.id, permissionMode, projectRoot, "user_prompt_submit");
+    } catch (error) {
+      hookLog("warn", "user_prompt_submit", `maybeActivate failed (non-critical): ${error}`, { stderr: false });
+    }
+
+    hookLog("debug", "user_prompt_submit", `Session bound to ${existingCtx.id}`, { stderr: false });
+  } else if (prompt) {
+    // First prompt — need to determine context
+    try {
+      const [contextId, method, outputText] = await determineContext(prompt, sessionId, projectRoot);
+
+      if (contextId) {
+        bindSession(contextId, sessionId, projectRoot);
+        maybeActivate(contextId, permissionMode, projectRoot, "user_prompt_submit");
+
+        // Clear handoff_path after binding (prevents re-injection)
+        const state = getContextBySessionId(sessionId, projectRoot);
+        if (state && state.handoff_path) {
+          state.handoff_path = null;
+          saveState(state.id, state, projectRoot);
+        }
+
+        logInfo("user_prompt_submit", `Context ${contextId} via ${method}`);
+      }
+
+      if (outputText) {
+        outputs.push(outputText);
+      }
+    } catch (error) {
+      if (error instanceof BlockRequest) {
+        logBlocking("user_prompt_submit", (error as Error).message);
+        process.exit(2); // Block the prompt
+      }
+
+      throw error; // Re-throw unexpected errors
+    }
+  }
+
+  if (outputs.length > 0) {
+    emitContext(outputs.join("\n\n"));
+  }
+}
+
+runHookAsync(asyncMain, "user_prompt_submit");