aiwcli 0.15.5 → 0.17.0

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

@@ -1,93 +0,0 @@
-#!/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 uses emitBlock() to block the prompt.
- */
-import { getProjectRoot } from "../lib-ts/base/constants.js";
-import {
-  loadHookInput, runHookAsync, logDebug, logInfo, logWarn, hookLog, emitContext, emitBlock,
-} from "../lib-ts/base/hook-utils.js";
-import { buildContextInventory } from "../lib-ts/context/context-formatter.js";
-import { determineContext, BlockRequest } from "../lib-ts/context/context-selector.js";
-import {
-  getContextBySessionId, bindSession, 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);
-      }
-
-      // Append context folder inventory
-      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) {
-        emitBlock((error as Error).message);
-        return;
-      }
-      throw error; // Re-throw unexpected errors
-    }
-  }
-
-  if (outputs.length > 0) {
-    emitContext(outputs.join("\n\n"));
-  }
-}
-
-runHookAsync(asyncMain, "user_prompt_submit");

package/dist/templates/_shared/lib-ts/agent-exec/backends/headless.ts

@@ -1,33 +0,0 @@
-/**
- * Headless execution backend — wraps execFileAsync() for subprocess execution.
- * Default backend for all CLI agents. If outputFilePath is specified and exists
- * after execution, reads output from file instead of stdout (Codex pattern).
- */
-
-import * as fs from "node:fs";
-
-import { execFileAsync } from "../../base/subprocess-utils.js";
-import type { ExecutionBackend, ExecutionRequest, ExecutionResult } from "../execution-backend.js";
-
-export class HeadlessBackend implements ExecutionBackend {
-  async execute(request: ExecutionRequest): Promise<ExecutionResult> {
-    const result = await execFileAsync(request.cliPath, request.args, {
-      input: request.input,
-      timeout: request.timeoutMs,
-      env: request.env,
-      maxBuffer: request.maxBuffer ?? 10 * 1024 * 1024,
-      shell: request.shell ?? (process.platform === "win32"),
-    });
-
-    // If outputFilePath specified and exists, read from file instead of stdout
-    if (request.outputFilePath && fs.existsSync(request.outputFilePath)) {
-      const fileContent = fs.readFileSync(request.outputFilePath, "utf-8");
-      return {
-        ...result,
-        stdout: fileContent,
-      };
-    }
-
-    return result;
-  }
-}

package/dist/templates/_shared/lib-ts/agent-exec/backends/index.ts

@@ -1,6 +0,0 @@
-/**
- * Barrel re-export for execution backends.
- */
-
-export { HeadlessBackend } from "./headless.js";
-export { TmuxBackend, type TmuxBackendOptions } from "./tmux.js";

package/dist/templates/_shared/lib-ts/agent-exec/backends/tmux.ts

@@ -1,119 +0,0 @@
-/**
- * Tmux execution backend — runs CLI agents in visible tmux panes
- * with sentinel-file-based output capture.
- *
- * Delegates pane management to tmux-driver.ts primitives. Does NOT use
- * launchDriverInTmuxOrFallback() because fallback is the caller's concern,
- * not the backend's.
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-import { execFileAsync } from "../../base/subprocess-utils.js";
-import {
-  buildShellCaptureScript,
-  cleanupSentinelIpc,
-  createSentinelIpcPaths,
-  readSentinelExitCode,
-  readTextIfExists,
-  waitForSentinelFile,
-} from "../../base/sentinel-ipc.js";
-import { getTmuxAvailability, quoteForSh, normalizeSplitFlag } from "../../base/tmux-driver.js";
-import type { ExecutionBackend, ExecutionRequest, ExecutionResult } from "../execution-backend.js";
-
-export interface TmuxBackendOptions {
-  splitFlag?: string;
-  splitTarget?: string;
-}
-
-export class TmuxBackend implements ExecutionBackend {
-  private options: TmuxBackendOptions;
-
-  constructor(options?: TmuxBackendOptions) {
-    this.options = options ?? {};
-  }
-
-  async execute(request: ExecutionRequest): Promise<ExecutionResult> {
-    const tmux = getTmuxAvailability({ requireSessionEnv: true });
-    if (!tmux.available || !tmux.tmuxPath) {
-      return {
-        stdout: "",
-        stderr: `tmux pane launch failed: ${tmux.reason ?? "tmux unavailable"}`,
-        exitCode: 1,
-        killed: false,
-        signal: null,
-      };
-    }
-
-    const agentName = path.basename(request.cliPath).replace(/\.[^.]+$/, "");
-    const ipc = createSentinelIpcPaths(`aiwcli-agent-${agentName}`);
-
-    try {
-      fs.writeFileSync(ipc.inputPath, request.input, "utf-8");
-
-      const envEntries = Object.entries(request.env).filter(
-        ([, value]) => value !== undefined,
-      ) as Array<[string, string]>;
-      const envPrefix = envEntries
-        .map(([key, value]) => `${key}=${quoteForSh(value)}`)
-        .join(" ");
-
-      const quotedArgs = request.args.map((arg) => quoteForSh(arg)).join(" ");
-      const command = `${envPrefix} ${quoteForSh(request.cliPath)} ${quotedArgs}`.trim();
-      const script = buildShellCaptureScript(command, ipc, quoteForSh);
-
-      const splitFlag = normalizeSplitFlag(this.options.splitFlag);
-      const tmuxArgs = ["split-window", splitFlag, "-P", "-F", "#{pane_id}"];
-      if (this.options.splitTarget) {
-        tmuxArgs.push("-t", this.options.splitTarget);
-      }
-      tmuxArgs.push(`bash -lc ${quoteForSh(script)}`);
-
-      const split = await execFileAsync(tmux.tmuxPath, tmuxArgs, { timeout: 5000 });
-      if (split.exitCode !== 0) {
-        return {
-          stdout: "",
-          stderr: `tmux pane launch failed: ${split.stderr.trim()}`,
-          exitCode: 1,
-          killed: false,
-          signal: null,
-        };
-      }
-
-      const paneId = split.stdout.trim().split(/\r?\n/).pop() ?? "";
-      const finished = await waitForSentinelFile(ipc.sentinelPath, request.timeoutMs);
-
-      if (!finished) {
-        if (paneId) {
-          await execFileAsync(tmux.tmuxPath, ["kill-pane", "-t", paneId], { timeout: 3000 });
-        }
-        return {
-          stdout: "",
-          stderr: "",
-          exitCode: -1,
-          killed: true,
-          signal: "SIGTERM",
-        };
-      }
-
-      const exitCode = readSentinelExitCode(ipc.sentinelPath, 1);
-      const stdout = readTextIfExists(ipc.stdoutPath);
-      const stderr = readTextIfExists(ipc.stderrPath);
-
-      if (request.outputFilePath && fs.existsSync(request.outputFilePath)) {
-        return {
-          stdout: fs.readFileSync(request.outputFilePath, "utf-8"),
-          stderr,
-          exitCode,
-          killed: false,
-          signal: null,
-        };
-      }
-
-      return { stdout, stderr, exitCode, killed: false, signal: null };
-    } finally {
-      cleanupSentinelIpc(ipc);
-    }
-  }
-}

package/dist/templates/_shared/lib-ts/agent-exec/execution-backend.ts

@@ -1,50 +0,0 @@
-/**
- * Execution backend interfaces for CLI agent subprocess invocations.
- * Decouples agent logic (prompt building, output parsing) from execution
- * strategy (headless subprocess vs tmux pane).
- */
-
-// ---------------------------------------------------------------------------
-// Execution Request / Result
-// ---------------------------------------------------------------------------
-
-/** Request to execute a CLI subprocess. */
-export interface ExecutionRequest {
-  cliPath: string;
-  args: string[];
-  input: string;
-  env: Record<string, string | undefined>;
-  timeoutMs: number;
-  /** If set, read output from this file instead of stdout (Codex pattern). */
-  outputFilePath?: string;
-  maxBuffer?: number;
-  shell?: boolean;
-}
-
-/** Result from a CLI subprocess execution. */
-export interface ExecutionResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-  killed: boolean;
-  signal: string | null;
-}
-
-// ---------------------------------------------------------------------------
-// Execution Backend
-// ---------------------------------------------------------------------------
-
-/** Strategy interface for running CLI agent subprocesses. */
-export interface ExecutionBackend {
-  execute(request: ExecutionRequest): Promise<ExecutionResult>;
-}
-
-// ---------------------------------------------------------------------------
-// Debug Logger
-// ---------------------------------------------------------------------------
-
-/** Injectable debug logger for agents running in _shared context. */
-export interface AgentDebugLogger {
-  log(contextPath: string, sessionName: string, component: string, message: string, data?: unknown): void;
-  raw(contextPath: string, sessionName: string, component: string, label: string, raw: string): void;
-}

package/dist/templates/_shared/lib-ts/agent-exec/index.ts

@@ -1,6 +0,0 @@
-export { BaseCliAgent, type AgentExecutionConfig } from "./base-agent.js";
-export type { ExecutionBackend, ExecutionRequest, ExecutionResult, AgentDebugLogger } from "./execution-backend.js";
-export { HeadlessBackend } from "./backends/headless.js";
-export { TmuxBackend } from "./backends/tmux.js";
-export { parseJsonObjectMaybe, parseStructuredOutput } from "./structured-output.js";
-export type { StructuredOutputParseOptions } from "./structured-output.js";

package/dist/templates/_shared/lib-ts/agent-exec/structured-output.ts

@@ -1,166 +0,0 @@
-/**
- * Shared structured output parsing utilities for CLI-based agents.
- * Supports Claude/Codex-style envelopes and heuristic JSON extraction.
- */
-
-import { logDebug, logError, logWarn } from "../base/logger.js";
-
-export interface StructuredOutputParseOptions {
-  requireFields?: string[];
-  loggerTag?: string;
-}
-
-const DEFAULT_LOG_TAG = "structured_output";
-
-function getTag(options?: StructuredOutputParseOptions): string {
-  return options?.loggerTag ?? DEFAULT_LOG_TAG;
-}
-
-function validateRequiredFields(
-  obj: Record<string, unknown>,
-  parseMethod: "strict" | "heuristic",
-  options?: StructuredOutputParseOptions,
-): Record<string, unknown> | null {
-  const required = options?.requireFields;
-  if (!required || required.length === 0) return obj;
-
-  const missing = required.filter((field) => !(field in obj) || obj[field] === undefined || obj[field] === null);
-  if (missing.length === 0) return obj;
-
-  const tag = getTag(options);
-  logWarn(tag, `Parsed JSON (${parseMethod}) missing required fields: ${JSON.stringify(missing)}`);
-  logDebug(tag, `Parsed keys: ${JSON.stringify(Object.keys(obj))}`);
-
-  // Heuristic extraction often grabs the wrong JSON blob. Reject in that case.
-  if (parseMethod === "heuristic") {
-    return null;
-  }
-  return obj;
-}
-
-/**
- * Parse a JSON object from text using strict parse first, then heuristic
- * extraction of the first object-like block.
- */
-export function parseJsonObjectMaybe(
-  text: string,
-  options?: StructuredOutputParseOptions,
-): Record<string, unknown> | null {
-  const tag = getTag(options);
-  const trimmed = text.trim();
-  if (!trimmed) return null;
-
-  // Strict parse first.
-  try {
-    const parsed: unknown = JSON.parse(trimmed);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return validateRequiredFields(parsed as Record<string, unknown>, "strict", options);
-    }
-  } catch {
-    // Fall through to heuristic extraction.
-  }
-
-  // Heuristic parse: extract the first object-like block.
-  const start = trimmed.indexOf("{");
-  const end = trimmed.lastIndexOf("}");
-  if (start === -1 || end === -1 || end <= start) return null;
-
-  const candidate = trimmed.slice(start, end + 1);
-  try {
-    const parsed: unknown = JSON.parse(candidate);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      logDebug(tag, `Used heuristic JSON extraction (chars ${start}-${end})`);
-      return validateRequiredFields(parsed as Record<string, unknown>, "heuristic", options);
-    }
-  } catch {
-    logDebug(tag, `Heuristic JSON extraction failed (chars ${start}-${end})`);
-  }
-
-  return null;
-}
-
-function parseAssistantEnvelope(
-  envelope: Record<string, unknown>,
-  options?: StructuredOutputParseOptions,
-): Record<string, unknown> | null {
-  const tag = getTag(options);
-  const message = envelope.message;
-  if (!message || typeof message !== "object") return null;
-
-  const content = (message as Record<string, unknown>).content;
-  if (!Array.isArray(content)) return null;
-
-  for (const item of content) {
-    if (!item || typeof item !== "object") continue;
-    const toolUse = item as Record<string, unknown>;
-    if (toolUse.name !== "StructuredOutput") continue;
-    if (toolUse.input && typeof toolUse.input === "object" && !Array.isArray(toolUse.input)) {
-      logDebug(tag, "Found StructuredOutput in assistant envelope");
-      return toolUse.input as Record<string, unknown>;
-    }
-  }
-  return null;
-}
-
-/**
- * Parse structured output across known CLI envelope formats.
- * Falls back to generic JSON extraction when no recognized envelope exists.
- */
-export function parseStructuredOutput(
-  raw: string,
-  options?: StructuredOutputParseOptions,
-): Record<string, unknown> | null {
-  const tag = getTag(options);
-
-  try {
-    const parsed: unknown = JSON.parse(raw);
-
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      const obj = parsed as Record<string, unknown>;
-
-      if (obj.structured_output && typeof obj.structured_output === "object" && !Array.isArray(obj.structured_output)) {
-        logDebug(tag, "Found structured_output in root object");
-        return validateRequiredFields(obj.structured_output as Record<string, unknown>, "strict", options);
-      }
-
-      const assistantResult = parseAssistantEnvelope(obj, options);
-      if (assistantResult) return assistantResult;
-
-      // Session result envelope (no structured output tool call).
-      if (obj.type === "result" || ("duration_ms" in obj && "session_id" in obj)) {
-        if (obj.is_error === true || (Array.isArray(obj.errors) && obj.errors.length > 0)) {
-          logWarn(tag, `CLI returned error envelope: ${JSON.stringify(obj.errors ?? "is_error=true")}`);
-          return null;
-        }
-
-        if (typeof obj.result === "string" && obj.result.trim().length > 0) {
-          logDebug(tag, "Found text result in session envelope, attempting JSON extraction");
-          const extracted = parseJsonObjectMaybe(obj.result, options);
-          if (extracted) return extracted;
-          logWarn(tag, "Session envelope result contained no extractable JSON object");
-        }
-        return null;
-      }
-    } else if (Array.isArray(parsed)) {
-      for (let i = 0; i < parsed.length; i++) {
-        const event = parsed[i];
-        if (!event || typeof event !== "object") continue;
-        const eventObj = event as Record<string, unknown>;
-        const assistantResult = parseAssistantEnvelope(eventObj, options);
-        if (assistantResult) {
-          logDebug(tag, `Found StructuredOutput in event[${i}]`);
-          return assistantResult;
-        }
-      }
-    }
-  } catch (error: unknown) {
-    if (error instanceof SyntaxError) {
-      logWarn(tag, `JSON decode error: ${error.message}`);
-    } else {
-      logError(tag, `Unexpected parse error: ${error}`);
-    }
-  }
-
-  logDebug(tag, "No structured envelope found, falling back to generic JSON extraction");
-  return parseJsonObjectMaybe(raw, options);
-}

package/dist/templates/_shared/lib-ts/base/launchers/tmux-launcher.ts

@@ -1,173 +0,0 @@
-import { execFileAsync, findExecutable } from "../subprocess-utils.js";
-import { findBestSplit, listPanes } from "../tmux-pane-placement.js";
-import type { PaneLaunchOptions, PaneLaunchResult, PaneLauncher } from "../pane-launcher.js";
-
-export type TmuxSplitFlag = "-h" | "-v";
-
-export interface TmuxAvailability {
-  available: boolean;
-  tmuxPath?: string;
-  reason?: string;
-}
-
-export interface TmuxLauncherOptions {
-  requireSessionEnv?: boolean;
-}
-
-export function quoteForSh(input: string): string {
-  return `'${input.replaceAll("'", "'\"'\"'")}'`;
-}
-
-export function normalizeSplitFlag(value: string | undefined): TmuxSplitFlag {
-  return value?.trim() === "-v" ? "-v" : "-h";
-}
-
-export function getTmuxAvailability(options?: TmuxLauncherOptions): TmuxAvailability {
-  const requireSessionEnv = options?.requireSessionEnv ?? true;
-  if (requireSessionEnv && !process.env.TMUX) {
-    return { available: false, reason: "TMUX is not set" };
-  }
-
-  const tmuxPath = findExecutable("tmux");
-  if (!tmuxPath) {
-    return { available: false, reason: "tmux not found on PATH" };
-  }
-
-  return { available: true, tmuxPath };
-}
-
-function splitFlagFromDimensions(width: number, height: number): TmuxSplitFlag {
-  // Terminal cells are ~2x taller than wide. Correct for aspect ratio so BSP
-  // splits the visually longer axis, not just the higher character count.
-  const CELL_ASPECT_RATIO = 2.0;
-  return width >= height * CELL_ASPECT_RATIO ? "-h" : "-v";
-}
-
-function getLastLine(text: string): string {
-  const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  return lines.at(-1) ?? "";
-}
-
-async function resolveSplitFlagForTargetPane(
-  tmuxPath: string,
-  splitTarget: string,
-): Promise<TmuxSplitFlag | null> {
-  const size = await execFileAsync(
-    tmuxPath,
-    ["display-message", "-p", "-t", splitTarget, "#{pane_width} #{pane_height}"],
-    { timeout: 3000 },
-  );
-  if (size.exitCode !== 0) return null;
-
-  const parts = size.stdout.trim().split(/\s+/);
-  if (parts.length < 2) return null;
-
-  const width = Number.parseInt(parts[0] ?? "", 10);
-  const height = Number.parseInt(parts[1] ?? "", 10);
-  if (!Number.isFinite(width) || !Number.isFinite(height)) return null;
-
-  return splitFlagFromDimensions(width, height);
-}
-
-async function resolveAutoSplit(
-  tmuxPath: string,
-  splitTarget?: string,
-): Promise<{ splitFlag: TmuxSplitFlag; splitTarget?: string }> {
-  const explicitTarget = splitTarget?.trim();
-  if (explicitTarget) {
-    const splitFlag = await resolveSplitFlagForTargetPane(tmuxPath, explicitTarget);
-    return {
-      splitFlag: splitFlag ?? "-h",
-      splitTarget: explicitTarget,
-    };
-  }
-
-  const panes = await listPanes(tmuxPath);
-  const placement = findBestSplit(panes);
-  if (!placement) return { splitFlag: "-h" };
-
-  return {
-    splitFlag: placement.splitFlag,
-    splitTarget: placement.targetPane,
-  };
-}
-
-export class TmuxLauncher implements PaneLauncher {
-  readonly backend = "tmux" as const;
-  private options: TmuxLauncherOptions;
-
-  constructor(options?: TmuxLauncherOptions) {
-    this.options = options ?? {};
-  }
-
-  async available(): Promise<boolean> {
-    return getTmuxAvailability(this.options).available;
-  }
-
-  async launch(options: PaneLaunchOptions): Promise<PaneLaunchResult> {
-    const tmux = getTmuxAvailability(this.options);
-    if (!tmux.available || !tmux.tmuxPath) {
-      return {
-        launched: false,
-        backend: this.backend,
-        reason: tmux.reason ?? "tmux unavailable",
-      };
-    }
-
-    const splitDirection = options.splitDirection ?? "h";
-    const explicitTarget = options.splitTarget?.trim();
-
-    let splitFlag: TmuxSplitFlag;
-    let splitTarget: string | undefined;
-
-    if (splitDirection === "auto") {
-      try {
-        const resolved = await resolveAutoSplit(tmux.tmuxPath, explicitTarget);
-        splitFlag = resolved.splitFlag;
-        splitTarget = resolved.splitTarget;
-      } catch {
-        splitFlag = "-h";
-        splitTarget = explicitTarget;
-      }
-    } else {
-      splitFlag = splitDirection === "v" ? "-v" : "-h";
-      splitTarget = explicitTarget;
-    }
-
-    const body = options.cwd?.trim()
-      ? `cd ${quoteForSh(options.cwd.trim())} && ${options.command}`
-      : options.command;
-
-    const tmuxArgs = ["split-window", splitFlag, "-P", "-F", "#{pane_id}"];
-    if (splitTarget) tmuxArgs.push("-t", splitTarget);
-    tmuxArgs.push(`bash -lc ${quoteForSh(body)}`);
-
-    const split = await execFileAsync(tmux.tmuxPath, tmuxArgs, { timeout: 5000 });
-    if (split.exitCode !== 0) {
-      return {
-        launched: false,
-        backend: this.backend,
-        reason: "tmux split-window failed",
-        stderr: split.stderr.trim() || undefined,
-      };
-    }
-
-    const paneId = getLastLine(split.stdout) || undefined;
-    return {
-      launched: true,
-      backend: this.backend,
-      paneId,
-    };
-  }
-
-  async kill(paneId: string): Promise<void> {
-    if (!paneId) return;
-
-    const tmux = getTmuxAvailability(this.options);
-    if (!tmux.available || !tmux.tmuxPath) return;
-
-    await execFileAsync(tmux.tmuxPath, ["kill-pane", "-t", paneId], {
-      timeout: 3000,
-    });
-  }
-}