u-foo 1.0.3 → 1.1.9

package/src/context/sync.js

@@ -0,0 +1,127 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Sync log manager
+ * Stores lightweight agent progress notes as JSONL.
+ */
+class SyncManager {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.contextDir = path.join(projectRoot, ".ufoo", "context");
+    this.syncFile = path.join(this.contextDir, "sync.jsonl");
+  }
+
+  ensureContextDir() {
+    fs.mkdirSync(this.contextDir, { recursive: true });
+  }
+
+  parseLines() {
+    if (!fs.existsSync(this.syncFile)) return [];
+    const raw = fs.readFileSync(this.syncFile, "utf8");
+    if (!raw.trim()) return [];
+    const lines = raw
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean);
+
+    const entries = [];
+    for (const line of lines) {
+      try {
+        entries.push(JSON.parse(line));
+      } catch {
+        // Skip malformed legacy lines.
+      }
+    }
+    return entries;
+  }
+
+  normalizeActor(value, fallback = "unknown") {
+    const text = String(value || "").trim();
+    if (text) return text;
+    return fallback;
+  }
+
+  buildEntry(options = {}) {
+    const message = String(options.message || "").trim();
+    if (!message) {
+      throw new Error(
+        "Missing sync message. Usage: ufoo ctx sync write [--for <agent>] \"message\""
+      );
+    }
+
+    return {
+      ts: new Date().toISOString(),
+      type: "sync",
+      from: this.normalizeActor(
+        options.from,
+        process.env.UFOO_SUBSCRIBER_ID ||
+          process.env.UFOO_NICKNAME ||
+          process.env.USER ||
+          process.env.USERNAME ||
+          "unknown"
+      ),
+      for: this.normalizeActor(options.for, ""),
+      message,
+      decision: String(options.decision || "").trim(),
+      file: String(options.file || "").trim(),
+      tests: String(options.tests || "").trim(),
+      verification: String(options.verification || "").trim(),
+      risk: String(options.risk || "").trim(),
+      next: String(options.next || "").trim(),
+    };
+  }
+
+  write(options = {}) {
+    const entry = this.buildEntry(options);
+    this.ensureContextDir();
+    fs.appendFileSync(this.syncFile, `${JSON.stringify(entry)}\n`, "utf8");
+    console.log(this.formatEntry(entry));
+    return entry;
+  }
+
+  formatEntry(entry) {
+    const parts = [];
+    parts.push("[sync]");
+    if (entry.for) parts.push(`[for ${entry.for}]`);
+    if (entry.from) parts.push(`[from ${entry.from}]`);
+    parts.push(entry.message);
+
+    if (entry.decision) parts.push(`decision: ${entry.decision}.`);
+    if (entry.file) parts.push(`file: ${entry.file}.`);
+    if (entry.tests) parts.push(`tests: ${entry.tests}.`);
+    if (entry.verification) parts.push(`verification: ${entry.verification}.`);
+    if (entry.risk) parts.push(`risk: ${entry.risk}.`);
+    if (entry.next) parts.push(`next-cut: ${entry.next}.`);
+
+    return parts.join(" ");
+  }
+
+  list(options = {}) {
+    const num = Number.isFinite(options.num) && options.num > 0 ? options.num : 20;
+    const filterFor = String(options.for || "").trim();
+    const filterFrom = String(options.from || "").trim();
+
+    let entries = this.parseLines();
+    if (filterFor) entries = entries.filter((entry) => String(entry.for || "") === filterFor);
+    if (filterFrom) entries = entries.filter((entry) => String(entry.from || "") === filterFrom);
+
+    entries.sort((a, b) => {
+      const left = new Date(a.ts || 0).getTime();
+      const right = new Date(b.ts || 0).getTime();
+      return right - left;
+    });
+
+    const shown = entries.slice(0, num);
+    console.log(`=== Sync (${shown.length} shown, ${entries.length} matched) ===`);
+    for (const entry of shown) {
+      console.log(`${entry.ts || "-"} ${this.formatEntry(entry)}`);
+    }
+    if (shown.length === 0) {
+      console.log("No sync entries found.");
+    }
+    return shown;
+  }
+}
+
+module.exports = SyncManager;

package/src/daemon/agentProcessManager.js

@@ -0,0 +1,74 @@
+"use strict";
+
+const EventBus = require("../bus");
+
+class AgentProcessManager {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.processes = new Map(); // subscriber_id -> child_process
+  }
+
+  /**
+   * 注册子进程并监听退出事件
+   */
+  register(subscriberId, childProcess) {
+    if (!subscriberId || !childProcess) return;
+
+    this.processes.set(subscriberId, childProcess);
+
+    childProcess.on("exit", (code, signal) => {
+      this.processes.delete(subscriberId);
+
+      // 自动清理 bus 状态
+      try {
+        const eventBus = new EventBus(this.projectRoot);
+        eventBus.loadBusData();
+        if (eventBus.busData.agents?.[subscriberId]) {
+          eventBus.busData.agents[subscriberId].status = "inactive";
+          eventBus.busData.agents[subscriberId].last_seen = new Date().toISOString();
+          eventBus.saveBusData();
+          console.log(`[daemon] Agent ${subscriberId} exited (code=${code}, signal=${signal}), marked inactive`);
+        }
+      } catch (err) {
+        console.error(`[daemon] Failed to cleanup ${subscriberId}:`, err.message);
+      }
+    });
+
+    childProcess.on("error", (err) => {
+      console.error(`[daemon] Agent ${subscriberId} error:`, err.message);
+      this.processes.delete(subscriberId);
+    });
+  }
+
+  /**
+   * 获取运行中的进程
+   */
+  get(subscriberId) {
+    return this.processes.get(subscriberId);
+  }
+
+  /**
+   * 获取所有进程数量
+   */
+  count() {
+    return this.processes.size;
+  }
+
+  /**
+   * 清理所有子进程
+   */
+  cleanup() {
+    for (const [subscriberId, child] of this.processes.entries()) {
+      try {
+        child.kill("SIGTERM");
+        console.log(`[daemon] Killed agent ${subscriberId}`);
+      } catch {
+        // ignore
+      }
+    }
+    this.processes.clear();
+  }
+}
+
+
+module.exports = { AgentProcessManager };

package/src/daemon/cronOps.js

@@ -0,0 +1,241 @@
+const {
+  createCronScheduler,
+  parseIntervalMs,
+  formatIntervalMs,
+} = require("../chat/cronScheduler");
+
+function splitTargets(value = "") {
+  return String(value || "")
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function normalizeCronTargets(op = {}) {
+  const fromArray = Array.isArray(op.targets)
+    ? op.targets.map((item) => String(item || "").trim()).filter(Boolean)
+    : [];
+  if (fromArray.length > 0) return Array.from(new Set(fromArray));
+
+  const merged = [
+    op.target,
+    op.agent,
+    op.to,
+  ]
+    .map((item) => String(item || "").trim())
+    .filter(Boolean)
+    .join(",");
+
+  return Array.from(new Set(splitTargets(merged)));
+}
+
+function resolveCronOperation(op = {}) {
+  const raw = String(op.operation || op.op || op.command || "").trim().toLowerCase();
+  if (raw) return raw;
+  if (op.list === true) return "list";
+  if (op.stop === true) return "stop";
+  if (op.id || op.task_id || op.taskId) return "stop";
+  return "start";
+}
+
+function resolveCronIntervalMs(op = {}) {
+  const numeric = Number(op.interval_ms ?? op.intervalMs);
+  if (Number.isFinite(numeric) && numeric > 0) {
+    return Math.floor(numeric);
+  }
+
+  const everyRaw = String(op.every || op.interval || op.ms || "").trim();
+  if (!everyRaw) return 0;
+  return parseIntervalMs(everyRaw);
+}
+
+function resolveCronPrompt(op = {}) {
+  return String(op.prompt || op.message || op.msg || "").trim();
+}
+
+function resolveCronTaskId(op = {}) {
+  return String(op.id || op.task_id || op.taskId || "").trim();
+}
+
+function formatCronTask(task = {}) {
+  return {
+    id: String(task.id || ""),
+    intervalMs: Number(task.intervalMs) || 0,
+    interval: formatIntervalMs(task.intervalMs || 0),
+    targets: Array.isArray(task.targets) ? task.targets.slice() : [],
+    prompt: String(task.prompt || ""),
+    createdAt: Number(task.createdAt) || 0,
+    lastRunAt: Number(task.lastRunAt) || 0,
+    tickCount: Number(task.tickCount) || 0,
+    summary: String(task.summary || ""),
+  };
+}
+
+function createDaemonCronController(options = {}) {
+  const {
+    dispatch = async () => {},
+    log = () => {},
+    setIntervalFn,
+    clearIntervalFn,
+    nowFn,
+  } = options;
+
+  const scheduler = createCronScheduler({
+    dispatch: ({ taskId, target, message }) => {
+      try {
+        Promise.resolve(dispatch({ taskId, target, message })).catch((err) => {
+          const detail = err && err.message ? err.message : String(err || "dispatch failed");
+          log(`cron dispatch failed task=${taskId} target=${target}: ${detail}`);
+        });
+      } catch (err) {
+        const detail = err && err.message ? err.message : String(err || "dispatch failed");
+        log(`cron dispatch failed task=${taskId} target=${target}: ${detail}`);
+      }
+    },
+    setIntervalFn,
+    clearIntervalFn,
+    nowFn,
+  });
+
+  function listTasks() {
+    return scheduler.listTasks().map(formatCronTask);
+  }
+
+  function handleCronOp(op = {}) {
+    const operation = resolveCronOperation(op);
+
+    if (operation === "list" || operation === "ls") {
+      const tasks = listTasks();
+      return {
+        action: "cron",
+        operation: "list",
+        ok: true,
+        count: tasks.length,
+        tasks,
+      };
+    }
+
+    if (operation === "stop" || operation === "rm" || operation === "remove") {
+      const id = resolveCronTaskId(op);
+      if (!id) {
+        return {
+          action: "cron",
+          operation: "stop",
+          ok: false,
+          error: "cron stop requires id or all",
+        };
+      }
+
+      if (id === "all") {
+        const stopped = scheduler.stopAll();
+        return {
+          action: "cron",
+          operation: "stop",
+          ok: true,
+          id: "all",
+          stopped,
+        };
+      }
+
+      const ok = scheduler.stopTask(id);
+      if (!ok) {
+        return {
+          action: "cron",
+          operation: "stop",
+          ok: false,
+          id,
+          error: `cron task not found: ${id}`,
+        };
+      }
+
+      return {
+        action: "cron",
+        operation: "stop",
+        ok: true,
+        id,
+        stopped: 1,
+      };
+    }
+
+    if (operation !== "start" && operation !== "add" && operation !== "create") {
+      return {
+        action: "cron",
+        operation,
+        ok: false,
+        error: `unsupported cron operation: ${operation}`,
+      };
+    }
+
+    const intervalMs = resolveCronIntervalMs(op);
+    if (!Number.isFinite(intervalMs) || intervalMs < 1000) {
+      return {
+        action: "cron",
+        operation: "start",
+        ok: false,
+        error: "invalid cron interval (min 1s)",
+      };
+    }
+
+    const targets = normalizeCronTargets(op);
+    if (targets.length === 0) {
+      return {
+        action: "cron",
+        operation: "start",
+        ok: false,
+        error: "cron start requires at least one target",
+      };
+    }
+
+    const prompt = resolveCronPrompt(op);
+    if (!prompt) {
+      return {
+        action: "cron",
+        operation: "start",
+        ok: false,
+        error: "cron start requires prompt",
+      };
+    }
+
+    const task = scheduler.addTask({
+      intervalMs,
+      targets,
+      prompt,
+    });
+
+    if (!task) {
+      return {
+        action: "cron",
+        operation: "start",
+        ok: false,
+        error: "failed to create cron task",
+      };
+    }
+
+    return {
+      action: "cron",
+      operation: "start",
+      ok: true,
+      task: formatCronTask(task),
+    };
+  }
+
+  function stopAll() {
+    return scheduler.stopAll();
+  }
+
+  return {
+    handleCronOp,
+    listTasks,
+    stopAll,
+  };
+}
+
+module.exports = {
+  createDaemonCronController,
+  normalizeCronTargets,
+  resolveCronOperation,
+  resolveCronIntervalMs,
+  resolveCronPrompt,
+  resolveCronTaskId,
+  formatCronTask,
+};