agent-work-loop 0.0.0 → 0.6.22

package/dist/chunk-VU6IPRRM.js

@@ -0,0 +1,166 @@
+import {
+  npmVersionCachePath
+} from "./chunk-7SYRDDTX.js";
+
+// package.json
+var name = "agent-work-loop";
+var version = "0.6.22";
+
+// src/core/npm-registry.ts
+import fs from "fs";
+import path from "path";
+var REGISTRY_URL = "https://registry.npmjs.org";
+var FETCH_TIMEOUT_MS = 2e3;
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+async function fetchLatestVersion(packageName, fetchImpl = fetch) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetchImpl(`${REGISTRY_URL}/${packageName}/latest`, {
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      return null;
+    }
+    const body = await res.json();
+    if (body && typeof body === "object") {
+      const v = body.version;
+      if (typeof v === "string") {
+        return v;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function readCache() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(npmVersionCachePath(), "utf8"));
+    if (raw && typeof raw === "object") {
+      const checkedAt = raw.checkedAt;
+      const latestVersion = raw.latestVersion;
+      if (typeof checkedAt === "string" && (typeof latestVersion === "string" || latestVersion === null)) {
+        return { checkedAt, latestVersion };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function writeCache(cache) {
+  const p = npmVersionCachePath();
+  const tmp = `${p}.${process.pid}.tmp`;
+  try {
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(tmp, JSON.stringify(cache));
+    fs.renameSync(tmp, p);
+  } catch {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {
+    }
+  }
+}
+async function getLatestVersionCached(packageName, opts = {}) {
+  const now = opts.now ?? (() => Date.now());
+  const ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+  const cached = readCache();
+  if (cached && now() - new Date(cached.checkedAt).getTime() < ttlMs) {
+    return cached.latestVersion;
+  }
+  const latestVersion = await fetchLatestVersion(packageName, opts.fetchImpl ?? fetch);
+  writeCache({ checkedAt: new Date(now()).toISOString(), latestVersion });
+  return latestVersion;
+}
+function readCachedLatestVersion() {
+  return readCache()?.latestVersion ?? null;
+}
+
+// src/core/versions.ts
+var UPDATE_HINT = "npm i -g agent-work-loop@latest \uB85C \uAC31\uC2E0\uD558\uC138\uC694.";
+function parseSemver(version2) {
+  const m = /^(\d+)\.(\d+)\.(\d+)/.exec(version2);
+  if (!m) {
+    return null;
+  }
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+function isNewerSemver(a, b) {
+  if (a[0] !== b[0]) return a[0] > b[0];
+  if (a[1] !== b[1]) return a[1] > b[1];
+  if (a[2] !== b[2]) return a[2] > b[2];
+  return false;
+}
+function computeUpdateAvailable(current, npmLatestVersion) {
+  if (npmLatestVersion === null) {
+    return void 0;
+  }
+  const latestParsed = parseSemver(npmLatestVersion);
+  const currentParsed = parseSemver(current);
+  if (latestParsed === null || currentParsed === null) {
+    return void 0;
+  }
+  if (!isNewerSemver(latestParsed, currentParsed)) {
+    return void 0;
+  }
+  return { current, latest: npmLatestVersion, hint: UPDATE_HINT };
+}
+var SKILL_LABELS = {
+  claude: "Claude",
+  codex: "Codex"
+};
+function checkVersions(inputs) {
+  const mismatches = [];
+  if (inputs.engineSourceVersion !== null && inputs.engineSourceVersion !== inputs.packageVersion) {
+    mismatches.push({
+      kind: "build",
+      a: inputs.packageVersion,
+      b: inputs.engineSourceVersion,
+      hint: "package.json \uACFC engine/version.json \uBC84\uC804\uC774 \uB2E4\uB985\uB2C8\uB2E4 \u2014 \uC124\uCE58\uAC00 \uC190\uC0C1\uB410\uC744 \uC218 \uC788\uC2B5\uB2C8\uB2E4. \uC7AC\uC124\uCE58\uD558\uC138\uC694."
+    });
+  }
+  if (inputs.installedEngineVersion !== null && inputs.installedEngineVersion !== inputs.packageVersion) {
+    mismatches.push({
+      kind: "binary-vs-engine",
+      a: inputs.packageVersion,
+      b: inputs.installedEngineVersion,
+      hint: "\uC124\uCE58\uB41C \uC5D4\uC9C4(~/.awl/engine)\uC774 \uC2E4\uD589 \uBC14\uC774\uB108\uB9AC\uC640 \uB2E4\uB985\uB2C8\uB2E4. awl update \uB85C \uC5D4\uC9C4\uC744 \uAC31\uC2E0\uD558\uC138\uC694."
+    });
+  }
+  if (inputs.projectEngineVersion !== null && inputs.installedEngineVersion !== null && inputs.projectEngineVersion !== inputs.installedEngineVersion) {
+    mismatches.push({
+      kind: "project-vs-engine",
+      a: inputs.projectEngineVersion,
+      b: inputs.installedEngineVersion,
+      hint: `\uC774 \uD504\uB85C\uC81D\uD2B8\uB294 ${inputs.projectEngineVersion} \uAE30\uC900\uC73C\uB85C \uC124\uC815\uB410\uC73C\uB098 \uC5D4\uC9C4\uC740 ${inputs.installedEngineVersion}\uC785\uB2C8\uB2E4. awl init --yes \uB85C \uD504\uB85C\uC81D\uD2B8\xB7\uC2A4\uD0AC \uBC84\uC804\uC744 \uC5D4\uC9C4\uC5D0 \uB9DE\uCDB0 \uB3D9\uAE30\uD654\uD558\uC138\uC694.`
+    });
+  }
+  for (const skill of ["claude", "codex"]) {
+    const skillVersion = inputs.installedSkillVersions[skill];
+    if (skillVersion !== null && inputs.installedEngineVersion !== null && skillVersion !== inputs.installedEngineVersion) {
+      mismatches.push({
+        kind: `${skill}-skill-vs-engine`,
+        a: skillVersion,
+        b: inputs.installedEngineVersion,
+        hint: `\uC124\uCE58\uB41C ${SKILL_LABELS[skill]} \uC2A4\uD0AC\uC774 ${skillVersion} \uAE30\uC900\uC785\uB2C8\uB2E4. \uC5D4\uC9C4\uC740 ${inputs.installedEngineVersion}\uC785\uB2C8\uB2E4. awl init --yes \uB85C \uC2A4\uD0AC\uC744 \uC7AC\uC124\uCE58\xB7\uB3D9\uAE30\uD654\uD558\uC138\uC694.`
+      });
+    }
+  }
+  return {
+    ok: mismatches.length === 0,
+    mismatches,
+    updateAvailable: computeUpdateAvailable(inputs.packageVersion, inputs.npmLatestVersion)
+  };
+}
+
+export {
+  name,
+  version,
+  getLatestVersionCached,
+  readCachedLatestVersion,
+  computeUpdateAvailable,
+  checkVersions
+};

package/dist/chunk-X5LMP5J7.js

@@ -0,0 +1,307 @@
+import {
+  mergeIsolatedHome,
+  removeGitWorktree,
+  removeWorkitemFromState,
+  runWorkNew,
+  sanitizeForGit,
+  worktreeDirtyTracked
+} from "./chunk-LMWAVN7B.js";
+import {
+  loadState,
+  writeState
+} from "./chunk-4OCSYHYB.js";
+import {
+  resolveProjectRoot,
+  run
+} from "./chunk-UOPWVM2H.js";
+import {
+  caps,
+  card,
+  feedback,
+  makeColors,
+  signal
+} from "./chunk-7SYRDDTX.js";
+
+// src/commands/lane.ts
+import fs from "fs";
+import path from "path";
+var WORKTREES_DIR = ".awl-worktrees";
+var PIPELINE_TRIGGERS = ["/awl-pipeline-plan", "/awl-pipeline-exec", "/awl-pipeline-review"];
+function requireRoot() {
+  const root = resolveProjectRoot();
+  if (!root) {
+    process.stderr.write("\n  \uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. awl init \uC744 \uC2E4\uD589\uD558\uC138\uC694.\n");
+    process.exit(1);
+  }
+  return root;
+}
+async function isGitWorkTree(root) {
+  const r = await run({
+    cmd: "git",
+    args: ["rev-parse", "--is-inside-work-tree"],
+    cwd: root,
+    timeoutMs: 1e4
+  });
+  return r.exitCode === 0 && r.stdout.trim() === "true";
+}
+async function runLaneNew(name, description) {
+  const root = requireRoot();
+  const c = caps();
+  const color = makeColors(c.color);
+  if (!await isGitWorkTree(root)) {
+    process.stderr.write(
+      `
+${feedback(c, "error", "\uB808\uC778\uC744 \uB9CC\uB4E4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4", "\uD604\uC7AC \uC704\uCE58\uAC00 git \uC800\uC7A5\uC18C\uAC00 \uC544\uB2D9\uB2C8\uB2E4 \u2014 awl lane \uC740 git worktree \uB97C \uC501\uB2C8\uB2E4")}
+`
+    );
+    process.exit(1);
+  }
+  const laneName = sanitizeForGit(name);
+  if (!laneName) {
+    process.stderr.write(`
+${feedback(c, "error", "\uB808\uC778 \uC774\uB984\uC744 \uC785\uB825\uD558\uC138\uC694")}
+`);
+    process.exit(1);
+  }
+  const lanePath = path.join(root, WORKTREES_DIR, laneName);
+  if (fs.existsSync(lanePath)) {
+    process.stderr.write(
+      `
+${feedback(c, "error", `\uC774\uBBF8 \uC874\uC7AC\uD558\uB294 \uB808\uC778\uC785\uB2C8\uB2E4: ${laneName}`, `awl lane rm ${laneName} \uB85C \uBA3C\uC800 \uC815\uB9AC\uD558\uC138\uC694`)}
+`
+    );
+    process.exit(1);
+  }
+  await runWorkNew(name, description, { worktree: true, isolated: true });
+  process.stdout.write(`
+${feedback(c, "ok", `\uB808\uC778 \uC900\uBE44  ${color.bold(laneName)}`)}
+`);
+  process.stdout.write(`    ${color.dim("\uC774 \uB808\uC778\uC758 \uC5ED\uD560 \uC138\uC158\uC5D0\uC11C \uC2A4\uD0AC \uD2B8\uB9AC\uAC70\uB97C \uC2E4\uD589\uD558\uC138\uC694:")}
+`);
+  for (const t of PIPELINE_TRIGGERS) {
+    process.stdout.write(`      ${color.dim(t)}
+`);
+  }
+}
+function parseWorktreeBranches(porcelain) {
+  const map = /* @__PURE__ */ new Map();
+  let current = null;
+  for (const raw of porcelain.split("\n")) {
+    const line = raw.trim();
+    if (line.startsWith("worktree ")) {
+      current = line.slice("worktree ".length);
+    } else if (line.startsWith("branch ") && current) {
+      map.set(current, line.slice("branch ".length).replace(/^refs\/heads\//, ""));
+    } else if (line === "") {
+      current = null;
+    }
+  }
+  return map;
+}
+async function laneBranchMap(root) {
+  const r = await run({
+    cmd: "git",
+    args: ["worktree", "list", "--porcelain"],
+    cwd: root,
+    timeoutMs: 1e4
+  });
+  if (r.exitCode !== 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  return parseWorktreeBranches(r.stdout);
+}
+async function unmergedCommitCount(root, branch) {
+  const r = await run({
+    cmd: "git",
+    args: ["rev-list", "--count", `HEAD..${branch}`],
+    cwd: root,
+    timeoutMs: 1e4
+  });
+  if (r.exitCode !== 0) {
+    return null;
+  }
+  const n = Number.parseInt(r.stdout.trim(), 10);
+  return Number.isNaN(n) ? null : n;
+}
+var AWL_INTERNAL_DIRS = /* @__PURE__ */ new Set([".awl", ".awl-worktrees", ".claude"]);
+async function worktreeUntracked(root, targetPath) {
+  const r = await run({
+    cmd: "git",
+    args: ["-C", targetPath, "ls-files", "--others", "--exclude-standard"],
+    cwd: root,
+    timeoutMs: 1e4
+  });
+  const files = r.stdout.split("\n").map((l) => l.trim()).filter(Boolean).filter((f) => !AWL_INTERNAL_DIRS.has(f.split("/")[0] ?? ""));
+  return { untracked: files.length > 0, count: files.length, first: files[0] };
+}
+function branchOf(branches, lanePath) {
+  const direct = branches.get(lanePath);
+  if (direct) {
+    return direct;
+  }
+  try {
+    return branches.get(fs.realpathSync(lanePath));
+  } catch {
+    return void 0;
+  }
+}
+async function collectLanes(root) {
+  const base = path.join(root, WORKTREES_DIR);
+  let entries;
+  try {
+    entries = fs.readdirSync(base, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const branches = await laneBranchMap(root);
+  const lanes = [];
+  for (const e of entries) {
+    if (!e.isDirectory()) {
+      continue;
+    }
+    const p = path.join(base, e.name);
+    lanes.push({ name: e.name, path: p, branch: branchOf(branches, p) ?? "(detached)" });
+  }
+  lanes.sort((a, b) => a.name.localeCompare(b.name));
+  return lanes;
+}
+function renderLaneList(lanes, c) {
+  const color = makeColors(c.color);
+  if (lanes.length === 0) {
+    return card(
+      "\uB808\uC778",
+      [
+        `${signal(c, "info")} \uB808\uC778\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.`,
+        "",
+        color.dim("awl lane new <name> \uB85C \uACA9\uB9AC \uB808\uC778\uC744 \uB9CC\uB4DC\uC138\uC694.")
+      ],
+      c
+    );
+  }
+  const nameWidth = Math.max(...lanes.map((l) => l.name.length), 4) + 2;
+  const out = [];
+  for (const l of lanes) {
+    out.push(`${color.bold(l.name.padEnd(nameWidth, " "))}${color.dim(l.branch)}`);
+    out.push(`  ${color.dim(l.path)}`);
+  }
+  return card("\uB808\uC778", out, c);
+}
+async function runLaneList(opts) {
+  const root = requireRoot();
+  const lanes = await collectLanes(root);
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(lanes, null, 2)}
+`);
+  } else {
+    process.stdout.write(`${renderLaneList(lanes, caps())}
+`);
+  }
+}
+async function runLaneRemove(name, opts = {}) {
+  const root = requireRoot();
+  const c = caps();
+  const color = makeColors(c.color);
+  const laneName = sanitizeForGit(name);
+  if (!laneName) {
+    process.stderr.write(`
+${feedback(c, "error", "\uB808\uC778 \uC774\uB984\uC744 \uC785\uB825\uD558\uC138\uC694")}
+`);
+    process.exit(1);
+  }
+  const lanePath = path.join(root, WORKTREES_DIR, laneName);
+  if (!fs.existsSync(lanePath)) {
+    process.stderr.write(
+      `
+${feedback(c, "error", `\uB808\uC778\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${laneName}`, "awl lane ls \uB85C \uD604\uC874 \uB808\uC778\uC744 \uD655\uC778\uD558\uC138\uC694")}
+`
+    );
+    process.exit(1);
+  }
+  const branches = await laneBranchMap(root);
+  const branch = branchOf(branches, lanePath) ?? `work/${laneName}`;
+  if (!opts.force) {
+    const d = await worktreeDirtyTracked(root, lanePath);
+    if (d.dirty) {
+      process.stderr.write(
+        `
+${feedback(c, "error", `\uB808\uC778\uC5D0 \uCEE4\uBC0B\uB418\uC9C0 \uC54A\uC740 \uBCC0\uACBD ${d.count}\uAC74 (\uC608: ${d.first})`, "--force \uB85C \uAC15\uC81C \uC81C\uAC70\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4")}
+`
+      );
+      process.exit(1);
+    }
+    const u = await worktreeUntracked(root, lanePath);
+    if (u.untracked) {
+      process.stderr.write(
+        `
+${feedback(c, "error", `\uB808\uC778\uC5D0 \uCEE4\uBC0B\uB418\uC9C0 \uC54A\uC740 \uC0C8 \uD30C\uC77C ${u.count}\uAC74 (\uC608: ${u.first})`, "git add\xB7\uCEE4\uBC0B\uD558\uAC70\uB098 --force \uB85C \uAC15\uC81C \uC81C\uAC70\uD558\uC138\uC694")}
+`
+      );
+      process.exit(1);
+    }
+    const unmerged = await unmergedCommitCount(root, branch);
+    if (unmerged === null) {
+      process.stderr.write(
+        `
+${feedback(c, "error", `\uB808\uC778 \uBE0C\uB79C\uCE58 ${branch} \uC758 \uBBF8\uBA38\uC9C0 \uCEE4\uBC0B \uC218\uB97C \uD655\uC778\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 (rm \uD558\uBA74 \uCEE4\uBC0B\uC774 \uD30C\uAE30\uB420 \uC218 \uC788\uC2B5\uB2C8\uB2E4)`, "\uBA3C\uC800 \uBE0C\uB79C\uCE58\uB97C \uD655\uC778\uD558\uAC70\uB098 --force \uB85C \uAC15\uC81C \uC81C\uAC70\uD558\uC138\uC694")}
+`
+      );
+      process.exit(1);
+    }
+    if (unmerged > 0) {
+      process.stderr.write(
+        `
+${feedback(c, "error", `\uB808\uC778 \uBE0C\uB79C\uCE58 ${branch} \uC5D0 \uBCD1\uD569\uB418\uC9C0 \uC54A\uC740 \uCEE4\uBC0B ${unmerged}\uAC1C (rm \uD558\uBA74 \uD30C\uAE30\uB429\uB2C8\uB2E4)`, "\uBA3C\uC800 \uBCD1\uD569\xB7\uD478\uC2DC\uD558\uAC70\uB098 --force \uB85C \uAC15\uC81C \uC81C\uAC70\uD558\uC138\uC694")}
+`
+      );
+      process.exit(1);
+    }
+  }
+  let merged = null;
+  try {
+    merged = mergeIsolatedHome(path.join(lanePath, ".awl", "home"));
+  } catch (e) {
+    process.stderr.write(
+      `
+${feedback(c, "error", "\uACA9\uB9AC \uD559\uC2B5 \uC804\uC5ED \uBCD1\uD569 \uC2E4\uD328 \u2014 \uB808\uC778\uC744 \uBCF4\uC874\uD569\uB2C8\uB2E4", e instanceof Error ? e.message : String(e))}
+`
+    );
+    process.exit(1);
+  }
+  const removed = await removeGitWorktree(root, lanePath, branch);
+  if (!removed.ok) {
+    process.stderr.write(`
+${feedback(c, "error", "\uB808\uC778 \uC81C\uAC70 \uC2E4\uD328", removed.error ?? "")}
+`);
+    process.exit(1);
+  }
+  if (fs.existsSync(lanePath)) {
+    fs.rmSync(lanePath, { recursive: true, force: true });
+  }
+  const cleaned = removeWorkitemFromState(loadState(root), [name.trim(), laneName]);
+  if (cleaned.removed) {
+    writeState(root, cleaned.state);
+  }
+  process.stdout.write(`
+${feedback(c, "ok", `\uB808\uC778 \uC81C\uAC70  ${color.bold(laneName)}`, branch)}
+`);
+  if (merged && (merged.gotchasAdded > 0 || merged.rulesAdded > 0 || merged.generationsAdded > 0)) {
+    process.stdout.write(
+      `    ${color.dim(`\uD559\uC2B5 \uC804\uC5ED \uBCD1\uD569  gotcha ${merged.gotchasAdded} \xB7 rule ${merged.rulesAdded} \xB7 generation ${merged.generationsAdded}`)}
+`
+    );
+  }
+}
+
+export {
+  WORKTREES_DIR,
+  runLaneNew,
+  parseWorktreeBranches,
+  laneBranchMap,
+  unmergedCommitCount,
+  worktreeUntracked,
+  branchOf,
+  collectLanes,
+  renderLaneList,
+  runLaneList,
+  runLaneRemove
+};