aiwcli 0.15.5 → 0.17.0

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

@@ -0,0 +1,233 @@
+/**
+ * Zod schemas mirroring types.ts for runtime validation at JSON.parse boundaries.
+ * All object schemas use .passthrough() to preserve method-specific extension fields.
+ * See types.ts for corresponding TypeScript interfaces.
+ */
+
+import { z } from "zod";
+
+// §1.1
+export const ModeSchema = z.enum(["active", "has_staged_work", "idle"]);
+
+// §1.2
+export const GitStateSchema = z
+  .object({
+    branch: z.string().optional(),
+    last_commit_short: z.string().optional(),
+    uncommitted_files: z.array(z.string()).optional(),
+  })
+  .passthrough();
+
+export const LastSessionSchema = z
+  .object({
+    context_remaining_pct: z.number().optional(),
+    context_warnings_fired: z.array(z.number()).optional(),
+    git_state: GitStateSchema.optional(),
+    save_reason: z.string().optional(),
+    saved_at: z.string().optional(),
+    session_id: z.string().optional(),
+    transcript_path: z.string().optional(),
+  })
+  .passthrough();
+
+// §1.3
+export const TaskSchema = z
+  .object({
+    active_form: z.string(),
+    completed_at: z.string().nullable(),
+    created_at: z.string(),
+    description: z.string(),
+    evidence: z.string(),
+    files_changed: z.array(z.string()),
+    id: z.string(),
+    session_id: z.string().optional(),
+    status: z.enum(["blocked", "completed", "in_progress", "pending"]),
+    subject: z.string(),
+    work_summary: z.string(),
+  })
+  .passthrough();
+
+// §1.1 (continued)
+export const ContextStateSchema = z
+  .object({
+    created_at: z.string(),
+    handoff_consumed: z.boolean().optional(), // deprecated
+    handoff_path: z.string().nullable().optional(),
+    id: z.string(),
+    last_active: z.string(),
+    last_session: LastSessionSchema.nullable().optional(),
+    method: z.string(),
+    mode: ModeSchema,
+    next_artifact_type: z.enum(["handoff", "plan"]).nullable().optional(),
+    plan_anchors: z.array(z.string()).optional(),
+    plan_consumed: z.boolean().optional(), // deprecated
+    plan_hash: z.string().nullable().optional(),
+    plan_hash_consumed: z.string().nullable().optional(),
+    plan_id: z.string().nullable().optional(),
+    plan_path: z.string().nullable().optional(),
+    plan_signature: z.string().nullable().optional(),
+    session_ids: z.array(z.string()).optional(),
+    status: z.enum(["active", "completed"]),
+    summary: z.string(),
+    tags: z.array(z.string()).optional(),
+    tasks: z.array(TaskSchema).optional(),
+    work_consumed: z.boolean().optional(),
+  })
+  .passthrough();
+
+// §1.4
+export const IndexEntrySchema = z
+  .object({
+    last_active: z.string(),
+    mode: z.string(),
+    summary: z.string(),
+  })
+  .passthrough();
+
+export const IndexFileSchema = z
+  .object({
+    contexts: z.record(z.string(), IndexEntrySchema),
+    sessions: z.record(z.string(), z.string()),
+    updated_at: z.string(),
+    version: z.literal("3.0"),
+  })
+  .passthrough();
+
+// §1.5
+export const LogEntrySchema = z
+  .object({
+    component: z.string().optional(),
+    data: z.unknown().optional(),
+    hook: z.string(),
+    level: z.enum(["debug", "error", "info", "warn"]),
+    msg: z.string(),
+    tb: z.string().optional(),
+    ts: z.string(),
+  })
+  .passthrough();
+
+// §1.6
+export const HookInputSchema = z
+  .object({
+    context_window: z
+      .object({
+        context_window_size: z.number().optional(),
+        current_usage: z
+          .object({
+            cache_creation_input_tokens: z.number().optional(),
+            cache_read_input_tokens: z.number().optional(),
+            input_tokens: z.number().optional(),
+            output_tokens: z.number().optional(),
+          })
+          .passthrough()
+          .optional(),
+      })
+      .passthrough()
+      .optional(),
+    cwd: z.string().optional(),
+    hook_event_name: z.string(),
+    permission_mode: z.string().optional(),
+    session_id: z.string().optional(),
+    source: z.string().optional(),
+    tool_input: z.record(z.string(), z.unknown()).optional(),
+    tool_name: z.string().optional(),
+    tool_result: z.string().optional(),
+    transcript_path: z.string().optional(),
+  })
+  .passthrough();
+
+// §1.7
+export const HookOutputSchema = z
+  .object({
+    decision: z.literal("block").optional(),
+    hookSpecificOutput: z
+      .object({
+        additionalContext: z.string().optional(),
+        hookEventName: z.string().optional(),
+        permissionDecision: z.enum(["allow", "ask", "deny"]).optional(),
+        permissionDecisionReason: z.string().optional(),
+        updatedInput: z.record(z.string(), z.unknown()).optional(),
+      })
+      .passthrough()
+      .optional(),
+    reason: z.string().optional(),
+  })
+  .passthrough();
+
+// §1.7b
+export const PermissionRequestOutputSchema = z
+  .object({
+    decision: z.object({
+      behavior: z.enum(["allow", "deny"]),
+      message: z.string().optional(),
+      updatedInput: z.record(z.string(), z.unknown()).optional(),
+      updatedPermissions: z.record(z.string(), z.unknown()).optional(),
+    }),
+  })
+  .passthrough();
+
+// §1.8
+export const InferenceResultSchema = z
+  .object({
+    error: z.string().optional(),
+    latency_ms: z.number(),
+    output: z.string(),
+    success: z.boolean(),
+  })
+  .passthrough();
+
+// §1.9
+export const HandoffDocumentSchema = z
+  .object({
+    active_tasks: z.array(TaskSchema),
+    completed_tasks_this_session: z.array(z.object({ subject: z.string() }).passthrough()),
+    context_folder: z.string(),
+    context_id: z.string(),
+    context_summary: z.string(),
+    created_at: z.string(),
+    events_log_path: z.string(),
+    file_path: z.string().nullable(),
+    important_notes: z.array(z.string()),
+    next_steps: z.array(z.string()),
+    plan_path: z.string().nullable(),
+    reason: z.string(),
+    session_id: z.string(),
+    work_summary: z.string(),
+  })
+  .passthrough();
+
+// §1.10
+export const HandoffSectionsSchema = z
+  .object({
+    completedWork: z.string().nullable(),
+    context: z.string().nullable(),
+    deadEnds: z.string().nullable(),
+    decisions: z.string().nullable(),
+    index: z.string().nullable(),
+    pending: z.string().nullable(),
+    plan: z.string().nullable(),
+  })
+  .passthrough();
+
+// §1.11
+export const CaretCommandSchema = z
+  .object({
+    ends: z.array(z.string()),
+    new_context_desc: z.string().nullable(),
+    remaining_prompt: z.string(),
+    select: z.string().nullable(),
+  })
+  .passthrough();
+
+// §1.13
+export const AgentConfigSchema = z
+  .object({
+    categories: z.array(z.string()),
+    description: z.string(),
+    focus: z.string(),
+    model: z.string(),
+    name: z.string(),
+    provider: z.string(),
+    system_prompt: z.string(),
+  })
+  .passthrough();

package/dist/templates/{_shared → core}/lib-ts/templates/formatters.ts

@@ -32,13 +32,14 @@ export function getStatusIcon(status: string): string {
 
 // §13.3 — Task rendering
 export function renderTaskItem(
-  task: Record<string, any> | Task,
+  task: Record<string, unknown> | Task,
   showDescription = true,
   maxDescriptionLength = 100,
 ): string {
-  const status = (task as any).status ?? "pending";
-  const subject = (task as any).subject ?? "";
-  const description = (task as any).description ?? "";
+  const taskData = task as Partial<Task> & Record<string, unknown>;
+  const status = typeof taskData.status === "string" ? taskData.status : "pending";
+  const subject = typeof taskData.subject === "string" ? taskData.subject : "";
+  const description = typeof taskData.description === "string" ? taskData.description : "";
 
   const icon = getStatusIcon(status);
   const statusText = `[${status.toUpperCase()}]`;
@@ -57,7 +58,7 @@ export function renderTaskItem(
 }
 
 export function renderTaskList(
-  tasks: Array<Record<string, any> | Task>,
+  tasks: Array<Record<string, unknown> | Task>,
   header = "Active Tasks",
   showDescription = true,
 ): string {
@@ -102,3 +103,4 @@ export const REASON_MAP: Record<string, string> = {
 export function formatReason(reason: string): string {
   return REASON_MAP[reason] ?? reason;
 }
+

package/dist/templates/{_shared → core}/lib-ts/templates/plan-context.ts

@@ -29,7 +29,7 @@ What exactly to build or change
 - \`exact/path/to/reference.ext\` — Why relevant (e.g., "pattern to follow at lines 12-30")
 
 ## Steps
-Numbered steps with specific details. For each step, consider whether any of the skills available in your system-reminder messages would help the implementation agent — if so, reference the skill inline at the point of use.
+Numbered steps with specific details. For each step, consider whether unknown of the skills available in your system-reminder messages would help the implementation agent — if so, reference the skill inline at the point of use.
 
 1. [Specific action with function names, patterns, or code snippets]
 2. [Enough detail for someone who never saw this conversation]
@@ -56,3 +56,4 @@ The implementation agent should document these so the next session inherits what
 - [ ] Are relevant skills referenced where they add value?
 - [ ] Are key decisions captured so they survive this session?`;
 }
+

package/dist/templates/{_shared → core}/lib-ts/tsconfig.json

@@ -7,7 +7,9 @@
     "noUncheckedIndexedAccess": true,
     "outDir": "dist",
     "rootDir": ".",
-    "declaration": true
+    "declaration": true,
+    "types": ["node", "bun-types"],
+    "skipLibCheck": true
   },
   "include": ["./**/*.ts"]
 }

package/dist/templates/{_shared → core}/lib-ts/types.ts

@@ -5,128 +5,128 @@
  */
 
 // §1.1
-export type Mode = "idle" | "has_staged_work" | "active";
+export type Mode = "active" | "has_staged_work" | "idle";
 
 export interface ContextState {
-  id: string;
-  status: "active" | "completed";
-  summary: string;
-  method: string;
-  tags: string[];
   created_at: string;
+  /** @deprecated Use work_consumed instead */
+  handoff_consumed?: boolean;
+  handoff_path: null | string;
+  id: string;
   last_active: string;
+  last_session: LastSession | null;
+  method: string;
   mode: Mode;
-  plan_path: string | null;
-  plan_hash: string | null;
-  plan_signature: string | null;
-  plan_id: string | null;
+  next_artifact_type: "handoff" | "plan" | null;  // Explicit artifact type for has_staged_work mode
   plan_anchors: string[];
-  plan_hash_consumed: string | null;
-  handoff_path: string | null;
-  // Unified lifecycle fields (v0.13.0+)
-  work_consumed: boolean;  // Replaces plan_consumed + handoff_consumed
-  next_artifact_type: "plan" | "handoff" | null;  // Explicit artifact type for has_staged_work mode
   // Deprecated fields (kept for migration)
   /** @deprecated Use work_consumed instead */
   plan_consumed?: boolean;
-  /** @deprecated Use work_consumed instead */
-  handoff_consumed?: boolean;
+  plan_hash: null | string;
+  plan_hash_consumed: null | string;
+  plan_id: null | string;
+  plan_path: null | string;
+  plan_signature: null | string;
   session_ids: string[];
-  last_session: LastSession | null;
+  status: "active" | "completed";
+  summary: string;
+  tags: string[];
   tasks: Task[];
+  // Unified lifecycle fields (v0.13.0+)
+  work_consumed: boolean;  // Replaces plan_consumed + handoff_consumed
 }
 
 // §1.2
 export interface GitState {
   branch?: string;
-  uncommitted_files?: string[];
   last_commit_short?: string;
+  uncommitted_files?: string[];
 }
 
 export interface LastSession {
-  session_id?: string;
-  saved_at?: string;
-  save_reason?: string;
-  transcript_path?: string;
   context_remaining_pct?: number;
   context_warnings_fired?: number[];
   git_state?: GitState;
+  save_reason?: string;
+  saved_at?: string;
+  session_id?: string;
+  transcript_path?: string;
 }
 
 // §1.3
 export interface Task {
-  id: string;
-  subject: string;
-  description: string;
   active_form: string;
-  status: "pending" | "in_progress" | "completed" | "blocked";
+  completed_at: null | string;
   created_at: string;
-  completed_at: string | null;
+  description: string;
   evidence: string;
-  work_summary: string;
   files_changed: string[];
+  id: string;
   session_id?: string;
+  status: "blocked" | "completed" | "in_progress" | "pending";
+  subject: string;
+  work_summary: string;
 }
 
 // §1.4
 export interface IndexEntry {
-  summary: string;
-  mode: string;
   last_active: string;
+  mode: string;
+  summary: string;
 }
 
 export interface IndexFile {
-  version: "3.0";
-  updated_at: string;
-  sessions: Record<string, string>;
   contexts: Record<string, IndexEntry>;
+  sessions: Record<string, string>;
+  updated_at: string;
+  version: "3.0";
 }
 
 // §1.5
 export interface LogEntry {
-  ts: string;
-  level: "debug" | "info" | "warn" | "error";
+  component?: string;
+  data?: unknown;
   hook: string;
+  level: "debug" | "error" | "info" | "warn";
   msg: string;
-  component?: string;
-  data?: any;
   tb?: string;
+  ts: string;
 }
 
 // §1.6
 export interface HookInput {
-  hook_event_name: string;
-  tool_name?: string;
-  tool_input?: Record<string, any>;
-  tool_result?: string;
-  session_id?: string;
-  cwd?: string;
-  transcript_path?: string;
   context_window?: {
+    context_window_size?: number;
     current_usage?: {
+      cache_creation_input_tokens?: number;
       cache_read_input_tokens?: number;
       input_tokens?: number;
-      cache_creation_input_tokens?: number;
       output_tokens?: number;
     };
-    context_window_size?: number;
   };
+  cwd?: string;
+  hook_event_name: string;
   permission_mode?: string;
+  session_id?: string;
   source?: string;
+  tool_input?: Record<string, unknown>;
+  tool_name?: string;
+  tool_result?: string;
+  transcript_path?: string;
 }
 
 // §1.7 — Three hook output patterns (see hook-utils.ts for emit functions)
 export interface HookOutput {
+  // Pattern 2: Top-level decision (UserPromptSubmit, Stop, SubagentStop)
+  decision?: "block";
   // Pattern 1: hookSpecificOutput (PreToolUse, PostToolUse, UserPromptSubmit, etc.)
   hookSpecificOutput?: {
-    hookEventName?: string;
     additionalContext?: string;
-    permissionDecision?: "allow" | "deny" | "ask";
+    hookEventName?: string;
+    permissionDecision?: "allow" | "ask" | "deny";
     permissionDecisionReason?: string;
     updatedInput?: Record<string, unknown>;
   };
-  // Pattern 2: Top-level decision (UserPromptSubmit, Stop, SubagentStop)
-  decision?: "block";
   reason?: string;
 }
 
@@ -142,62 +142,63 @@ export interface PermissionRequestOutput {
 
 // §1.8
 export interface InferenceResult {
-  success: boolean;
-  output: string;
   error?: string;
   latency_ms: number;
+  output: string;
+  success: boolean;
 }
 
 // §1.9
 export interface HandoffDocument {
+  active_tasks: Task[];
+  completed_tasks_this_session: Array<{ subject: string }>;
+  context_folder: string;
   context_id: string;
   context_summary: string;
-  session_id: string;
-  reason: string;
   created_at: string;
-  plan_path: string | null;
-  context_folder: string;
   events_log_path: string;
-  active_tasks: Task[];
-  completed_tasks_this_session: Array<{ subject: string }>;
-  work_summary: string;
-  next_steps: string[];
+  file_path: null | string;
   important_notes: string[];
-  file_path: string | null;
+  next_steps: string[];
+  plan_path: null | string;
+  reason: string;
+  session_id: string;
+  work_summary: string;
 }
 
 // §1.10
 export interface HandoffSections {
-  index: string | null;
-  deadEnds: string | null;
-  pending: string | null;
-  plan: string | null;
-  decisions: string | null;
-  completedWork: string | null;
-  context: string | null;
+  completedWork: null | string;
+  context: null | string;
+  deadEnds: null | string;
+  decisions: null | string;
+  index: null | string;
+  pending: null | string;
+  plan: null | string;
 }
 
 // §1.11
 export interface CaretCommand {
   ends: string[];
-  select: string | null;
-  new_context_desc: string | null;
+  new_context_desc: null | string;
   remaining_prompt: string;
+  select: null | string;
 }
 
 // §1.12 — Preflight types (shared across hooks)
-// Re-exported from base/preflight.ts for convenience
-export type { PreflightCommandConfig, PreflightCheckResult } from "./base/preflight.js";
+// Re-exported from runtime/preflight.ts for convenience
+export type { PreflightCheckResult, PreflightCommandConfig } from "./runtime/preflight.js";
 
 // §1.13 — Agent configuration (shared across templates)
 
 /** Configuration for a CLI review agent */
 export interface AgentConfig {
-  name: string;
-  model: string;
-  provider: string; // e.g. "claude" | "codex" — assigned at runtime by assignModelsToAgents()
-  focus: string;
   categories: string[];
   description: string;
+  focus: string;
+  model: string;
+  name: string;
+  provider: string; // e.g. "claude" | "codex" — assigned at runtime by assignModelsToAgents()
   system_prompt: string; // Markdown body content for --system-prompt
 }
+

package/dist/templates/core/scripts/resolve-run.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env bun
+/**
+ * Cross-platform project root resolver for hook and status line commands.
+ *
+ * Finds the project root, sets cwd, then dynamically imports the target script
+ * in-process (no second bun spawn). stdin/stdout/stderr pass through naturally.
+ *
+ * Root detection strategy (fastest first):
+ *   1. Derive from this script's own location (O(1) — no I/O)
+ *   2. git rev-parse --show-toplevel (works from any subdirectory)
+ *   3. Walk up from cwd to find .aiwcli/ anchor (O(depth) — a few stat calls)
+ *
+ * Strategy 2 is critical when this script is installed globally at ~/.aiwcli/bin/
+ * (strategy 1 fails) and the cwd is a subdirectory that has its own .aiwcli/
+ * (strategy 3 finds the wrong root).
+ *
+ * Usage:    bun .aiwcli/_core/scripts/resolve-run.ts .aiwcli/_core/hooks-ts/hook.ts
+ */
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Convert MSYS2/Git-Bash POSIX path to native Windows path.
+ * /c/Users/foo → C:/Users/foo
+ */
+function fromMsysPosixPath(p: string): string {
+  if (process.platform !== "win32") return p;
+  const m = p.match(/^\/([a-zA-Z])\/(.*)/);
+  return m ? `${m[1]!.toUpperCase()}:/${m[2]!}` : p;
+}
+
+function findProjectRoot(): string {
+  // 1. Derive from script location: .aiwcli/_core/scripts/resolve-run.ts → 3 levels up
+  const derived = path.resolve(import.meta.dir, "..", "..", "..");
+  if (fs.existsSync(path.join(derived, ".aiwcli"))) return derived;
+
+  // 2. git rev-parse (works from any subdirectory, even when cwd has its own .aiwcli/)
+  try {
+    let root = execSync("git rev-parse --show-toplevel", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 2000,
+    }).trim();
+    root = fromMsysPosixPath(root);
+    if (root && fs.existsSync(path.join(root, ".aiwcli"))) return root;
+  } catch { /* not a git repo or git not available */ }
+
+  // 3. Walk up from cwd to find .aiwcli/ anchor
+  let dir = process.cwd();
+  while (true) {
+    if (fs.existsSync(path.join(dir, ".aiwcli"))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return process.cwd(); // last resort
+}
+
+const target = process.argv[2];
+if (!target) {
+  process.stderr.write("resolve-run: missing script path argument\n");
+  process.exit(1);
+}
+
+const root = findProjectRoot();
+const fullPath = path.resolve(root, target);
+
+if (!fs.existsSync(fullPath)) {
+  process.stderr.write(`resolve-run: script not found: ${fullPath}\n`);
+  process.exit(1);
+}
+
+// Set up environment before importing the hook
+process.env.AIW_CALLER_CWD = process.cwd();
+
+// Scope FORCE_COLOR to status line only — other hooks may emit structured
+// output that should not contain ANSI escape codes.
+if (fullPath.endsWith("status_line.ts")) {
+  process.env.FORCE_COLOR ??= "2";
+}
+
+// Strip the consumed target-script argument so the imported script sees only
+// its own flags in process.argv.slice(2).  Without this, the script path
+// leaks into the args and can end up as literal prompt text sent to agents.
+process.argv.splice(2, 1);
+
+process.chdir(root);
+await import(fullPath);
+
+
+

package/dist/templates/{_shared → core}/scripts/resolve_context.ts

@@ -3,7 +3,7 @@
  * Resolve and print the active context ID.
  *
  * Usage:
- *   bun .aiwcli/_shared/scripts/resolve_context.ts
+ *   bun .aiwcli/_core/scripts/resolve_context.ts
  *
  * Prints the context ID to stdout. Exits 1 if no active context found.
  * Used by command templates (/handoff, /handoff-resume) to programmatically
@@ -11,9 +11,9 @@
  *
  * Requires CLAUDE_SESSION_ID environment variable (set by Claude Code).
  */
-import { getProjectRoot } from "../lib-ts/base/constants.js";
-import { eprint } from "../lib-ts/base/utils.js";
 import { getContextBySessionId } from "../lib-ts/context/context-store.js";
+import { getProjectRoot } from "../lib-ts/runtime/constants.js";
+import { eprint } from "../lib-ts/runtime/utils.js";
 
 const projectRoot = getProjectRoot(process.cwd());
 const sessionId = process.env.CLAUDE_SESSION_ID;