aiwcli 0.12.0 → 0.12.2

package/dist/lib/template-installer.js

@@ -75,14 +75,14 @@ export async function checkTemplateStatus(templatePath, targetDir, ides, templat
  * Patterns to exclude when copying template directories.
  * These are development/test artifacts that shouldn't be packaged.
  */
-const EXCLUDED_PATTERNS = [
+const EXCLUDED_PATTERNS = new Set([
     '_output',
-];
+]);
 /**
  * Check if a filename should be excluded from copying
  */
 export function shouldExclude(name) {
-    return EXCLUDED_PATTERNS.includes(name);
+    return EXCLUDED_PATTERNS.has(name);
 }
 /**
  * Copy directory recursively with proper error handling.

package/dist/lib/version.js

@@ -37,7 +37,7 @@ const MIN_CLAUDE_CODE_VERSION = '0.1.0';
  * Known incompatible Claude Code versions.
  * These versions have confirmed issues with AI Workflow CLI.
  */
-const INCOMPATIBLE_VERSIONS = ['0.0.9'];
+const INCOMPATIBLE_VERSIONS = new Set(['0.0.9']);
 /**
  * Detects Claude Code version by executing `claude --version`.
  *
@@ -109,7 +109,7 @@ export function checkVersionCompatibility(version) {
         };
     }
     // Check known incompatible versions first
-    if (INCOMPATIBLE_VERSIONS.includes(version)) {
+    if (INCOMPATIBLE_VERSIONS.has(version)) {
         return {
             compatible: false,
             version,

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

@@ -5,18 +5,70 @@
  */
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
+import * as path from "node:path";
 
-import { getProjectRoot } from "../lib-ts/base/constants.js";
+import { getProjectRoot, getContextDir } 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,
+  loadHookInput, runHook, logDebug, logInfo, logWarn, logError, logDiagnostic,
 } 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,
+  findLatestPlan, normalizePlanContent, generatePlanId, extractPlanAnchors,
 } from "../lib-ts/context/plan-manager.js";
 
+/**
+ * Archive session transcript to context's session-transcripts/ folder.
+ * Returns archived path on success, null if skipped or failed.
+ */
+function archiveTranscript(
+  transcriptPath: string,
+  contextId: string,
+  sessionId: string,
+  projectRoot: string,
+): string | null {
+  // 1. Validate inputs
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+    logDebug("session_end", `Transcript not found: ${transcriptPath}`);
+    return null;
+  }
+
+  // 2. Ensure session-transcripts directory exists
+  const contextDir = getContextDir(contextId, projectRoot);
+  const transcriptsDir = path.join(contextDir, "session-transcripts");
+  fs.mkdirSync(transcriptsDir, { recursive: true });
+
+  // 3. Generate archive filename: YYYY-MM-DD-HHMM-{session_id}.jsonl
+  const now = new Date();
+  // Format: 2026-02-14-1400 (year-month-day-hourminute)
+  // Note: Hours and minutes are concatenated without separator (HHMM)
+  const timestamp =
+    `${now.getFullYear()}-` +
+    `${String(now.getMonth() + 1).padStart(2, "0")}-` +
+    `${String(now.getDate()).padStart(2, "0")}-` +
+    `${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}`;
+
+  // 4. Handle collisions (rare, but possible with rapid session churn)
+  let archiveName = `${timestamp}-${sessionId}.jsonl`;
+  let archivePath = path.join(transcriptsDir, archiveName);
+  let counter = 2;
+  while (fs.existsSync(archivePath)) {
+    archiveName = `${timestamp}-${sessionId}-${counter}.jsonl`;
+    archivePath = path.join(transcriptsDir, archiveName);
+    counter++;
+  }
+
+  // 5. Copy transcript file
+  try {
+    fs.copyFileSync(transcriptPath, archivePath);
+    return archivePath;
+  } catch (error) {
+    logError("session_end", `Failed to copy transcript: ${error}`);
+    return null;
+  }
+}
+
 function main(): void {
   const payload = loadHookInput();
   if (!payload) return;
@@ -50,6 +102,25 @@ function main(): void {
   };
   state.last_active = nowIso();
 
+  // Archive transcript (NEW)
+  // Note: state is a ContextState object (from getContextBySessionId on line 33)
+  // state.id is the context ID used to construct paths like _output/contexts/{context_id}/
+  if (payload.transcript_path) {
+    try {
+      const archived = archiveTranscript(
+        payload.transcript_path,
+        state.id,  // Context ID, verified by existing code on line 98: saveState(state.id, ...)
+        sessionId,
+        projectRoot,
+      );
+      if (archived) {
+        logInfo("session_end", `Archived transcript: ${path.basename(archived)}`);
+      }
+    } catch (error) {
+      logError("session_end", `Transcript archival failed: ${error}`);
+    }
+  }
+
   // Plan fallback assignment (skip in plan mode — rejected plans shouldn't stage)
   if (permissionMode !== "plan") {
     // Step 1: Assign plan fields if missing
@@ -57,7 +128,7 @@ function main(): void {
       const latestPlanPath = findLatestPlan(state.id, projectRoot);
       if (latestPlanPath) {
         try {
-          const content = fs.readFileSync(latestPlanPath, "utf8");
+          const content = fs.readFileSync(latestPlanPath, "utf-8");
           const normalized = normalizePlanContent(content);
           const planHash = crypto.createHash("sha256")
             .update(normalized, "utf-8")

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

@@ -13,6 +13,7 @@ import {
 } from "../lib-ts/context/context-store.js";
 import {
   buildRestoreSections, formatHandoffContinuation, getModeDisplay,
+  buildContextInventory,
 } from "../lib-ts/context/context-formatter.js";
 import type { ContextState } from "../lib-ts/types.js";
 
@@ -39,6 +40,9 @@ function handleCompactRestore(sessionId: string, projectRoot: string): void {
   const restore = buildRestoreSections(state, projectRoot, true);
   if (restore) sections.push(restore);
 
+  const inventory = buildContextInventory(state, projectRoot);
+  if (inventory) sections.push("", inventory);
+
   sections.push(
     "",
     "---",
@@ -79,6 +83,9 @@ async function handleClearRestore(sessionId: string, projectRoot: string): Promi
     const restore = buildRestoreSections(ctx, projectRoot, false);
     if (restore) sections.push(restore);
 
+    const inventory = buildContextInventory(ctx, projectRoot);
+    if (inventory) sections.push("", inventory);
+
     sections.push(
       "",
       "---",
@@ -100,7 +107,9 @@ async function handleClearRestore(sessionId: string, projectRoot: string): Promi
     logInfo("session_start", `Clear restore: ${ctx.id} has_handoff → active (handoff_consumed=true)`);
 
     const handoffContent = formatHandoffContinuation(ctx, projectRoot);
-    emitContext(handoffContent);
+    const handoffInventory = buildContextInventory(ctx, projectRoot);
+    const combined = handoffInventory ? handoffContent + "\n\n" + handoffInventory : handoffContent;
+    emitContext(combined);
     return;
   }
 

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

@@ -14,6 +14,7 @@ import {
   getContextBySessionId, bindSession, maybeActivate, saveState,
 } from "../lib-ts/context/context-store.js";
 import { determineContext, BlockRequest } from "../lib-ts/context/context-selector.js";
+import { buildContextInventory } from "../lib-ts/context/context-formatter.js";
 
 async function asyncMain(): Promise<void> {
   const payload = loadHookInput();
@@ -64,6 +65,17 @@ async function asyncMain(): Promise<void> {
       if (outputText) {
         outputs.push(outputText);
       }
+
+      // Append context folder inventory
+      try {
+        const boundState = getContextBySessionId(sessionId, projectRoot);
+        if (boundState) {
+          const inventory = buildContextInventory(boundState, projectRoot);
+          if (inventory) outputs.push(inventory);
+        }
+      } catch (e) {
+        logWarn("user_prompt_submit", `Inventory failed (non-critical): ${e}`);
+      }
     } catch (e) {
       if (e instanceof BlockRequest) {
         emitBlock((e as Error).message);

package/dist/templates/_shared/lib-ts/base/hook-utils.ts

@@ -4,14 +4,15 @@
  * See SPEC.md §5
  */
 
-import * as fs from "node:fs";
-import { logDebug, logInfo, logWarn, logError, logBlocking, logHookError, logDiagnostic, hookLog, setSessionId, setContextPath, getContextPath as _getContextPath } from "./logger.js";
+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";
 
 // Re-export logger functions for convenience (matches Python hook_utils re-exports)
-export { logDebug, logInfo, logWarn, logError, logBlocking, logHookError, logDiagnostic, hookLog, setSessionId, setContextPath };
+export {          setSessionId };
 
 // Context window baseline: tokens not visible in hook data §5.9
 export const CONTEXT_BASELINE_TOKENS = 22_600;
@@ -93,7 +94,7 @@ export function checkSkipPersistence(
   const toolInput = getToolInput(payload);
   if (!toolInput) return false;
 
-  const metadata = toolInput.metadata;
+  const {metadata} = toolInput;
   if (metadata && typeof metadata === "object" && metadata.skip_persistence) {
     logDebug(hookName, "Skipping persistence (skip_persistence flag set)");
     return true;
@@ -105,11 +106,23 @@ export function checkSkipPersistence(
  * Emit hookSpecificOutput with additionalContext to stdout.
  * hookEventName is required by Claude Code's Zod validator (discriminated union).
  * Auto-detected from stdin payload (set by loadHookInput/runHook).
+ *
+ * SubagentStop and Stop events use top-level systemMessage field instead of hookSpecificOutput.
  * See SPEC.md §5.5
  */
 export function emitContext(additionalContext: string): void {
   const eventName = _lastHookEvent ?? undefined;
   const tool = _lastToolName;
+
+  // SubagentStop and Stop use top-level systemMessage field
+  if (eventName === "SubagentStop" || eventName === "Stop") {
+    const out = { systemMessage: additionalContext };
+    process.stdout.write(JSON.stringify(out) + "\n");
+    _logEmit("systemMessage", additionalContext.length, { event: eventName ?? "unknown", systemMessage: additionalContext });
+    return;
+  }
+
+  // All other events use hookSpecificOutput
   const out: HookOutput = {
     hookSpecificOutput: {
       ...(eventName ? { hookEventName: eventName } : {}),
@@ -153,8 +166,8 @@ export function emitContextAndBlock(
   process.stdout.write(json + "\n");
 }
 
-/** Log hook output (context or block) to hook-log.jsonl for visibility. */
-function _logEmit(type: "context" | "block", chars: number, payload: Record<string, any>): void {
+/** 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 {
   const hook = _cachedHookName ?? "unknown";
   const event = payload.event ?? "unknown";
   const mechanism = payload.mechanism ? ` via ${payload.mechanism}` : "";
@@ -268,27 +281,28 @@ export function emitPermissionDecision(
 export function emitBlock(reason: string, context?: string): void {
   const event = _lastHookEvent;
   switch (event) {
-    case "PreToolUse":
-      emitContextAndBlock(context ?? reason, reason);
-      break;
-    case "UserPromptSubmit":
-      emitBlockPrompt(reason, context);
+    case "PermissionRequest":
+      emitPermissionDecision("deny", { message: reason });
       break;
     case "PostToolUse":
     case "PostToolUseFailure":
       emitBlockViaExit(reason, context);
       break;
+    case "PreToolUse":
+      emitContextAndBlock(context ?? reason, reason);
+      break;
     case "Stop":
     case "SubagentStop":
       emitBlockTopLevel(reason);
       break;
-    case "PermissionRequest":
-      emitPermissionDecision("deny", { message: reason });
+    case "UserPromptSubmit":
+      emitBlockPrompt(reason, context);
       break;
-    default:
+    default: {
       logWarn(_cachedHookName ?? "unknown",
         `emitBlock() called from ${event ?? "unknown"} — no blocking mechanism exists for this event type, ignoring`);
-      break;
+      break;
+    }
   }
 }
 
@@ -296,7 +310,7 @@ export function emitBlock(reason: string, context?: string): void {
  * Auto-detect template origin from the hook script path.
  */
 function detectTemplate(scriptPath = ""): string {
-  const p = (scriptPath || (process.argv[1] ?? "")).replace(/\\/g, "/");
+  const p = (scriptPath || (process.argv[1] ?? "")).replaceAll('\\', "/");
   if (p.includes("/_shared/hooks/") || p.startsWith("_shared/hooks/")) {
     return "shared";
   }
@@ -438,16 +452,16 @@ export function runHook(
     const result = mainFunc();
     exitCode = typeof result === "number" ? result : 0;
     status = exitCode !== 0 ? "blocked" : "success";
-  } catch (e: any) {
-    if (e instanceof Error && e.message.startsWith("SystemExit:")) {
-      const code = parseInt(e.message.slice(11), 10);
-      exitCode = isNaN(code) ? (e.message.slice(11) ? 1 : 0) : code;
+  } catch (error: any) {
+    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;
       status = exitCode !== 0 ? "blocked" : "success";
     } else {
       exitCode = 0; // Non-blocking
       status = "error";
-      const stack = e instanceof Error ? e.stack ?? "" : "";
-      errorInfo = [e instanceof Error ? e : new Error(String(e)), stack];
+      const stack = error instanceof Error ? error.stack ?? "" : "";
+      errorInfo = [error instanceof Error ? error : new Error(String(error)), stack];
     }
   }
 
@@ -487,19 +501,19 @@ export function runHookAsync(
       _emitHookEnd(hookName, startTime, exitCode, exitCode !== 0 ? "blocked" : "success", null, startData, event, tool, template);
       _drainAndExit(exitCode);
     })
-    .catch((e: any) => {
+    .catch((error: any) => {
       let exitCode = 0;
       let status = "error";
       let errorInfo: [Error, string] | null = null;
 
-      if (e instanceof Error && e.message.startsWith("SystemExit:")) {
-        const code = parseInt(e.message.slice(11), 10);
-        exitCode = isNaN(code) ? (e.message.slice(11) ? 1 : 0) : code;
+      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;
         status = exitCode !== 0 ? "blocked" : "success";
       } else {
         exitCode = 0; // Non-blocking (fail open)
-        const stack = e instanceof Error ? e.stack ?? "" : "";
-        errorInfo = [e instanceof Error ? e : new Error(String(e)), stack];
+        const stack = error instanceof Error ? error.stack ?? "" : "";
+        errorInfo = [error instanceof Error ? error : new Error(String(error)), stack];
       }
 
       _emitHookEnd(hookName, startTime, exitCode, status, errorInfo, startData, event, tool, template);
@@ -541,7 +555,7 @@ function _emitHookEnd(
   if (errorInfo) {
     const [err, tb] = errorInfo;
     endData.error_type = err.constructor.name;
-    hookLog("error", hookName, `[${endEvent}] ${err.constructor.name}: ${String(err).replace(/[\n\r]/g, " ").slice(0, 200)}`, { traceback_str: tb });
+    hookLog("error", hookName, `[${endEvent}] ${err.constructor.name}: ${String(err).replaceAll(/[\n\r]/g, " ").slice(0, 200)}`, { traceback_str: tb });
     hookLog("error", hookName, `HOOK_END: ${err}`, { data: endData, traceback_str: tb });
   } else if (status === "blocked") {
     hookLog("warn", hookName, "HOOK_END", { data: endData });
@@ -568,3 +582,5 @@ function _drainAndExit(code: number): void {
     process.exit(code);
   });
 }
+
+export {logInfo, logError, logBlocking, logHookError, logDiagnostic, setContextPath, hookLog, logDebug, logWarn} from "./logger.js";

package/dist/templates/_shared/lib-ts/base/logger.ts

@@ -235,7 +235,7 @@ export function logHookError(
   tracebackStr = "",
 ): void {
   const errStr = typeof error === "string" ? error : String(error);
-  const msg = errStr.replace(/[\n\r]/g, " ").slice(0, 200);
+  const msg = errStr.replaceAll(/[\n\r]/g, " ").slice(0, 200);
   const errType =
     typeof error === "object" && error !== null
       ? error.constructor.name

package/dist/templates/_shared/lib-ts/base/subprocess-utils.ts

@@ -92,7 +92,7 @@ export function isExecSyncError(e: unknown): e is ExecSyncError {
  */
 export function shellQuoteWin(arg: string): string {
   if (process.platform !== "win32") return arg;
-  return '"' + arg.replace(/"/g, '""') + '"';
+  return '"' + arg.replaceAll('"', '""') + '"';
 }
 
 // ---------------------------------------------------------------------------