aiwcli 0.15.5 → 0.17.0

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

@@ -0,0 +1,369 @@
+/**
+ * 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);
+  });
+}
+
+/**
+ * Print to stderr (shared by agent launch scripts).
+ */
+export function eprint(...args: unknown[]): void {
+  process.stderr.write(args.map(String).join(" ") + "\n");
+}
+
+/**
+ * Best-effort cleanup of a sentinel directory.
+ */
+export function cleanupSentinel(sentinelPath: string | null | undefined): void {
+  if (!sentinelPath) return;
+  try {
+    const dir = path.dirname(sentinelPath);
+    fs.rmSync(dir, { recursive: true, force: true });
+  } catch { /* best-effort */ }
+}
+
+/**
+ * Case-sensitive (or case-insensitive on Windows) path comparison.
+ */
+export function samePath(a: string, b: string): boolean {
+  const left = path.resolve(a);
+  const right = path.resolve(b);
+  if (process.platform === "win32") {
+    return left.toLowerCase() === right.toLowerCase();
+  }
+  return left === right;
+}
+
+/**
+ * Heuristic check for LLM output that isn't a real summary.
+ */
+export function looksLikeBadSummary(output: string): boolean {
+  const normalized = output.toLowerCase();
+  return (
+    normalized.includes("don't see") ||
+    normalized.includes("no output") ||
+    normalized.includes("could you provide") ||
+    normalized.includes("paste")
+  );
+}
+
+/**
+ * Return a deterministic summary file path for a given agent prefix + task ID.
+ * Callers can advertise this path before the session finishes so consumers
+ * know where to look for the summary once it's written.
+ */
+export function getWellKnownSummaryPath(
+  prefix: string,
+  taskId: string,
+  projectRoot?: string,
+): string {
+  const sessionKey = projectRoot
+    ? path.basename(projectRoot)
+    : "unknown";
+  const dir = path.join(os.tmpdir(), "aiw-agent-output", sessionKey);
+  return path.join(dir, `${prefix}-${taskId}.md`).replaceAll("\\", "/");
+}
+
+export function persistSummary(
+  summary: string,
+  prefix: string,
+  sessionId?: string,
+  taskId?: string,
+  projectRoot?: 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");
+
+    // Also write to the well-known path for deterministic discovery.
+    if (taskId) {
+      try {
+        const wkPath = getWellKnownSummaryPath(prefix, taskId, projectRoot);
+        fs.mkdirSync(path.dirname(wkPath), { recursive: true });
+        fs.writeFileSync(wkPath, summary, "utf8");
+      } catch {
+        logWarn("agent-launcher", "Failed to write well-known summary path");
+      }
+    }
+
+    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,108 @@
+/**
+ * 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;
+  /** Launch devin instead of claude. */
+  devin?: 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.devin) args.push("--devin");
+  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.handle ?? 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,18 +4,18 @@
  * platform quoting, model tier resolution, and env setup.
  */
 
+import { CLAUDE_MODELS, CODEX_MODELS, DEVIN_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
 // ---------------------------------------------------------------------------
 
 export type InvocationMode = "structured" | "print" | "preflight";
-export type CliProvider = "claude" | "codex";
+export type CliProvider = "claude" | "codex" | "devin";
 export type ModelTier = "fast" | "standard" | "smart";
 
 const VALID_SANDBOXES = ["read-only", "workspace-write", "danger-full-access"] as const;
@@ -71,6 +71,12 @@ export const CODEX_MODEL_TIERS: Record<ModelTier, string> = {
   smart: CODEX_MODELS.codex,
 };
 
+export const DEVIN_MODEL_TIERS: Record<ModelTier, string> = {
+  fast: DEVIN_MODELS.sonnet,
+  standard: DEVIN_MODELS.swe,
+  smart: DEVIN_MODELS.opus,
+};
+
 export const TIER_TIMEOUTS: Record<ModelTier, number> = {
   fast: 15,
   standard: 30,
@@ -91,7 +97,9 @@ export function resolveModelForProvider(
   provider: CliProvider,
 ): string {
   if (!isModelTier(model)) return model;
-  return provider === "codex" ? CODEX_MODEL_TIERS[model] : MODEL_TIERS[model];
+  if (provider === "codex") return CODEX_MODEL_TIERS[model];
+  if (provider === "devin") return DEVIN_MODEL_TIERS[model];
+  return MODEL_TIERS[model];
 }
 
 export function getTierTimeout(tier: ModelTier): number {
@@ -104,6 +112,12 @@ export function resolveCodexModel(input: string): string {
   return input;
 }
 
+/** Resolve a Devin model: tier resolution + pass-through. No aliases (those are skill-specific). */
+export function resolveDevinModel(input: string): string {
+  if (isModelTier(input)) return DEVIN_MODEL_TIERS[input as ModelTier];
+  return input;
+}
+
 // ---------------------------------------------------------------------------
 // Core Builder
 // ---------------------------------------------------------------------------
@@ -258,7 +272,7 @@ export function reviewSpec(
     model,
     mode: "structured",
     jsonSchema: schema,
-    systemPrompt,
+    ...(systemPrompt ? {systemPrompt} : {}),
   };
 }
 
@@ -270,9 +284,9 @@ export function codexReplSpec(
   return {
     provider: "codex",
     mode: "repl",
-    model,
-    sandbox,
-    yolo,
+    ...(model ? {model} : {}),
+    ...(sandbox ? {sandbox} : {}),
+    ...(yolo !== undefined ? {yolo} : {}),
   };
 }
 
@@ -285,3 +299,5 @@ export function preflightCommandConfig(provider: CliProvider): PreflightCommandC
     input,
   };
 }
+
+export {CLAUDE_MODELS, CODEX_MODELS, DEVIN_MODELS} from "./models.js";