@chlrc/aiw 0.1.0

package/src/layout.mjs

@@ -0,0 +1,54 @@
+import path from "node:path";
+import { aiwBinPath, resolveAgent } from "./config.mjs";
+import { quoteShell } from "./run.mjs";
+
+export function buildLayout(config, agentName) {
+  const agent = resolveAgent(config, agentName);
+  const aiw = quoteShell(aiwBinPath());
+  const agentCommand = [agent.cmd, ...agent.args].map(quoteShell).join(" ");
+  return {
+    direction: "vertical",
+    split: 0.56,
+    children: [
+      {
+        direction: "horizontal",
+        split: 0.34,
+        children: [
+          terminalPane("Files", `${aiw} files`),
+          terminalPane(agentTitle(agent.name), agentCommand)
+        ]
+      },
+      {
+        direction: "horizontal",
+        split: 0.5,
+        children: [
+          terminalPane("Git", `${aiw} git`),
+          terminalPane("Diff", `${aiw} diff --watch`)
+        ]
+      }
+    ]
+  };
+}
+
+export function workspaceName(cwd, agentName) {
+  const repo = path.basename(cwd);
+  return `AI ${agentName}: ${repo}`;
+}
+
+function terminalPane(name, command) {
+  return {
+    pane: {
+      surfaces: [
+        {
+          type: "terminal",
+          name,
+          command
+        }
+      ]
+    }
+  };
+}
+
+function agentTitle(agentName) {
+  return agentName.slice(0, 1).toUpperCase() + agentName.slice(1);
+}

package/src/prompt.mjs

@@ -0,0 +1,60 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { spawnSync } from "node:child_process";
+import { commandExists } from "./run.mjs";
+
+export async function askInput(label, options = {}) {
+  if (!process.stdin.isTTY && !options.allowNonTty) {
+    const error = new Error(`${label} is required, but stdin is not interactive`);
+    error.exitCode = 4;
+    throw error;
+  }
+  const rl = readline.createInterface({ input, output });
+  try {
+    const suffix = options.defaultValue ? ` (${options.defaultValue})` : "";
+    const answer = (await rl.question(`${label}${suffix}: `)).trim();
+    return answer || options.defaultValue || "";
+  } finally {
+    rl.close();
+  }
+}
+
+export async function pickFromList(label, items, options = {}) {
+  if (items.length === 1 && !options.force) {
+    return items[0];
+  }
+  const orderedItems = orderDefault(items, options.defaultItem);
+  if (process.stdin.isTTY && commandExists("fzf")) {
+    const result = spawnSync("fzf", ["--prompt", `${label}> `], {
+      input: `${orderedItems.join("\n")}\n`,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "inherit"]
+    });
+    if (result.status === 0 && result.stdout.trim()) {
+      return result.stdout.trim();
+    }
+  }
+  if (!process.stdin.isTTY) {
+    const error = new Error(`${label} requires an interactive terminal`);
+    error.exitCode = 4;
+    throw error;
+  }
+  orderedItems.forEach((item, index) => {
+    console.log(`${index + 1}. ${item}`);
+  });
+  const answer = await askInput(label);
+  const index = Number(answer);
+  if (!Number.isInteger(index) || index < 1 || index > orderedItems.length) {
+    const error = new Error(`invalid selection: ${answer}`);
+    error.exitCode = 4;
+    throw error;
+  }
+  return orderedItems[index - 1];
+}
+
+function orderDefault(items, defaultItem) {
+  if (!defaultItem || !items.includes(defaultItem)) {
+    return items;
+  }
+  return [defaultItem, ...items.filter((item) => item !== defaultItem)];
+}

package/src/run.mjs

@@ -0,0 +1,78 @@
+import { spawn, spawnSync } from "node:child_process";
+
+export function commandExists(command) {
+  const result = spawnSync("sh", ["-lc", `command -v ${quoteShell(command)} >/dev/null 2>&1`], {
+    stdio: "ignore"
+  });
+  return result.status === 0;
+}
+
+export function commandPath(command) {
+  const result = spawnSync("sh", ["-lc", `command -v ${quoteShell(command)}`], {
+    encoding: "utf8"
+  });
+  return result.status === 0 ? result.stdout.trim() : "";
+}
+
+export function capture(command, args = [], options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd,
+    env: options.env,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.status !== 0) {
+    const error = new Error((result.stderr || result.stdout || `${command} failed`).trim());
+    error.exitCode = result.status || 1;
+    throw error;
+  }
+  return result.stdout.trim();
+}
+
+export function tryCapture(command, args = [], options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd,
+    env: options.env,
+    encoding: "utf8",
+    input: options.input,
+    stdio: [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"]
+  });
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: result.stdout.trim(),
+    stderr: result.stderr.trim()
+  };
+}
+
+export function runInherit(command, args = [], options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      const error = new Error(`${command} exited with code ${code}`);
+      error.exitCode = code || 1;
+      reject(error);
+    });
+  });
+}
+
+export function quoteShell(value) {
+  const text = String(value);
+  if (text.length === 0) {
+    return "''";
+  }
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}