chainlesschain 0.162.154 → 0.162.156

package/src/lib/agent-batch.js

@@ -0,0 +1,235 @@
+/**
+ * agent-batch — dynamic worktree batch core (gap-analysis 第四阶段 #4).
+ *
+ * Takes a large task already decomposed into independent UNITS and runs each in
+ * its OWN git worktree, in parallel (bounded concurrency), then aggregates the
+ * outcome: per-unit agent status, test result, diff stat, and — on integration
+ * — a merge-conflict preview against base. This is the `/batch` shape from
+ * Claude Code, built on the same worktree isolation `cc team --worktree` uses.
+ *
+ * Pure over injected deps (worktree lifecycle, agent/test spawns, git) so the
+ * whole fan-out + aggregation is unit-testable without a real repo or LLM.
+ *
+ * A `unit` is `{ key, prompt, test? }`. Concurrency is a simple worker pool.
+ * Integration is SEQUENTIAL (like TeamWorktreeCoordinator.integrate) so a later
+ * branch that conflicts with an already-merged one is reported, not clobbered.
+ */
+
+/** Run `items` through `worker` with at most `limit` in flight; preserves order. */
+async function mapPool(items, limit, worker) {
+  const results = new Array(items.length);
+  let next = 0;
+  const runners = new Array(Math.max(1, Math.min(limit, items.length)))
+    .fill(0)
+    .map(async () => {
+      while (true) {
+        const i = next++;
+        if (i >= items.length) return;
+        results[i] = await worker(items[i], i);
+      }
+    });
+  await Promise.all(runners);
+  return results;
+}
+
+function normalizeUnits(units) {
+  if (!Array.isArray(units) || units.length === 0) {
+    throw new Error("batch requires a non-empty `units` array");
+  }
+  const seen = new Set();
+  return units.map((u, i) => {
+    const key = String(u.key || `unit-${i + 1}`);
+    if (seen.has(key)) throw new Error(`duplicate unit key "${key}"`);
+    seen.add(key);
+    if (!u.prompt || typeof u.prompt !== "string") {
+      throw new Error(`unit "${key}" has no prompt`);
+    }
+    return { key, prompt: u.prompt, test: u.test || null };
+  });
+}
+
+/**
+ * @param {object} opts
+ * @param {Array<{key,prompt,test?}>} opts.units
+ * @param {number} [opts.concurrency=4]
+ * @param {string} [opts.test]         default test command for units without one
+ * @param {boolean} [opts.merge]       merge clean branches back to base
+ * @param {(msg:object)=>void} [opts.onEvent]  progress callback
+ * @param {object} deps  injected effectful ops (see command wiring)
+ * @returns {Promise<{units:Array, summary:object}>}
+ */
+export async function runBatch(opts, deps) {
+  const units = normalizeUnits(opts.units);
+  const concurrency = Math.max(1, Number(opts.concurrency) || 4);
+  const onEvent = opts.onEvent || (() => {});
+  const {
+    createWorktree,
+    removeWorktree,
+    runAgent,
+    runTest,
+    diffStat,
+    commit,
+    previewMerge,
+    mergeBranch,
+    branchFor = (key) => `batch/${key}`,
+  } = deps;
+
+  onEvent({ type: "batch:start", units: units.length, concurrency });
+
+  const results = await mapPool(units, concurrency, async (unit) => {
+    const branch = branchFor(unit.key);
+    const record = {
+      key: unit.key,
+      branch,
+      status: "pending",
+      filesChanged: 0,
+      insertions: 0,
+      deletions: 0,
+      testCommand: unit.test || opts.test || null,
+      testPassed: null,
+      committed: false,
+      error: null,
+    };
+    let worktreePath = null;
+    try {
+      worktreePath = createWorktree(unit.key, branch);
+      onEvent({ type: "unit:start", key: unit.key, branch });
+      await runAgent(unit.prompt, worktreePath);
+
+      const stat = diffStat(worktreePath);
+      record.filesChanged = stat.filesChanged;
+      record.insertions = stat.insertions;
+      record.deletions = stat.deletions;
+
+      const testCmd = unit.test || opts.test || null;
+      if (testCmd) {
+        try {
+          await runTest(testCmd, worktreePath);
+          record.testPassed = true;
+        } catch (err) {
+          record.testPassed = false;
+          record.testError = err.message;
+        }
+      }
+
+      if (stat.filesChanged > 0) {
+        record.committed = commit(worktreePath, `batch: ${unit.key}`);
+      }
+      // A unit whose tests FAILED is reported failed even though its worktree
+      // committed — integration below skips non-passing units so a red unit
+      // never merges into base.
+      record.status =
+        record.testPassed === false
+          ? "test-failed"
+          : record.filesChanged === 0
+            ? "no-changes"
+            : "done";
+    } catch (err) {
+      record.status = "error";
+      record.error = err.message;
+    }
+    onEvent({
+      type: "unit:done",
+      key: unit.key,
+      status: record.status,
+      testPassed: record.testPassed,
+      filesChanged: record.filesChanged,
+    });
+    return { record, worktreePath };
+  });
+
+  // Sequential integration: only units that DID change, committed, and did not
+  // fail tests are eligible. Preview each; merge clean ones when --merge.
+  for (const { record } of results) {
+    if (!record.committed || record.status === "test-failed") {
+      record.integration = { eligible: false, reason: record.status };
+      continue;
+    }
+    let preview;
+    try {
+      preview = previewMerge(record.branch);
+    } catch (err) {
+      record.integration = {
+        eligible: true,
+        clean: false,
+        merged: false,
+        conflicts: [],
+        error: err.message,
+      };
+      continue;
+    }
+    const clean = preview?.success === true;
+    const conflicts = preview?.conflicts || [];
+    let merged = false;
+    if (clean && opts.merge) {
+      let mergeResult;
+      try {
+        mergeResult = mergeBranch(record.branch, `Merge batch ${record.key}`);
+      } catch (err) {
+        mergeResult = { success: false, message: err.message };
+      }
+      merged = mergeResult?.success === true;
+      if (!merged && (!conflicts || conflicts.length === 0)) {
+        record.integration = {
+          eligible: true,
+          clean,
+          merged,
+          conflicts: mergeResult?.conflicts || [],
+          error: mergeResult?.message || null,
+        };
+        continue;
+      }
+    }
+    record.integration = { eligible: true, clean, merged, conflicts };
+    onEvent({
+      type: "unit:integrated",
+      key: record.key,
+      clean,
+      merged,
+      conflicts: conflicts.length,
+    });
+  }
+
+  // Best-effort teardown of every worktree we created (branches persist for the
+  // user to inspect/merge later unless already merged).
+  if (typeof removeWorktree === "function") {
+    for (const { record, worktreePath } of results) {
+      if (!worktreePath) continue;
+      try {
+        removeWorktree(worktreePath, {
+          deleteBranch: record.integration?.merged === true,
+        });
+      } catch {
+        // best-effort — a leftover worktree is recoverable via `git worktree`
+      }
+    }
+  }
+
+  const records = results.map((r) => r.record);
+  const summary = summarize(records);
+  onEvent({ type: "batch:done", ...summary });
+  return { units: records, summary };
+}
+
+function summarize(records) {
+  const summary = {
+    total: records.length,
+    done: 0,
+    testFailed: 0,
+    noChanges: 0,
+    errored: 0,
+    merged: 0,
+    conflicted: 0,
+  };
+  for (const r of records) {
+    if (r.status === "done") summary.done += 1;
+    else if (r.status === "test-failed") summary.testFailed += 1;
+    else if (r.status === "no-changes") summary.noChanges += 1;
+    else if (r.status === "error") summary.errored += 1;
+    if (r.integration?.merged) summary.merged += 1;
+    if (r.integration?.conflicts?.length) summary.conflicted += 1;
+  }
+  return summary;
+}
+
+export const _internal = { mapPool, normalizeUnits, summarize };

package/src/lib/agent-notify.js

@@ -0,0 +1,66 @@
+/**
+ * agent-notify — shared backing for the `notify` agent tool + `cc agenda`
+ * monitor firing (gap-analysis 第四阶段 #3).
+ *
+ * Fans a notification out over the user's configured multi-channel notifiers
+ * (Telegram / WeCom / DingTalk / Feishu, via NotificationManager.fromEnv) and,
+ * when a paired-device push descriptor exists, the mobile push bridge. Pure
+ * over injected deps so it is unit-testable without any network.
+ */
+
+import { NotificationManager } from "./notifiers/index.js";
+
+/**
+ * @param {{title:string, body?:string, level?:"info"|"success"|"failure"}} msg
+ * @param {{env?:object, manager?:object}} [deps]
+ * @returns {Promise<{delivered:string[], failed:string[], channels:number, results:Array}>}
+ */
+export async function sendAgentNotification(msg, deps = {}) {
+  const title = String(msg?.title || "").trim();
+  if (!title) throw new Error("notify requires a title");
+  const body = msg?.body ? String(msg.body) : "";
+  const level = ["info", "success", "failure"].includes(msg?.level)
+    ? msg.level
+    : "info";
+
+  const manager =
+    deps.manager ||
+    NotificationManager.fromEnv({ env: deps.env || process.env });
+  if (!manager.isConfigured) {
+    return {
+      delivered: [],
+      failed: [],
+      channels: 0,
+      results: [],
+      note: "No notification channels configured (set TELEGRAM_BOT_TOKEN / WECOM_WEBHOOK_URL / DINGTALK_WEBHOOK_URL / FEISHU_WEBHOOK_URL).",
+    };
+  }
+
+  const summary = {
+    taskId: msg?.taskId || null,
+    description: title,
+    detail: body,
+    message: body || title,
+    title,
+  };
+  const method =
+    level === "success"
+      ? "notifySuccess"
+      : level === "failure"
+        ? "notifyFailure"
+        : "notifyStart";
+  const results = await manager[method](summary);
+
+  const delivered = [];
+  const failed = [];
+  for (const r of results || []) {
+    if (r && r.ok !== false) delivered.push(r.channel);
+    else failed.push(r?.channel || "unknown");
+  }
+  return {
+    delivered,
+    failed,
+    channels: (manager.activeChannels || []).length,
+    results: results || [],
+  };
+}

package/src/lib/agent-schedule-store.js

@@ -0,0 +1,330 @@
+/**
+ * AgentScheduleStore — persistent backing for the agent-callable Monitor /
+ * Cron / Wakeup tools (gap-analysis 第四阶段 #3).
+ *
+ * A one-shot `cc agent` turn cannot itself keep a timer alive, so these tools
+ * PERSIST their intent to a JSONL store under
+ * `~/.chainlesschain/agent-schedule/<kind>.jsonl`; a supervising loop / cron
+ * (`cc agenda run`) reads due entries and acts. This mirrors how Claude Code's
+ * Monitor/CronCreate/ScheduleWakeup outlive a single turn.
+ *
+ * Three entry kinds share one store:
+ *   - wakeup   one-shot: run `prompt` (a `cc agent -p`) once at/after `dueAt`.
+ *   - cron     recurring: run `prompt` on a cron schedule; `nextAt` advances.
+ *   - monitor  recurring watch: run `command` (shell) every `intervalMs`;
+ *              fire the `notify` payload when `stopWhen` regex matches output.
+ *
+ * Pure over an injected clock + directory so it is fully unit-testable. Cron
+ * parsing is a compact 5-field evaluator (min hour dom mon dow) supporting
+ * `* , - /` — enough for the scheduling the agent actually asks for.
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { randomUUID } from "crypto";
+
+export const SCHEDULE_KINDS = Object.freeze(["wakeup", "cron", "monitor"]);
+
+export function agentScheduleDir(homedir = os.homedir()) {
+  return path.join(homedir, ".chainlesschain", "agent-schedule");
+}
+
+// ─── cron (5-field) ────────────────────────────────────────────────────────
+
+const CRON_RANGES = [
+  [0, 59], // minute
+  [0, 23], // hour
+  [1, 31], // day of month
+  [1, 12], // month
+  [0, 6], // day of week (0/7 = Sunday)
+];
+
+function parseCronField(field, [min, max]) {
+  const values = new Set();
+  for (const part of String(field).split(",")) {
+    const [rangePart, stepPart] = part.split("/");
+    const step = stepPart ? parseInt(stepPart, 10) : 1;
+    if (!Number.isFinite(step) || step < 1) {
+      throw new Error(`invalid cron step in "${field}"`);
+    }
+    let lo = min;
+    let hi = max;
+    if (rangePart !== "*" && rangePart !== "") {
+      const bounds = rangePart.split("-");
+      lo = parseInt(bounds[0], 10);
+      hi = bounds.length > 1 ? parseInt(bounds[1], 10) : lo;
+      if (!Number.isFinite(lo) || !Number.isFinite(hi)) {
+        throw new Error(`invalid cron range in "${field}"`);
+      }
+    }
+    for (let v = lo; v <= hi; v += step) {
+      if (v < min || v > max) throw new Error(`cron value out of range: ${v}`);
+      values.add(v);
+    }
+  }
+  return values;
+}
+
+/** Parse a 5-field cron expression into per-field value sets. Throws on junk. */
+export function parseCron(expr) {
+  const fields = String(expr).trim().split(/\s+/);
+  if (fields.length !== 5) {
+    throw new Error(
+      `cron expression must have 5 fields (min hour dom mon dow), got ${fields.length}`,
+    );
+  }
+  return fields.map((field, i) => parseCronField(field, CRON_RANGES[i]));
+}
+
+function cronMatches(sets, date) {
+  const dow = date.getDay(); // 0-6, Sun=0
+  return (
+    sets[0].has(date.getMinutes()) &&
+    sets[1].has(date.getHours()) &&
+    sets[2].has(date.getDate()) &&
+    sets[3].has(date.getMonth() + 1) &&
+    (sets[4].has(dow) || (sets[4].has(7) && dow === 0))
+  );
+}
+
+/**
+ * Next epoch-ms at which `expr` fires strictly after `fromMs` (local time,
+ * minute granularity). Scans up to ~366 days then gives up (returns null) so a
+ * never-matching expression can't loop forever.
+ */
+export function nextCronTime(expr, fromMs) {
+  const sets = parseCron(expr);
+  const cursor = new Date(fromMs);
+  cursor.setSeconds(0, 0);
+  cursor.setMinutes(cursor.getMinutes() + 1);
+  const limit = 366 * 24 * 60;
+  for (let i = 0; i < limit; i += 1) {
+    if (cronMatches(sets, cursor)) return cursor.getTime();
+    cursor.setMinutes(cursor.getMinutes() + 1);
+  }
+  return null;
+}
+
+// ─── store ───────────────────────────────────────────────────────────────
+
+export class AgentScheduleStore {
+  constructor({ dir = null, now = () => Date.now() } = {}) {
+    this.dir = dir || agentScheduleDir();
+    this._now = typeof now === "function" ? now : () => now;
+  }
+
+  _file(kind) {
+    return path.join(this.dir, `${kind}.jsonl`);
+  }
+
+  _ensureDir() {
+    fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+  }
+
+  _readAll(kind) {
+    let raw;
+    try {
+      raw = fs.readFileSync(this._file(kind), "utf-8");
+    } catch {
+      return [];
+    }
+    const entries = [];
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        entries.push(JSON.parse(trimmed));
+      } catch {
+        // Skip a corrupt line rather than throwing — one bad append must not
+        // poison the whole store (per-row resilience, like the JSON.parse sweep).
+      }
+    }
+    return entries;
+  }
+
+  _writeAll(kind, entries) {
+    this._ensureDir();
+    const body = entries.map((entry) => JSON.stringify(entry)).join("\n");
+    fs.writeFileSync(this._file(kind), body ? body + "\n" : "", {
+      encoding: "utf-8",
+      mode: 0o600,
+    });
+  }
+
+  // ── create ──────────────────────────────────────────────────────────────
+
+  scheduleWakeup({ prompt, delayMs = 0, dueAt = null, label = null } = {}) {
+    if (!prompt || typeof prompt !== "string") {
+      throw new Error("wakeup requires a prompt");
+    }
+    const now = this._now();
+    const entry = {
+      id: randomUUID(),
+      kind: "wakeup",
+      prompt,
+      label: label || null,
+      dueAt:
+        dueAt != null ? Number(dueAt) : now + Math.max(0, Number(delayMs) || 0),
+      createdAt: now,
+      status: "pending",
+    };
+    const entries = this._readAll("wakeup");
+    entries.push(entry);
+    this._writeAll("wakeup", entries);
+    return entry;
+  }
+
+  createCron({ prompt, cron, label = null } = {}) {
+    if (!prompt || typeof prompt !== "string") {
+      throw new Error("cron requires a prompt");
+    }
+    const now = this._now();
+    const nextAt = nextCronTime(cron, now); // validates the expression too
+    if (nextAt == null) {
+      throw new Error(`cron "${cron}" has no upcoming match`);
+    }
+    const entry = {
+      id: randomUUID(),
+      kind: "cron",
+      prompt,
+      cron,
+      label: label || null,
+      nextAt,
+      createdAt: now,
+      lastRunAt: null,
+      runs: 0,
+      status: "active",
+    };
+    const entries = this._readAll("cron");
+    entries.push(entry);
+    this._writeAll("cron", entries);
+    return entry;
+  }
+
+  createMonitor({
+    command,
+    intervalMs,
+    stopWhen = null,
+    notify = null,
+    maxChecks = null,
+    label = null,
+  } = {}) {
+    if (!command || typeof command !== "string") {
+      throw new Error("monitor requires a command");
+    }
+    const interval = Math.max(1000, Number(intervalMs) || 60000);
+    if (stopWhen != null) {
+      // Validate the regex up-front so a bad pattern errors at creation, not
+      // silently at the first check.
+      // eslint-disable-next-line no-new
+      new RegExp(stopWhen);
+    }
+    const now = this._now();
+    const entry = {
+      id: randomUUID(),
+      kind: "monitor",
+      command,
+      intervalMs: interval,
+      stopWhen: stopWhen || null,
+      notify: notify || null,
+      maxChecks: maxChecks != null ? Number(maxChecks) : null,
+      label: label || null,
+      nextAt: now + interval,
+      createdAt: now,
+      checks: 0,
+      status: "active",
+    };
+    const entries = this._readAll("monitor");
+    entries.push(entry);
+    this._writeAll("monitor", entries);
+    return entry;
+  }
+
+  // ── query ─────────────────────────────────────────────────────────────────
+
+  list(kind = null) {
+    const kinds = kind ? [kind] : SCHEDULE_KINDS;
+    const out = [];
+    for (const k of kinds) out.push(...this._readAll(k));
+    return out;
+  }
+
+  /** Entries whose time has come (pending wakeup / active cron|monitor). */
+  due(kind = null, atMs = null) {
+    const now = atMs != null ? atMs : this._now();
+    return this.list(kind).filter((entry) => {
+      if (entry.kind === "wakeup") {
+        return entry.status === "pending" && entry.dueAt <= now;
+      }
+      return entry.status === "active" && entry.nextAt <= now;
+    });
+  }
+
+  cancel(id) {
+    for (const kind of SCHEDULE_KINDS) {
+      const entries = this._readAll(kind);
+      const idx = entries.findIndex((entry) => entry.id === id);
+      if (idx >= 0) {
+        const [removed] = entries.splice(idx, 1);
+        this._writeAll(kind, entries);
+        return removed;
+      }
+    }
+    return null;
+  }
+
+  // ── lifecycle mutations (used by `cc agenda run`) ──────────────────────────
+
+  /** Mark a one-shot wakeup fired (keeps history; due() skips it). */
+  markWakeupFired(id, atMs = null) {
+    return this._mutate("wakeup", id, (entry) => {
+      entry.status = "fired";
+      entry.firedAt = atMs != null ? atMs : this._now();
+    });
+  }
+
+  /** Advance a cron entry to its next fire time after running once. */
+  advanceCron(id, atMs = null) {
+    const now = atMs != null ? atMs : this._now();
+    return this._mutate("cron", id, (entry) => {
+      entry.lastRunAt = now;
+      entry.runs = (entry.runs || 0) + 1;
+      const next = nextCronTime(entry.cron, now);
+      if (next == null) {
+        entry.status = "exhausted";
+      } else {
+        entry.nextAt = next;
+      }
+    });
+  }
+
+  /**
+   * Record a monitor check. `matched` ends the monitor (done); otherwise it is
+   * re-armed for the next interval, or exhausted once maxChecks is hit.
+   */
+  recordMonitorCheck(id, { matched = false, atMs = null } = {}) {
+    const now = atMs != null ? atMs : this._now();
+    return this._mutate("monitor", id, (entry) => {
+      entry.checks = (entry.checks || 0) + 1;
+      entry.lastCheckAt = now;
+      if (matched) {
+        entry.status = "matched";
+        entry.matchedAt = now;
+      } else if (entry.maxChecks != null && entry.checks >= entry.maxChecks) {
+        entry.status = "exhausted";
+      } else {
+        entry.nextAt = now + entry.intervalMs;
+      }
+    });
+  }
+
+  _mutate(kind, id, fn) {
+    const entries = this._readAll(kind);
+    const entry = entries.find((e) => e.id === id);
+    if (!entry) return null;
+    fn(entry);
+    this._writeAll(kind, entries);
+    return entry;
+  }
+}