aiwcli 0.15.5 → 0.15.7

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,93 @@
+import * as crypto from "node:crypto";
+
+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")}`
+  );
+}
+
+function resolveArtifactType(state: ContextState): "plan" | "handoff" | null {
+  if (state.next_artifact_type) return state.next_artifact_type;
+
+  const hasPlan = Boolean(state.plan_path && state.plan_hash);
+  const hasHandoff = Boolean(state.handoff_path);
+
+  if (hasPlan && hasHandoff) return "plan";
+  if (hasPlan) return "plan";
+  if (hasHandoff) return "handoff";
+  return null;
+}
+
+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 = resolveArtifactType(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"
+  }
+}

package/dist/templates/core/lib-ts/runtime/agent-launcher.ts

@@ -0,0 +1,295 @@
+/**
+ * Shared agent-launcher utilities used by Codex, Devin, and future agent skills.
+ * Extracted from codex skill to avoid duplication across agent launch scripts.
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import path from "node:path";
+
+import { logDebug, logWarn } from "./logger.js";
+import { execFileAsync, findExecutable } from "./subprocess-utils.js";
+import { buildExternalAgentContext } from "../context/context-formatter.js";
+import { getContextBySessionId, getContext } from "../context/context-store.js";
+import type { ContextState } from "../types.js";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+export const POLL_INTERVAL_MS = 2000;
+export const POLL_TIMEOUT_MS = 3000;
+export const WAIT_TIMEOUT_MS_DEFAULT = 14_400_000;
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+type PaneBackend = "tmux" | "window" | "exec";
+
+export interface PaneWatchTarget {
+  backend?: PaneBackend;
+  paneId?: string;
+  sentinelPath?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Generic Helpers
+// ---------------------------------------------------------------------------
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+export function persistSummary(
+  summary: string,
+  prefix: string,
+  sessionId?: string,
+): string | null {
+  try {
+    const suffix = sessionId
+      ? sessionId.replaceAll(/[^a-zA-Z0-9_-]/g, "").slice(0, 8)
+      : String(process.pid);
+    const filePath = path.join(
+      os.tmpdir(),
+      `${prefix}-summary-${Date.now()}-${suffix}.md`,
+    );
+    fs.writeFileSync(filePath, summary, "utf8");
+    return filePath.replaceAll("\\", "/");
+  } catch (error) {
+    logWarn("agent-launcher", `Failed to persist summary: ${String(error)}`);
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Plan Discovery
+// ---------------------------------------------------------------------------
+
+/** Fallback plan discovery: scan all context plan dirs by mtime. */
+export function findLatestPlanByMtime(projectRoot: string): string | null {
+  const contextsDir = path.join(projectRoot, "_output", "contexts");
+  if (!fs.existsSync(contextsDir)) return null;
+
+  let best: { path: string; mtime: number } | null = null;
+
+  for (const ctxEntry of fs.readdirSync(contextsDir)) {
+    if (ctxEntry.startsWith("_")) continue;
+    const plansDir = path.join(contextsDir, ctxEntry, "plans");
+    if (!fs.existsSync(plansDir)) continue;
+
+    for (const file of fs.readdirSync(plansDir)) {
+      if (!file.endsWith(".md")) continue;
+      const fullPath = path.join(plansDir, file);
+      try {
+        const mtime = fs.statSync(fullPath).mtimeMs;
+        if (!best || mtime > best.mtime) {
+          best = { path: fullPath, mtime };
+        }
+      } catch { /* skip unreadable */ }
+    }
+  }
+
+  return best?.path ?? null;
+}
+
+// ---------------------------------------------------------------------------
+// Bootstrap Prompt Construction
+// ---------------------------------------------------------------------------
+
+export function buildFileModeBootstrapPrompt(
+  targetPath: string,
+  sourceLabel: "plan" | "file",
+  extraPrompt?: string,
+  orientation?: string,
+): string {
+  const absolutePath = path.resolve(targetPath);
+  const sourceTitle = sourceLabel === "plan" ? "Plan Source" : "File Source";
+  const sections: string[] = ["## Startup Brief", ""];
+
+  if (orientation?.trim()) {
+    sections.push(orientation.trim(), "", "---", "");
+  }
+
+  sections.push(
+    `## ${sourceTitle}`,
+    "",
+    `Primary input path: ${absolutePath}`,
+    "",
+    "Read this file directly from disk before taking action.",
+    "Treat its contents as the source of truth.",
+    "Do not ask for the file contents to be pasted inline.",
+  );
+
+  if (extraPrompt?.trim()) {
+    sections.push("", "## Additional Instructions", "", extraPrompt.trim());
+  }
+
+  return sections.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Context Resolution
+// ---------------------------------------------------------------------------
+
+export function resolveContextForLaunch(
+  contextFlag: string | undefined,
+  projectRoot: string,
+): ContextState | null {
+  if (contextFlag) {
+    return getContext(contextFlag, projectRoot) ?? null;
+  }
+  const sessionId = process.env.CLAUDE_SESSION_ID;
+  if (sessionId) {
+    return getContextBySessionId(sessionId, projectRoot) ?? null;
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Prompt File Writers
+// ---------------------------------------------------------------------------
+
+export interface WritePromptFileOpts {
+  ctx?: ContextState | null;
+  extraPrompt?: string;
+  projectRoot: string;
+  tempFilePrefix: string;
+}
+
+export interface WriteFileRefPromptFileOpts extends WritePromptFileOpts {
+  fileReferencePath: string;
+  label: "plan" | "file";
+}
+
+export interface WriteInlinePromptFileOpts extends WritePromptFileOpts {
+  text: string;
+}
+
+/**
+ * Build a file-reference bootstrap prompt and write it to a temp file.
+ * Returns the temp file path.
+ */
+export function writeFileRefPromptFile(opts: WriteFileRefPromptFileOpts): string {
+  let orientation = "";
+  if (opts.ctx) {
+    try {
+      orientation = buildExternalAgentContext(opts.ctx, opts.projectRoot);
+    } catch {
+      logWarn("agent-launcher", `Context orientation build failed for ${opts.ctx.id}`);
+    }
+  }
+
+  const bootstrap = buildFileModeBootstrapPrompt(
+    opts.fileReferencePath,
+    opts.label,
+    opts.extraPrompt,
+    orientation,
+  );
+  const tempFile = path.join(os.tmpdir(), `${opts.tempFilePrefix}-file-ref-${Date.now()}.md`);
+  fs.writeFileSync(tempFile, bootstrap, "utf8");
+  return tempFile;
+}
+
+/**
+ * Write inline text to a temp file, prepend context orientation, append extra prompt.
+ * Returns the temp file path.
+ */
+export function writeInlinePromptFile(opts: WriteInlinePromptFileOpts): string {
+  let content = opts.text;
+
+  if (opts.ctx) {
+    try {
+      const orientation = buildExternalAgentContext(opts.ctx, opts.projectRoot);
+      content = `${orientation}\n\n---\n\n${content}`;
+    } catch {
+      logWarn("agent-launcher", `Context orientation prepend failed for ${opts.ctx.id}`);
+    }
+  }
+
+  if (opts.extraPrompt?.trim()) {
+    content = `${content}\n\n---\n\n## Additional Instructions\n\n${opts.extraPrompt}`;
+  }
+
+  const tempFile = path.join(os.tmpdir(), `${opts.tempFilePrefix}-prompt-${Date.now()}.md`);
+  fs.writeFileSync(tempFile, content, "utf8");
+  return tempFile;
+}
+
+// ---------------------------------------------------------------------------
+// Pane Watching
+// ---------------------------------------------------------------------------
+
+async function waitForSentinelClose(sentinelPath: string, timeoutMs: number): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    if (fs.existsSync(sentinelPath)) return;
+    if (Date.now() >= deadline) {
+      logDebug("agent-launcher", `watch timeout reached waiting for sentinel ${sentinelPath}`);
+      return;
+    }
+
+    const remainingMs = deadline - Date.now();
+    await sleep(Math.max(0, Math.min(POLL_INTERVAL_MS, remainingMs)));
+  }
+}
+
+function normalizeWatchTarget(target: string | PaneWatchTarget): PaneWatchTarget {
+  if (typeof target === "string") {
+    return { backend: "tmux", paneId: target };
+  }
+  return target;
+}
+
+export async function waitForPaneClose(
+  target: string | PaneWatchTarget,
+  timeoutMs = WAIT_TIMEOUT_MS_DEFAULT,
+): Promise<void> {
+  const watch = normalizeWatchTarget(target);
+
+  if (watch.sentinelPath) {
+    await waitForSentinelClose(watch.sentinelPath, timeoutMs);
+    return;
+  }
+
+  const backend = watch.backend ?? "tmux";
+  const paneId = watch.paneId ?? "";
+
+  if (backend !== "tmux") {
+    logDebug("agent-launcher", `No pane watcher for backend=${backend}; continuing without wait`);
+    return;
+  }
+
+  if (!paneId) return;
+
+  const tmuxPath = findExecutable("tmux");
+  if (!tmuxPath) {
+    logWarn("agent-launcher", `tmux unavailable while watching pane ${paneId}`);
+    return;
+  }
+
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    if (Date.now() >= deadline) {
+      logDebug("agent-launcher", `watch timeout reached for pane ${paneId} after ${timeoutMs}ms`);
+      return;
+    }
+
+    const result = await execFileAsync(tmuxPath, ["list-panes", "-a", "-F", "#{pane_id}"], {
+      timeout: POLL_TIMEOUT_MS,
+    });
+
+    if (result.exitCode !== 0) {
+      logDebug("agent-launcher", `list-panes failed; assuming pane closed (${result.stderr.trim() || "no stderr"})`);
+      return;
+    }
+
+    const activePaneIds = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    if (!activePaneIds.includes(paneId)) return;
+
+    const remainingMs = deadline - Date.now();
+    await sleep(Math.max(0, Math.min(POLL_INTERVAL_MS, remainingMs)));
+  }
+}

package/dist/templates/core/lib-ts/runtime/aiw-cli.ts

@@ -0,0 +1,106 @@
+/**
+ * Helper to discover and invoke the `aiw` CLI binary from template scripts.
+ *
+ * Reads the resolved binary path from `.aiwcli/.aiw-bin-path` (written by `aiw init`).
+ * Falls back to `aiw` on PATH if the file is missing.
+ */
+
+import * as fs from "node:fs";
+import path from "node:path";
+
+import { getProjectRoot } from "./constants.js";
+import { execFileAsync, type ExecResult } from "./subprocess-utils.js";
+
+function resolveAiwBin(cwd?: string): string {
+  const projectRoot = getProjectRoot(cwd ?? process.cwd());
+  const binPathFile = path.join(projectRoot, ".aiwcli", ".aiw-bin-path");
+  try {
+    const binPath = fs.readFileSync(binPathFile, "utf8").trim();
+    if (binPath && fs.existsSync(binPath)) return binPath;
+  } catch {
+    // Fall through to PATH lookup
+  }
+
+  return "aiw";
+}
+
+export interface AiwLaunchOptions {
+  /** Launch codex instead of claude. */
+  codex?: boolean;
+  /** Working directory. */
+  cwd?: string;
+  /** Extra env vars to inject. */
+  env?: Record<string, string>;
+  /** Return JSON output. */
+  json?: boolean;
+  /** Path to prompt file. */
+  promptPath?: string;
+  /** Split direction: auto, h, or v. */
+  split?: "auto" | "h" | "v";
+  /** Timeout in ms (only relevant with --wait). */
+  timeoutMs?: number;
+  /** Block until pane exits. */
+  wait?: boolean;
+}
+
+export interface AiwLaunchResult {
+  backend: string;
+  exitCode: null | number;
+  launched: boolean;
+  paneId: null | string;
+  reason: null | string;
+  sentinelPath: null | string;
+}
+
+/**
+ * Shell out to `aiw launch` with structured options.
+ * Returns parsed JSON result when --json is used.
+ */
+export async function aiwLaunch(options: AiwLaunchOptions): Promise<AiwLaunchResult> {
+  const bin = resolveAiwBin(options.cwd);
+  const args = ["launch"];
+
+  if (options.codex) args.push("--codex");
+  if (options.wait) args.push("--wait");
+  args.push("--json");
+  if (options.split) args.push("--split", options.split);
+  if (options.env && Object.keys(options.env).length > 0) {
+    args.push("--env", JSON.stringify(options.env));
+  }
+
+  if (options.promptPath) args.push("--prompt-path", options.promptPath);
+
+  const result = await execFileAsync(bin, args, {
+    timeout: options.timeoutMs ?? 14_400_000,
+    env: process.env as Record<string, string>,
+    shell: process.platform === "win32",
+  });
+
+  return parseJsonResult(result);
+}
+
+function parseJsonResult(result: ExecResult): AiwLaunchResult {
+  try {
+    const lines = result.stdout.trim().split(/\r?\n/);
+    const lastLine = lines.at(-1) ?? "";
+    const parsed = JSON.parse(lastLine);
+    return {
+      launched: Boolean(parsed.launched),
+      backend: String(parsed.backend ?? "exec"),
+      paneId: parsed.paneId ?? null,
+      sentinelPath: parsed.sentinelPath ?? null,
+      exitCode: typeof parsed.exitCode === "number" ? parsed.exitCode : null,
+      reason: parsed.reason ?? null,
+    };
+  } catch {
+    return {
+      launched: false,
+      backend: "exec",
+      paneId: null,
+      sentinelPath: null,
+      exitCode: result.exitCode,
+      reason: `Failed to parse aiw launch output: ${result.stderr || result.stdout}`,
+    };
+  }
+}
+

package/dist/templates/{_shared/lib-ts/base → core/lib-ts/runtime}/atomic-write.ts

@@ -8,7 +8,7 @@
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as _os from "node:os";
-import * as path from "node:path";
+import path from "node:path";
 
 /**
  * Write file atomically with retry logic.
@@ -21,6 +21,7 @@ export function atomicWrite(
   content: string,
   maxAttempts = 2,
   backoffMs: number[] = [500, 1000],
+  fsync = true,
 ): [boolean, null | string] {
   // Ensure parent directory exists
   const dir = path.dirname(filePath);
@@ -36,8 +37,8 @@ export function atomicWrite(
       // Write to temp file
       const fd = fs.openSync(tmpPath, "w");
       try {
-        fs.writeSync(fd, content, undefined, "utf-8");
-        fs.fsyncSync(fd);
+        fs.writeSync(fd, content, undefined, "utf8");
+        if (fsync) fs.fsyncSync(fd);
       } finally {
         fs.closeSync(fd);
       }
@@ -53,7 +54,7 @@ export function atomicWrite(
       fs.renameSync(tmpPath, filePath);
 
       return [true, null];
-    } catch (error: any) {
+    } catch (error: unknown) {
       // Clean up temp file
       try {
         fs.unlinkSync(tmpPath);
@@ -85,6 +86,7 @@ export function atomicAppend(
   content: string,
   maxAttempts = 2,
   backoffMs: number[] = [500, 1000],
+  fsync = true,
 ): [boolean, null | string] {
   // Ensure parent directory exists
   const dir = path.dirname(filePath);
@@ -96,8 +98,8 @@ export function atomicAppend(
     try {
       const fd = fs.openSync(filePath, "a");
       try {
-        fs.writeSync(fd, content, undefined, "utf-8");
-        fs.fsyncSync(fd);
+        fs.writeSync(fd, content, undefined, "utf8");
+        if (fsync) fs.fsyncSync(fd);
       } finally {
         fs.closeSync(fd);
       }
@@ -112,7 +114,7 @@ export function atomicAppend(
       }
 
       return [true, null];
-    } catch (error: any) {
+    } catch (error: unknown) {
       if (attempt < maxAttempts - 1) {
         const waitMs = backoffMs[Math.min(attempt, backoffMs.length - 1)] ?? backoffMs.at(-1) ?? 500;
         sleepSync(waitMs);
@@ -136,3 +138,6 @@ function sleepSync(ms: number): void {
   const i32 = new Int32Array(sab);
   Atomics.wait(i32, 0, 0, ms);
 }
+
+
+

package/dist/templates/{_shared/lib-ts/base → core/lib-ts/runtime}/cli-args.ts

@@ -4,11 +4,11 @@
  * platform quoting, model tier resolution, and env setup.
  */
 
+import { CLAUDE_MODELS, CODEX_MODELS } from "./models.js";
 import type { PreflightCommandConfig } from "./preflight.js";
 import { getInternalSubprocessEnv, shellQuoteWin } from "./subprocess-utils.js";
-import { CLAUDE_MODELS, CODEX_MODELS } from "./models.js";
 
-export { CLAUDE_MODELS, CODEX_MODELS };
+
 
 // ---------------------------------------------------------------------------
 // Types
@@ -258,7 +258,7 @@ export function reviewSpec(
     model,
     mode: "structured",
     jsonSchema: schema,
-    systemPrompt,
+    ...(systemPrompt ? {systemPrompt} : {}),
   };
 }
 
@@ -270,9 +270,9 @@ export function codexReplSpec(
   return {
     provider: "codex",
     mode: "repl",
-    model,
-    sandbox,
-    yolo,
+    ...(model ? {model} : {}),
+    ...(sandbox ? {sandbox} : {}),
+    ...(yolo !== undefined ? {yolo} : {}),
   };
 }
 
@@ -285,3 +285,5 @@ export function preflightCommandConfig(provider: CliProvider): PreflightCommandC
     input,
   };
 }
+
+export {CLAUDE_MODELS, CODEX_MODELS} from "./models.js";