@chlrc/aiw 0.1.0

package/src/commit.mjs

@@ -0,0 +1,175 @@
+import fs from "node:fs";
+import path from "node:path";
+import { cleanAgentText, runAgentForText } from "./agent.mjs";
+import { expandHome, resolveAgent } from "./config.mjs";
+import { capture, tryCapture } from "./run.mjs";
+
+const DEFAULT_COMMIT_PROMPT = `Generate a Git commit message for the staged diff.
+
+Rules:
+- Output only the commit message. Do not add Markdown fences or explanations.
+- Prefer Conventional Commits when the change clearly fits one type.
+- Keep the first line concise and specific.
+- Use a body only when it clarifies non-obvious context or hook failures.
+- Do not mention generated tooling unless it is part of the change.`;
+
+export async function runCommit(config, flags) {
+  const repo = capture("git", ["rev-parse", "--show-toplevel"], { cwd: process.cwd() });
+  const retries = Number(flags.retries || config.commit.retries || 3);
+  const agent = resolveAgent(config, flags.agent || config.commit.agent || config.defaults.agent);
+  const customPrompt = loadCustomPrompt(config, flags);
+  let lastFailure = null;
+
+  for (let attempt = 1; attempt <= retries; attempt += 1) {
+    const staged = readStagedDiff(config, repo);
+    if (!staged.diff) {
+      throw withExit("no staged changes; stage files before running aiw commit", 6);
+    }
+
+    const prompt = buildCommitPrompt({
+      basePrompt: customPrompt,
+      staged,
+      attempt,
+      retries,
+      lastFailure
+    });
+
+    if (flags.printPrompt) {
+      console.log(prompt);
+      return;
+    }
+
+    const agentResult = runAgentForText(agent, prompt, { cwd: repo });
+    if (!agentResult.ok) {
+      throw withExit(
+        [
+          `agent '${agent.name}' failed while generating commit message`,
+          agentResult.stderr.trim(),
+          agentResult.stdout.trim()
+        ].filter(Boolean).join("\n"),
+        agentResult.status || 1
+      );
+    }
+
+    const message = cleanAgentText(agentResult.stdout);
+    if (!message) {
+      throw withExit(`agent '${agent.name}' returned an empty commit message`, 7);
+    }
+
+    if (flags.dryRun) {
+      console.log(message);
+      return;
+    }
+
+    console.log(`[aiw commit] attempt ${attempt}/${retries}`);
+    console.log(firstLine(message));
+    const commitResult = tryCommit(repo, message);
+    if (commitResult.ok) {
+      process.stdout.write(commitResult.stdout);
+      process.stderr.write(commitResult.stderr);
+      return;
+    }
+
+    lastFailure = {
+      message,
+      output: [commitResult.stdout, commitResult.stderr].filter(Boolean).join("\n").trim()
+    };
+    process.stderr.write(lastFailure.output ? `${lastFailure.output}\n` : "");
+    if (attempt < retries) {
+      console.error(`[aiw commit] commit failed; regenerating message and retrying (${attempt + 1}/${retries})`);
+    }
+  }
+
+  throw withExit(`git commit failed after ${retries} attempts`, 8);
+}
+
+function readStagedDiff(config, repo) {
+  const diff = capture("git", ["diff", "--cached", "--no-ext-diff"], { cwd: repo });
+  const statResult = tryCapture("git", ["diff", "--cached", "--stat"], { cwd: repo });
+  const statusResult = tryCapture("git", ["status", "--short"], { cwd: repo });
+  const maxChars = Number(config.commit.max_diff_chars || 120000);
+  const truncated = diff.length > maxChars;
+  return {
+    diff: truncated ? diff.slice(0, maxChars) : diff,
+    truncated,
+    stat: statResult.ok ? statResult.stdout : "",
+    status: statusResult.ok ? statusResult.stdout : ""
+  };
+}
+
+function buildCommitPrompt({ basePrompt, staged, attempt, retries, lastFailure }) {
+  const sections = [
+    basePrompt,
+    `Attempt: ${attempt}/${retries}`,
+    "Git status:",
+    fenced(staged.status || "(empty)"),
+    "Staged diff stat:",
+    fenced(staged.stat || "(empty)")
+  ];
+
+  if (lastFailure) {
+    sections.push(
+      "The previous commit message failed during git commit hooks. Generate a corrected commit message.",
+      "Previous commit message:",
+      fenced(lastFailure.message),
+      "Hook / git commit output:",
+      fenced(lastFailure.output || "(empty)")
+    );
+  }
+
+  sections.push(
+    staged.truncated
+      ? "Staged diff (truncated due to max_diff_chars):"
+      : "Staged diff:",
+    fenced(staged.diff)
+  );
+
+  return sections.join("\n\n");
+}
+
+function loadCustomPrompt(config, flags) {
+  const parts = [];
+  const defaultPromptFile = config.commit.prompt_file
+    ? resolveConfigPath(config, config.commit.prompt_file)
+    : "";
+  if (defaultPromptFile && fs.existsSync(defaultPromptFile)) {
+    parts.push(fs.readFileSync(defaultPromptFile, "utf8").trim());
+  }
+  if (flags.promptFile) {
+    const promptFile = expandHome(flags.promptFile);
+    parts.push(fs.readFileSync(promptFile, "utf8").trim());
+  }
+  if (flags.prompt) {
+    parts.push(flags.prompt);
+  }
+  if (parts.length === 0) {
+    parts.push(DEFAULT_COMMIT_PROMPT);
+  }
+  return parts.filter(Boolean).join("\n\nAdditional user prompt:\n");
+}
+
+function resolveConfigPath(config, value) {
+  const expanded = expandHome(value);
+  return path.isAbsolute(expanded) ? expanded : path.join(config.configDir, expanded);
+}
+
+function tryCommit(repo, message) {
+  return tryCapture("git", ["commit", "-F", "-"], {
+    cwd: repo,
+    input: message.endsWith("\n") ? message : `${message}\n`
+  });
+}
+
+function fenced(value) {
+  return `\`\`\`\n${value}\n\`\`\``;
+}
+
+function firstLine(value) {
+  return value.split(/\r?\n/).find(Boolean) || "(empty commit message)";
+}
+
+function withExit(message, exitCode) {
+  const error = new Error(message);
+  error.exitCode = exitCode;
+  return error;
+}

package/src/config.mjs

@@ -0,0 +1,190 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+export function projectRoot() {
+  return ROOT;
+}
+
+export function aiwBinPath() {
+  return path.join(ROOT, "bin", "aiw");
+}
+
+export function expandHome(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  if (value === "~") {
+    return os.homedir();
+  }
+  if (value.startsWith("~/")) {
+    return path.join(os.homedir(), value.slice(2));
+  }
+  return value;
+}
+
+export function loadConfig() {
+  const configDir = process.env.AIW_CONFIG_DIR
+    ? expandHome(process.env.AIW_CONFIG_DIR)
+    : firstExistingDir([
+        path.join(os.homedir(), ".config", "aiw"),
+        path.join(ROOT, "config")
+      ]);
+
+  const aiwPath = path.join(configDir, "aiw.toml");
+  const agentsPath = path.join(configDir, "agents.toml");
+  const aiw = fs.existsSync(aiwPath) ? parseToml(fs.readFileSync(aiwPath, "utf8")) : {};
+  const agents = fs.existsSync(agentsPath) ? parseToml(fs.readFileSync(agentsPath, "utf8")) : {};
+
+  return {
+    configDir,
+    aiwPath,
+    agentsPath,
+    defaults: aiw.defaults || {},
+    paths: normalizePaths(aiw.paths || {}),
+    behavior: aiw.behavior || {},
+    commit: aiw.commit || {},
+    git: aiw.git || {},
+    workspace: aiw.workspace || {},
+    agents: agents.agents || {}
+  };
+}
+
+export function resolveAgent(config, requestedAgent) {
+  const name = requestedAgent || config.defaults.agent || "codex";
+  const entry = config.agents[name];
+  if (!entry || typeof entry.cmd !== "string" || entry.cmd.length === 0) {
+    const error = new Error(`unknown agent '${name}' in ${config.agentsPath}`);
+    error.exitCode = 2;
+    throw error;
+  }
+  return {
+    name,
+    cmd: entry.cmd,
+    args: Array.isArray(entry.args) ? entry.args.map(String) : [],
+    commitArgs: Array.isArray(entry.commit_args) ? entry.commit_args.map(String) : []
+  };
+}
+
+function normalizePaths(paths) {
+  return {
+    code_root: expandHome(paths.code_root || path.join(os.homedir(), "Code")),
+    worktrees: expandHome(paths.worktrees || "~/worktrees"),
+    core_config: expandHome(paths.core_config || ROOT)
+  };
+}
+
+function firstExistingDir(candidates) {
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return candidates[candidates.length - 1];
+}
+
+export function parseToml(source) {
+  const root = {};
+  let current = root;
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = stripComment(rawLine).trim();
+    if (!line) {
+      continue;
+    }
+    const sectionMatch = line.match(/^\[([A-Za-z0-9_.-]+)\]$/);
+    if (sectionMatch) {
+      current = root;
+      for (const part of sectionMatch[1].split(".")) {
+        current[part] = current[part] || {};
+        current = current[part];
+      }
+      continue;
+    }
+    const eq = line.indexOf("=");
+    if (eq === -1) {
+      continue;
+    }
+    const key = line.slice(0, eq).trim();
+    const value = line.slice(eq + 1).trim();
+    current[key] = parseTomlValue(value);
+  }
+  return root;
+}
+
+function stripComment(line) {
+  let inString = false;
+  let escaped = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (char === "#" && !inString) {
+      return line.slice(0, index);
+    }
+  }
+  return line;
+}
+
+function parseTomlValue(value) {
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  if (/^-?\d+(\.\d+)?$/.test(value)) {
+    return Number(value);
+  }
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const body = value.slice(1, -1).trim();
+    if (!body) {
+      return [];
+    }
+    return splitArray(body).map((item) => parseTomlValue(item.trim()));
+  }
+  return value;
+}
+
+function splitArray(body) {
+  const items = [];
+  let start = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = 0; index < body.length; index += 1) {
+    const char = body[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (char === "," && !inString) {
+      items.push(body.slice(start, index));
+      start = index + 1;
+    }
+  }
+  items.push(body.slice(start));
+  return items;
+}

package/src/deps.mjs

@@ -0,0 +1,172 @@
+import { commandExists, commandPath } from "./run.mjs";
+
+const COMMON_TOOLS = [
+  "git",
+  "cmux",
+  "wt",
+  "yazi",
+  "nvim",
+  "lazygit",
+  "delta",
+  "fd",
+  "rg",
+  "fzf",
+  "bat",
+  "eza",
+  "codex",
+  "claude",
+  "opencode",
+  "gemini",
+  "aider",
+  "cmux-git-diff"
+];
+
+export function collectDoctor(config) {
+  const tools = COMMON_TOOLS.map((name) => ({
+    name,
+    ok: commandExists(name),
+    path: commandPath(name)
+  }));
+  const agents = Object.entries(config.agents).map(([name, agent]) => ({
+    name,
+    cmd: agent.cmd,
+    ok: typeof agent.cmd === "string" && commandExists(agent.cmd),
+    path: typeof agent.cmd === "string" ? commandPath(agent.cmd) : ""
+  }));
+  return { tools, agents };
+}
+
+export function gate(profile, config, agent) {
+  const requirements = requirementsFor(profile, config, agent);
+  const missing = [];
+  const satisfied = [];
+
+  for (const requirement of requirements.commands) {
+    if (commandExists(requirement)) {
+      satisfied.push(requirement);
+    } else {
+      missing.push(requirement);
+    }
+  }
+
+  for (const alternative of requirements.anyOf) {
+    const found = alternative.find((candidate) => commandExists(candidate));
+    if (found) {
+      satisfied.push(found);
+    } else {
+      missing.push(alternative.join(" or "));
+    }
+  }
+
+  return {
+    ok: missing.length === 0,
+    profile,
+    satisfied,
+    missing
+  };
+}
+
+export function assertGate(profile, config, agent) {
+  const result = gate(profile, config, agent);
+  if (result.ok) {
+    return result;
+  }
+  const error = new Error(
+    [
+      `dependency gate '${profile}' failed`,
+      ...result.missing.map((item) => `  [missing] ${item}`),
+      "Install missing tools or change ~/.config/aiw config before retrying."
+    ].join("\n")
+  );
+  error.exitCode = 10;
+  throw error;
+}
+
+export function printDoctor(config, options = {}) {
+  const doctor = collectDoctor(config);
+  const gateName = options.gate;
+  const gateResult = gateName ? gate(gateName, config, options.agent) : gate("p0", config, options.agent);
+  const payload = {
+    ok: gateResult.ok,
+    gate: gateResult,
+    tools: doctor.tools,
+    agents: doctor.agents,
+    config: {
+      configDir: config.configDir,
+      aiwPath: config.aiwPath,
+      agentsPath: config.agentsPath
+    }
+  };
+
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    for (const tool of doctor.tools) {
+      const status = tool.ok ? "[ok]" : "[missing]";
+      const suffix = tool.path ? ` ${tool.path}` : "";
+      console.log(`${status} ${tool.name}${suffix}`);
+    }
+    console.log("");
+    console.log(`gate: ${gateResult.profile}`);
+    if (gateResult.ok) {
+      console.log("[ok] dependency gate passed");
+    } else {
+      for (const item of gateResult.missing) {
+        console.log(`[missing] ${item}`);
+      }
+    }
+  }
+
+  if (!gateResult.ok) {
+    const error = new Error(`dependency gate '${gateResult.profile}' failed`);
+    error.exitCode = 10;
+    throw error;
+  }
+}
+
+function requirementsFor(profile, config, agent) {
+  const agentCmd = agent?.cmd;
+  switch (profile) {
+    case "base":
+      return req(["git"]);
+    case "init":
+      return req(["sh", "git", "cmux", "wt", "yazi", "nvim", "lazygit", "rg", "fzf", "bat", agentCmd].filter(Boolean), [
+        ["cmux-git-diff", "delta"]
+      ]);
+    case "layout":
+      return req(["git", "cmux", "yazi", "lazygit", "nvim", agentCmd].filter(Boolean), [
+        ["cmux-git-diff", "delta"]
+      ]);
+    case "cmux-new":
+    case "new":
+      return req(["git", "wt", "cmux", "yazi", "lazygit", "nvim", agentCmd].filter(Boolean), [
+        ["cmux-git-diff", "delta"]
+      ]);
+    case "worktrunk":
+    case "workspace":
+      return req(["git", "wt"]);
+    case "files":
+      return req([config.defaults.files || "yazi"]);
+    case "git":
+      return req([config.defaults.git || "lazygit", ...(config.git.lazygit_config ? ["delta"] : [])]);
+    case "edit":
+      return req([config.defaults.editor || "nvim"]);
+    case "grep":
+      return req(["rg", "fzf", "bat", config.defaults.editor || "nvim"]);
+    case "pick":
+      return req(["fd", "fzf", "bat", config.defaults.editor || "nvim"]);
+    case "tree":
+      return req([], [["eza", "find"]]);
+    case "diff":
+      return req(["git"], [["cmux-git-diff", "delta"]]);
+    case "commit":
+      return req(["git", agentCmd].filter(Boolean));
+    case "p0":
+    default:
+      return req(["git", "cmux", "wt", "yazi", "nvim", "lazygit", "delta", "fd", "rg", "fzf", "bat", "eza"]);
+  }
+}
+
+function req(commands, anyOf = []) {
+  return { commands, anyOf };
+}