@chlrc/aiw 0.1.0

package/src/git.mjs

@@ -0,0 +1,210 @@
+import fs from "node:fs";
+import path from "node:path";
+import { capture, tryCapture } from "./run.mjs";
+import { pickFromList } from "./prompt.mjs";
+
+const SKIP_DIRS = new Set([
+  ".git",
+  "node_modules",
+  ".pnpm-store",
+  ".turbo",
+  ".next",
+  "dist",
+  "build",
+  "coverage"
+]);
+
+export function gitRoot(cwd = process.cwd()) {
+  const result = tryCapture("git", ["rev-parse", "--show-toplevel"], { cwd });
+  return result.ok ? result.stdout : "";
+}
+
+export function assertGitRoot(cwd = process.cwd()) {
+  const root = gitRoot(cwd);
+  if (root) {
+    return root;
+  }
+  const error = new Error(`not inside a Git repository: ${cwd}`);
+  error.exitCode = 3;
+  throw error;
+}
+
+export function isDirty(repo) {
+  const result = tryCapture("git", ["status", "--porcelain"], { cwd: repo });
+  return result.ok && result.stdout.length > 0;
+}
+
+export async function resolveRepo(cwd, codeRoot, explicitRepo, options = {}) {
+  if (explicitRepo) {
+    const root = gitRoot(explicitRepo);
+    if (!root) {
+      throw withExit(`not a Git repository: ${explicitRepo}`, 3);
+    }
+    return root;
+  }
+
+  if (options.pickRepo) {
+    return pickRepoFromRoot(codeRoot);
+  }
+
+  const current = gitRoot(cwd);
+  if (current) {
+    return current;
+  }
+
+  const normalizedCodeRoot = path.resolve(codeRoot);
+  const normalizedCwd = path.resolve(cwd);
+  if (!isInside(normalizedCwd, normalizedCodeRoot)) {
+    throw withExit(`not inside a Git repository and not under code root: ${cwd}`, 3);
+  }
+
+  const repos = discoverRepos(normalizedCwd === normalizedCodeRoot ? normalizedCodeRoot : normalizedCwd, 3);
+  if (repos.length === 0 && normalizedCwd !== normalizedCodeRoot) {
+    repos.push(...discoverRepos(normalizedCodeRoot, 2));
+  }
+  if (repos.length === 0) {
+    throw withExit(`no Git repositories found under ${normalizedCwd}`, 3);
+  }
+  return pickFromList("Select repository", repos);
+}
+
+export async function pickRepoFromRoot(codeRoot, defaultRepo = "") {
+  const normalizedCodeRoot = path.resolve(codeRoot);
+  const repos = discoverRepos(normalizedCodeRoot, 3);
+  if (defaultRepo && !repos.includes(defaultRepo)) {
+    repos.unshift(defaultRepo);
+  }
+  if (repos.length === 0) {
+    throw withExit(`no Git repositories found under ${normalizedCodeRoot}`, 3);
+  }
+  return pickFromList("Select repository", repos, { defaultItem: defaultRepo });
+}
+
+export function currentBranch(repo) {
+  const result = tryCapture("git", ["branch", "--show-current"], { cwd: repo });
+  return result.ok ? result.stdout : "";
+}
+
+export function branchExists(repo, branch) {
+  if (!branch) {
+    return false;
+  }
+  const local = tryCapture("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], { cwd: repo });
+  if (local.ok) {
+    return true;
+  }
+  const remote = tryCapture("git", ["show-ref", "--verify", "--quiet", `refs/remotes/${branch}`], { cwd: repo });
+  if (remote.ok) {
+    return true;
+  }
+  const originRemote = tryCapture("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${branch}`], { cwd: repo });
+  return originRemote.ok;
+}
+
+export function listBranches(repo) {
+  const local = listRefs(repo, "refs/heads");
+  const remoteRaw = listRefs(repo, "refs/remotes").filter((name) => !name.endsWith("/HEAD"));
+  const remote = remoteRaw.map((name) => {
+    if (name.startsWith("origin/")) {
+      return name.slice("origin/".length);
+    }
+    return name;
+  });
+  return [...new Set([...local, ...remote])].sort();
+}
+
+export async function selectBranch(repo, requestedBranch, options = {}) {
+  const current = currentBranch(repo);
+  if (requestedBranch) {
+    const create = options.forceCreate || !branchExists(repo, requestedBranch);
+    return {
+      branch: requestedBranch,
+      create,
+      targetBranch: create ? current : ""
+    };
+  }
+
+  const branches = listBranches(repo).filter((branch) => branch !== current);
+  const createChoice = "Create new branch from current HEAD...";
+  const localChoice = "Open current checkout...";
+  const selected = await pickFromList("Select worktree", [createChoice, localChoice, ...branches], {
+    defaultItem: createChoice
+  });
+  if (selected === localChoice) {
+    return {
+      local: true
+    };
+  }
+  if (selected !== createChoice) {
+    return {
+      branch: selected,
+      create: false
+    };
+  }
+
+  const { askInput } = await import("./prompt.mjs");
+  const branch = await askInput("New branch");
+  if (!branch) {
+    throw withExit("branch is required", 4);
+  }
+  return {
+    branch,
+    create: true,
+    targetBranch: current
+  };
+}
+
+export function discoverRepos(root, maxDepth = 3) {
+  const repos = [];
+  walk(path.resolve(root), 0, maxDepth, repos);
+  return [...new Set(repos)].sort();
+}
+
+function walk(dir, depth, maxDepth, repos) {
+  if (depth > maxDepth) {
+    return;
+  }
+  if (hasGitDir(dir)) {
+    repos.push(dir);
+    return;
+  }
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) {
+      continue;
+    }
+    if (entry.name.startsWith(".") && entry.name !== ".config") {
+      continue;
+    }
+    walk(path.join(dir, entry.name), depth + 1, maxDepth, repos);
+  }
+}
+
+function hasGitDir(dir) {
+  return fs.existsSync(path.join(dir, ".git"));
+}
+
+function listRefs(repo, refPath) {
+  try {
+    const output = capture("git", ["for-each-ref", "--format=%(refname:short)", refPath], { cwd: repo });
+    return output ? output.split(/\r?\n/).filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+
+function isInside(child, parent) {
+  const relative = path.relative(parent, child);
+  return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function withExit(message, exitCode) {
+  const error = new Error(message);
+  error.exitCode = exitCode;
+  return error;
+}

package/src/hooks.mjs

@@ -0,0 +1,252 @@
+import fs from "node:fs";
+import path from "node:path";
+import { expandHome, parseToml } from "./config.mjs";
+import { quoteShell, runInherit, tryCapture } from "./run.mjs";
+
+const PROJECT_CONFIG = ".aiw.toml";
+
+export function workspaceHookPlan(config, event, context = {}) {
+  const repo = context.repo || context.cwd || process.cwd();
+  const cwd = context.cwd || repo;
+  const project = projectInfo(repo);
+  const sources = [
+    {
+      kind: "global",
+      path: config.aiwPath,
+      workspace: config.workspace || {}
+    },
+    ...globalProjectHookSources(config.workspace || {}, config.aiwPath, project),
+    projectHookSource(repo, config.aiwPath)
+  ].filter(Boolean);
+
+  const commands = [];
+  for (const source of sources) {
+    for (const command of hookCommands(source.workspace, event, source.path)) {
+      commands.push({
+        event,
+        command,
+        cwd,
+        source: source.kind,
+        configPath: source.path,
+        project,
+        rule: source.rule || ""
+      });
+    }
+  }
+  return commands;
+}
+
+export async function runWorkspaceHook(config, event, context = {}) {
+  const plan = workspaceHookPlan(config, event, context);
+  if (plan.length === 0) {
+    return;
+  }
+  if (context.dryRun) {
+    printWorkspaceHookPlan(plan);
+    return;
+  }
+  for (const item of plan) {
+    const label = item.rule ? `${item.source}/${item.rule}` : item.source;
+    console.log(`[aiw hook:${event}] ${label} ${item.command}`);
+    try {
+      await runInherit("sh", ["-lc", item.command], {
+        cwd: item.cwd,
+        env: hookEnv(item, context)
+      });
+    } catch (error) {
+      error.message = `workspace hook '${event}' failed from ${item.configPath}: ${error.message}`;
+      throw error;
+    }
+  }
+}
+
+export function printWorkspaceHookPlan(plan) {
+  for (const item of plan) {
+    const label = item.rule ? `${item.source}/${item.rule}` : item.source;
+    console.log(`# hook ${item.event} (${label}: ${item.configPath})`);
+    console.log(`cd ${quoteShell(item.cwd)} && sh -lc ${quoteShell(item.command)}`);
+  }
+}
+
+function globalProjectHookSources(workspace, configPath, project) {
+  const projects = workspace?.hooks?.projects;
+  if (projects === undefined) {
+    return [];
+  }
+  if (!projects || typeof projects !== "object" || Array.isArray(projects)) {
+    const error = new Error(`workspace hook projects in ${configPath} must be a table`);
+    error.exitCode = 2;
+    throw error;
+  }
+  return Object.entries(projects)
+    .filter(([name, entry]) => projectHookEntryMatches(name, entry, project, configPath))
+    .map(([name, entry]) => ({
+      kind: "global-project",
+      rule: name,
+      path: configPath,
+      workspace: entry
+    }));
+}
+
+function projectHookSource(repo, globalConfigPath) {
+  const configPath = path.join(repo, PROJECT_CONFIG);
+  if (configPath === globalConfigPath || !fs.existsSync(configPath)) {
+    return null;
+  }
+  const parsed = parseToml(fs.readFileSync(configPath, "utf8"));
+  return {
+    kind: "project",
+    path: configPath,
+    workspace: parsed.workspace || {}
+  };
+}
+
+function projectHookEntryMatches(name, entry, project, sourcePath) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+    const error = new Error(`workspace project hook entry in ${sourcePath} must be a table`);
+    error.exitCode = 2;
+    throw error;
+  }
+  const namePatterns = [
+    ...stringList(entry.match, "match", sourcePath),
+    ...stringList(entry.matches, "matches", sourcePath),
+    ...stringList(entry.project, "project", sourcePath),
+    ...stringList(entry.projects, "projects", sourcePath)
+  ];
+  const pathPatterns = [
+    ...stringList(entry.path, "path", sourcePath),
+    ...stringList(entry.paths, "paths", sourcePath),
+    ...stringList(entry.repo, "repo", sourcePath),
+    ...stringList(entry.repos, "repos", sourcePath)
+  ];
+  const effectiveNamePatterns = namePatterns.length > 0 ? namePatterns : [name];
+  return effectiveNamePatterns.some((pattern) => matchProjectPattern(pattern, project)) ||
+    pathPatterns.some((pattern) => matchProjectPath(pattern, project));
+}
+
+function hookCommands(workspace, event, sourcePath) {
+  const hooks = workspace?.hooks || {};
+  const raw = hooks[event] ?? workspace[event];
+  if (raw === undefined) {
+    return [];
+  }
+  if (typeof raw === "string") {
+    return raw.trim() ? [raw] : [];
+  }
+  if (Array.isArray(raw) && raw.every((item) => typeof item === "string")) {
+    return raw.map((item) => item.trim()).filter(Boolean);
+  }
+  const error = new Error(`workspace hook '${event}' in ${sourcePath} must be a string or an array of strings`);
+  error.exitCode = 2;
+  throw error;
+}
+
+function hookEnv(item, context) {
+  return {
+    ...process.env,
+    AIW_HOOK_EVENT: item.event,
+    AIW_HOOK_SOURCE: item.source,
+    AIW_HOOK_CONFIG: item.configPath,
+    AIW_HOOK_CWD: item.cwd,
+    AIW_HOOK_RULE: item.rule || "",
+    AIW_REPO: context.repo || "",
+    AIW_PROJECT_PATH: item.project.commonPath || item.project.currentPath || "",
+    AIW_PROJECT_NAME: item.project.commonName || item.project.currentName || "",
+    AIW_WORKSPACE_PATH: context.workspacePath || item.cwd,
+    AIW_WORKSPACE_BRANCH: context.branch || "",
+    AIW_WORKSPACE_TARGET: context.target || context.branch || context.workspacePath || "",
+    AIW_AGENT: context.agent || ""
+  };
+}
+
+function stringList(value, key, sourcePath) {
+  if (value === undefined) {
+    return [];
+  }
+  if (typeof value === "string") {
+    return value.trim() ? [value.trim()] : [];
+  }
+  if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+    return value.map((item) => item.trim()).filter(Boolean);
+  }
+  const error = new Error(`workspace project hook '${key}' in ${sourcePath} must be a string or an array of strings`);
+  error.exitCode = 2;
+  throw error;
+}
+
+function projectInfo(repo) {
+  const currentPath = normalizePath(repo);
+  const commonPath = gitCommonRoot(currentPath) || currentPath;
+  return {
+    currentPath,
+    currentName: path.basename(currentPath),
+    commonPath,
+    commonName: path.basename(commonPath)
+  };
+}
+
+function gitCommonRoot(repo) {
+  const result = tryCapture("git", ["rev-parse", "--git-common-dir"], { cwd: repo });
+  if (!result.ok || !result.stdout) {
+    return "";
+  }
+  const commonDir = normalizePath(path.isAbsolute(result.stdout)
+    ? result.stdout
+    : path.resolve(repo, result.stdout));
+  return path.basename(commonDir) === ".git" ? path.dirname(commonDir) : "";
+}
+
+function matchProjectPattern(pattern, project) {
+  const normalizedPattern = normalizeMaybePathPattern(pattern);
+  return projectIdentities(project).some((identity) => wildcardMatch(normalizedPattern, identity));
+}
+
+function matchProjectPath(pattern, project) {
+  const normalizedPattern = normalizeMaybePathPattern(pattern);
+  return [project.currentPath, project.commonPath].some((identity) => wildcardMatch(normalizedPattern, identity));
+}
+
+function projectIdentities(project) {
+  return [
+    project.currentName,
+    project.commonName,
+    project.currentPath,
+    project.commonPath
+  ].filter(Boolean);
+}
+
+function normalizeMaybePathPattern(pattern) {
+  const expanded = expandHome(pattern);
+  if (!looksLikePath(expanded)) {
+    return expanded;
+  }
+  if (expanded.includes("*")) {
+    return path.resolve(expanded);
+  }
+  return normalizePath(expanded);
+}
+
+function looksLikePath(value) {
+  return value === "~" || value.startsWith("~/") || value.startsWith("/") || value.startsWith(".");
+}
+
+function wildcardMatch(pattern, value) {
+  if (pattern === value) {
+    return true;
+  }
+  if (!pattern.includes("*")) {
+    return false;
+  }
+  const escaped = pattern.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`).test(value);
+}
+
+function normalizePath(value) {
+  const expanded = expandHome(value);
+  const resolved = path.resolve(expanded);
+  try {
+    return fs.realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}