aiwcli 0.15.5 → 0.17.0

package/dist/templates/{_shared/lib-ts/base → core/lib-ts/hooks}/hook-utils.ts

@@ -6,10 +6,11 @@
 
 import * as fs from "node:fs";
 
-import { getProjectRoot } from "./constants.js";
-import { logDebug,  logWarn,     hookLog, setSessionId,  getContextPath as _getContextPath } from "./logger.js";
-import { getContextBySessionId } from "../context/context-store.js";
-import type { HookInput, HookOutput, PermissionRequestOutput } from "../types.js";
+import { getContextBySessionId, maybeActivate } from "../context/context-store.js";
+import { getProjectRoot } from "../runtime/constants.js";
+import { logDebug,  logWarn,     hookLog, setSessionId,  getContextPath as _getContextPath } from "../runtime/logger.js";
+import { HookInputSchema } from "../schemas.js";
+import type { ContextState, HookInput, HookOutput, PermissionRequestOutput } from "../types.js";
 
 // Re-export logger functions for convenience (matches Python hook_utils re-exports)
 
@@ -24,7 +25,120 @@ let _lastToolName: string | null = null;
 let _cachedHookName: string | null = null;
 
 // Pre-fetched input stash
-let _prefetchedInput: Record<string, any> | null = null;
+let _prefetchedInput: Record<string, unknown> | null = null;
+
+function readStringField(value: Record<string, unknown>, key: string): null | string {
+  const field = value[key];
+  return typeof field === "string" ? field : null;
+}
+
+export interface BoundSessionContext {
+  payload: HookInput;
+  projectRoot: string;
+  sessionId: string;
+  state: ContextState;
+}
+
+export interface PersistenceContext extends BoundSessionContext {
+  toolInput: Record<string, unknown>;
+}
+
+export interface ToolInputContext {
+  payload: HookInput;
+  toolInput: Record<string, unknown>;
+}
+
+/**
+ * Load the current payload, resolve its project root, and require an already-bound session.
+ * Returns null when the hook should quietly no-op.
+ */
+export function requireBoundSession(
+  hookName: string,
+  prefetchedPayload?: HookInput | null,
+): BoundSessionContext | null {
+  const payload = prefetchedPayload ?? loadHookInput();
+  if (!payload) return null;
+
+  const sessionId = payload.session_id;
+  if (!sessionId) {
+    logDebug(hookName, "No session_id available");
+    return null;
+  }
+
+  const projectRoot = getProjectRoot(payload.cwd);
+  const state = getContextBySessionId(sessionId, projectRoot);
+  if (!state) {
+    logDebug(hookName, `No bound context for session ${sessionId.slice(0, 8)}`);
+    return null;
+  }
+
+  return { payload, projectRoot, sessionId, state };
+}
+
+/**
+ * Require a bound session plus tool_input for PostToolUse task persistence hooks.
+ */
+export function requirePersistenceContext(
+  expectedTool: string,
+  hookName: string,
+): PersistenceContext | null {
+  const bound = requireBoundSession(hookName);
+  if (!bound) return null;
+
+  const { payload } = bound;
+  if (payload.hook_event_name !== "PostToolUse") {
+    return null;
+  }
+  if (payload.tool_name !== expectedTool) {
+    return null;
+  }
+  if (checkSkipPersistence(payload, hookName)) {
+    return null;
+  }
+
+  const toolInput = getToolInput(payload);
+  if (!toolInput) {
+    logWarn(hookName, `${expectedTool} missing tool_input payload`);
+    return null;
+  }
+
+  return { ...bound, toolInput };
+}
+
+/**
+ * Require a tool_input payload for tool-oriented hooks without needing a bound session.
+ */
+export function requireToolInput(
+  hookName: string,
+): ToolInputContext | null {
+  const payload = loadHookInput();
+  if (!payload) return null;
+
+  const toolInput = getToolInput(payload);
+  if (!toolInput) {
+    logDebug(hookName, "No tool_input payload");
+    return null;
+  }
+
+  return { payload, toolInput };
+}
+
+/**
+ * Best-effort wrapper around maybeActivate. Hooks should never fail closed on activation.
+ */
+export function safeMaybeActivate(
+  contextId: string,
+  permissionMode: string,
+  projectRoot?: string,
+  hookName = "hook",
+): boolean {
+  try {
+    return maybeActivate(contextId, permissionMode, projectRoot, hookName);
+  } catch (error) {
+    logWarn(hookName, `maybeActivate failed for ${contextId}: ${error}`);
+    return false;
+  }
+}
 
 /**
  * Load and parse JSON from stdin (or return prefetched input if set).
@@ -36,23 +150,28 @@ export function loadHookInput(): HookInput | null {
     const result = _prefetchedInput;
     _prefetchedInput = null; // consume once
     if (result && typeof result === "object") {
-      _lastHookEvent = result.hook_event_name ?? null;
-      _lastToolName = result.tool_name ?? null;
+      _lastHookEvent = readStringField(result, "hook_event_name");
+      _lastToolName = readStringField(result, "tool_name");
     }
-    return result as HookInput;
+    return result as unknown as HookInput;
   }
 
   try {
     // Read entire stdin using fd 0 (cross-platform, works on Windows)
-    const inputData = fs.readFileSync(0, "utf-8").trim();
+    const inputData = fs.readFileSync(0, "utf8").trim();
     if (!inputData) return null;
 
-    const result = JSON.parse(inputData);
+    const result = JSON.parse(inputData) as Record<string, unknown>;
+    const validated = HookInputSchema.safeParse(result);
+    if (!validated.success) {
+      logWarn("hook_utils", `Hook input schema validation failed: ${validated.error.message}`);
+      return null;
+    }
     if (result && typeof result === "object") {
-      _lastHookEvent = result.hook_event_name ?? null;
-      _lastToolName = result.tool_name ?? null;
+      _lastHookEvent = readStringField(result, "hook_event_name");
+      _lastToolName = readStringField(result, "tool_name");
     }
-    return result as HookInput;
+    return result as unknown as HookInput;
   } catch {
     return null;
   }
@@ -78,7 +197,7 @@ export function validateHookEvent(
  */
 export function getToolInput(
   payload: HookInput,
-): Record<string, any> | null {
+): Record<string, unknown> | null {
   const toolInput = payload.tool_input;
   return toolInput && typeof toolInput === "object" ? toolInput : null;
 }
@@ -95,7 +214,11 @@ export function checkSkipPersistence(
   if (!toolInput) return false;
 
   const {metadata} = toolInput;
-  if (metadata && typeof metadata === "object" && metadata.skip_persistence) {
+  if (
+    metadata &&
+    typeof metadata === "object" &&
+    Boolean((metadata as Record<string, unknown>).skip_persistence)
+  ) {
     logDebug(hookName, "Skipping persistence (skip_persistence flag set)");
     return true;
   }
@@ -167,12 +290,12 @@ export function emitContextAndBlock(
 }
 
 /** Log hook output (context, systemMessage, or block) to hook-log.jsonl for visibility. */
-function _logEmit(type: "context" | "systemMessage" | "block", chars: number, payload: Record<string, any>): void {
+function _logEmit(type: "context" | "systemMessage" | "block", chars: number, payload: Record<string, unknown>): void {
   const hook = _cachedHookName ?? "unknown";
   const event = payload.event ?? "unknown";
   const mechanism = payload.mechanism ? ` via ${payload.mechanism}` : "";
   const msg = type === "block"
-    ? `HOOK_OUTPUT [${type}] ${event} ${chars} chars${mechanism}, reason="${(payload.blockReason ?? "").slice(0, 80)}"`
+    ? `HOOK_OUTPUT [${type}] ${event} ${chars} chars${mechanism}, reason="${String(payload.blockReason ?? "").slice(0, 80)}"`
     : `HOOK_OUTPUT [${type}] ${event} ${chars} chars`;
   hookLog("info", hook, msg, { data: payload });
 }
@@ -316,8 +439,13 @@ export function emitBlock(reason: string, context?: string): void {
  */
 function detectTemplate(scriptPath = ""): string {
   const p = (scriptPath || (process.argv[1] ?? "")).replaceAll('\\', "/");
-  if (p.includes("/_shared/hooks/") || p.startsWith("_shared/hooks/")) {
-    return "shared";
+  if (
+    p.includes("/_core/hooks-ts/") ||
+    p.startsWith("_core/hooks-ts/") ||
+    p.includes("/core/hooks-ts/") ||
+    p.startsWith("core/hooks-ts/")
+  ) {
+    return "core";
   }
   const match = p.match(/_([a-z][a-z0-9-]*)\/hooks\//);
   if (match?.[1]) return match[1]; // e.g., "cc-native"
@@ -390,32 +518,39 @@ export function getContextPercentRemaining(
  * Read stdin early and extract session_id + event metadata.
  * Stashes parsed input for loadHookInput() to consume later.
  */
-function _earlyReadInput(prefetchedInput?: Record<string, any>): void {
+function _earlyReadInput(prefetchedInput?: Record<string, unknown>): void {
   if (prefetchedInput !== undefined) {
     _prefetchedInput = prefetchedInput;
   }
 
   // If we already have prefetched input, extract metadata from it
   if (_prefetchedInput && typeof _prefetchedInput === "object") {
-    _lastHookEvent = _prefetchedInput.hook_event_name ?? null;
-    _lastToolName = _prefetchedInput.tool_name ?? null;
-    if (_prefetchedInput.session_id) {
-      setSessionId(_prefetchedInput.session_id);
+    _lastHookEvent = readStringField(_prefetchedInput, "hook_event_name");
+    _lastToolName = readStringField(_prefetchedInput, "tool_name");
+    const sessionId = readStringField(_prefetchedInput, "session_id");
+    if (sessionId) {
+      setSessionId(sessionId);
     }
     return;
   }
 
   // Read stdin now so HOOK_START can include sid
   try {
-    const inputData = fs.readFileSync(0, "utf-8").trim();
+    const inputData = fs.readFileSync(0, "utf8").trim();
     if (inputData) {
-      const parsed = JSON.parse(inputData);
+      const parsed = JSON.parse(inputData) as Record<string, unknown>;
+      const validated = HookInputSchema.safeParse(parsed);
+      if (!validated.success) {
+        logWarn("hook_utils", `Early input schema validation failed: ${validated.error.message}`);
+        return;
+      }
       if (parsed && typeof parsed === "object") {
         _prefetchedInput = parsed;
-        _lastHookEvent = parsed.hook_event_name ?? null;
-        _lastToolName = parsed.tool_name ?? null;
-        if (parsed.session_id) {
-          setSessionId(parsed.session_id);
+        _lastHookEvent = readStringField(parsed, "hook_event_name");
+        _lastToolName = readStringField(parsed, "tool_name");
+        const sessionId = readStringField(parsed, "session_id");
+        if (sessionId) {
+          setSessionId(sessionId);
         }
       }
     }
@@ -431,7 +566,7 @@ function _earlyReadInput(prefetchedInput?: Record<string, any>): void {
 export function runHook(
   mainFunc: () => number | void,
   hookName = "unknown",
-  prefetchedInput?: Record<string, any>,
+  prefetchedInput?: Record<string, unknown>,
 ): never {
   _earlyReadInput(prefetchedInput);
   _cachedHookName = hookName;
@@ -439,7 +574,8 @@ export function runHook(
   // Ensure cwd is project root so relative paths in hooks resolve correctly,
   // even when cwd has drifted via `cd` in a Bash tool call.
   try {
-    const projectRoot = getProjectRoot(_prefetchedInput?.cwd);
+    const cwd = _prefetchedInput ? readStringField(_prefetchedInput, "cwd") ?? undefined : undefined;
+    const projectRoot = getProjectRoot(cwd);
     if (process.cwd() !== projectRoot) process.chdir(projectRoot);
   } catch { /* non-fatal — proceed with current cwd */ }
 
@@ -448,7 +584,7 @@ export function runHook(
   const event = _lastHookEvent ?? "unknown";
   const tool = _lastToolName;
 
-  const startData: Record<string, any> = {
+  const startData: Record<string, unknown> = {
     lifecycle: "start",
     template,
     event,
@@ -464,7 +600,7 @@ export function runHook(
     const result = mainFunc();
     exitCode = typeof result === "number" ? result : 0;
     status = exitCode !== 0 ? "blocked" : "success";
-  } catch (error: any) {
+  } catch (error: unknown) {
     if (error instanceof Error && error.message.startsWith("SystemExit:")) {
       const code = parseInt(error.message.slice(11), 10);
       exitCode = isNaN(code) ? (error.message.slice(11) ? 1 : 0) : code;
@@ -489,7 +625,7 @@ export function runHook(
 export function runHookAsync(
   mainFunc: () => Promise<number | void>,
   hookName = "unknown",
-  prefetchedInput?: Record<string, any>,
+  prefetchedInput?: Record<string, unknown>,
 ): void {
   _earlyReadInput(prefetchedInput);
   _cachedHookName = hookName;
@@ -497,7 +633,8 @@ export function runHookAsync(
   // Ensure cwd is project root so relative paths in hooks resolve correctly,
   // even when cwd has drifted via `cd` in a Bash tool call.
   try {
-    const projectRoot = getProjectRoot(_prefetchedInput?.cwd);
+    const cwd = _prefetchedInput ? readStringField(_prefetchedInput, "cwd") ?? undefined : undefined;
+    const projectRoot = getProjectRoot(cwd);
     if (process.cwd() !== projectRoot) process.chdir(projectRoot);
   } catch { /* non-fatal — proceed with current cwd */ }
 
@@ -506,7 +643,7 @@ export function runHookAsync(
   const event = _lastHookEvent ?? "unknown";
   const tool = _lastToolName;
 
-  const startData: Record<string, any> = {
+  const startData: Record<string, unknown> = {
     lifecycle: "start",
     template,
     event,
@@ -520,7 +657,7 @@ export function runHookAsync(
       _emitHookEnd(hookName, startTime, exitCode, exitCode !== 0 ? "blocked" : "success", null, startData, event, tool, template);
       _drainAndExit(exitCode);
     })
-    .catch((error: any) => {
+    .catch((error: unknown) => {
       let exitCode = 0;
       let status = "error";
       let errorInfo: [Error, string] | null = null;
@@ -547,7 +684,7 @@ function _emitHookEnd(
   exitCode: number,
   status: string,
   errorInfo: [Error, string] | null,
-  startData: Record<string, any>,
+  startData: Record<string, unknown>,
   event: string,
   tool: string | null,
   template: string,
@@ -561,7 +698,7 @@ function _emitHookEnd(
   const durationMs = Math.round((performance.now() - startTime) * 10) / 10;
   const endEvent = _lastHookEvent ?? event;
   const endTool = _lastToolName ?? tool;
-  const endData: Record<string, any> = {
+  const endData: Record<string, unknown> = {
     lifecycle: "end",
     status,
     duration_ms: durationMs,
@@ -602,4 +739,5 @@ function _drainAndExit(code: number): void {
   });
 }
 
-export {hookLog, logBlocking, logDebug, logDiagnostic, logError, logHookError, logInfo, logWarn, setContextPath, setSessionId} from "./logger.js";
+export {hookLog, logBlocking, logDebug, logDiagnostic, logError, logHookError, logInfo, logWarn, setContextPath, setSessionId} from "../runtime/logger.js";
+

package/dist/templates/core/lib-ts/hooks/prompt-binding-logic.ts

@@ -0,0 +1,80 @@
+import { safeMaybeActivate, logInfo, logWarn } from "./hook-utils.js";
+import { buildContextInventory } from "../context/context-formatter.js";
+import { BlockRequest, determineContext } from "../context/context-selector.js";
+import {
+  bindSession,
+  getContextBySessionId,
+  saveState,
+} from "../context/context-store.js";
+import type { ContextState } from "../types.js";
+
+export interface PromptBindingResult {
+  outputs: string[];
+  blockedReason?: string;
+}
+
+export function shouldClearHandoff(state: ContextState): boolean {
+  return Boolean(state.handoff_path);
+}
+
+export async function executePromptBinding(
+  prompt: string | undefined,
+  sessionId: string,
+  permissionMode: string,
+  projectRoot: string,
+): Promise<PromptBindingResult> {
+  const outputs: string[] = [];
+  const existingCtx = getContextBySessionId(sessionId, projectRoot);
+
+  if (existingCtx) {
+    safeMaybeActivate(
+      existingCtx.id,
+      permissionMode,
+      projectRoot,
+      "user_prompt_submit",
+    );
+    return { outputs };
+  }
+
+  if (!prompt) return { outputs };
+
+  try {
+    const [contextId, method, outputText] = await determineContext(
+      prompt,
+      sessionId,
+      projectRoot,
+    );
+
+    if (contextId) {
+      bindSession(contextId, sessionId, projectRoot);
+      safeMaybeActivate(contextId, permissionMode, projectRoot, "user_prompt_submit");
+
+      const state = getContextBySessionId(sessionId, projectRoot);
+      if (state && shouldClearHandoff(state)) {
+        state.handoff_path = null;
+        saveState(state.id, state, projectRoot);
+      }
+
+      logInfo("user_prompt_submit", `Context ${contextId} via ${method}`);
+    }
+
+    if (outputText) outputs.push(outputText);
+
+    try {
+      const boundState = getContextBySessionId(sessionId, projectRoot);
+      if (boundState) {
+        const inventory = buildContextInventory(boundState, projectRoot);
+        if (inventory) outputs.push(inventory);
+      }
+    } catch (error) {
+      logWarn("user_prompt_submit", `Inventory failed (non-critical): ${error}`);
+    }
+  } catch (error) {
+    if (error instanceof BlockRequest) {
+      return { outputs, blockedReason: (error as Error).message };
+    }
+    throw error;
+  }
+
+  return { outputs };
+}

package/dist/templates/core/lib-ts/hooks/session-end-logic.ts

@@ -0,0 +1,82 @@
+import * as crypto from "node:crypto";
+
+import { determineArtifactType } from "../context/context-store.js";
+import {
+  extractPlanAnchors,
+  generatePlanId,
+  normalizePlanContent,
+} from "../context/plan-manager.js";
+import { nowIso } from "../runtime/utils.js";
+import type { ContextState, GitState, LastSession } from "../types.js";
+
+function formatArchiveTimestamp(date: Date): string {
+  return (
+    `${date.getFullYear()}-` +
+    `${String(date.getMonth() + 1).padStart(2, "0")}-` +
+    `${String(date.getDate()).padStart(2, "0")}-` +
+    `${String(date.getHours()).padStart(2, "0")}` +
+    `${String(date.getMinutes()).padStart(2, "0")}`
+  );
+}
+
+export function computePlanFallback(
+  state: ContextState,
+  planContent: string,
+): Partial<ContextState> {
+  const normalized = normalizePlanContent(planContent);
+  const planHash = crypto
+    .createHash("sha256")
+    .update(normalized, "utf8")
+    .digest("hex")
+    .slice(0, 12);
+
+  return {
+    plan_hash: planHash,
+    plan_signature: planContent.slice(0, 200),
+    plan_id: generatePlanId(),
+    plan_anchors: extractPlanAnchors(planContent),
+    work_consumed: state.work_consumed ?? false,
+  };
+}
+
+export function shouldStage(
+  state: ContextState,
+  permissionMode: string,
+): boolean {
+  const artifactType = determineArtifactType(state);
+  const canStage = state.mode === "active" || permissionMode === "plan";
+  return Boolean(artifactType && canStage && !state.work_consumed);
+}
+
+export function buildSessionMetadata(
+  sessionId: string,
+  source: string,
+  transcriptPath: string | undefined,
+  gitState?: GitState,
+): LastSession {
+  return {
+    session_id: sessionId,
+    save_reason: source,
+    saved_at: nowIso(),
+    ...(transcriptPath ? { transcript_path: transcriptPath } : {}),
+    git_state: gitState ?? {},
+  };
+}
+
+export function generateArchiveFilename(
+  sessionId: string,
+  date: Date,
+  existingNames: Iterable<string>,
+): string {
+  const existing = new Set(existingNames);
+  const timestamp = formatArchiveTimestamp(date);
+
+  let archiveName = `${timestamp}-${sessionId}.jsonl`;
+  let counter = 2;
+  while (existing.has(archiveName)) {
+    archiveName = `${timestamp}-${sessionId}-${counter}.jsonl`;
+    counter += 1;
+  }
+
+  return archiveName;
+}

package/dist/templates/core/lib-ts/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "lib-ts-tests",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "vitest run",
+    "test:unit": "vitest run '__tests__/runtime/**/*.test.ts' '__tests__/templates/**/*.test.ts'",
+    "test:contract": "vitest run '__tests__/context/**/*.test.ts' '__tests__/handoff/**/*.test.ts'",
+    "test:integration": "vitest run '__tests__/integration/**/*.test.ts'",
+    "test:parity": "vitest run '__tests__/integration/python-parity.test.ts'"
+  },
+  "devDependencies": {
+    "chai": "^5.0.0",
+    "@types/sinon": "^17.0.0",
+    "sinon": "^17.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.2.4"
+  }
+}