u-foo 1.0.6 → 1.1.9

package/src/config.js

@@ -5,6 +5,14 @@ const DEFAULT_CONFIG = {
   launchMode: "auto",
   agentProvider: "codex-cli",
   agentModel: "",
+  assistantEngine: "auto",
+  assistantModel: "",
+  assistantUfooCmd: "",
+  ucodeProvider: "",
+  ucodeModel: "",
+  ucodeBaseUrl: "",
+  ucodeApiKey: "",
+  ucodeAgentDir: "",
   autoResume: false,
 };
 
@@ -20,6 +28,15 @@ function normalizeAgentProvider(value) {
   return value === "claude-cli" ? "claude-cli" : "codex-cli";
 }
 
+function normalizeAssistantEngine(value) {
+  const raw = String(value || "").trim().toLowerCase();
+  if (!raw || raw === "auto") return "auto";
+  if (raw === "codex" || raw === "codex-cli" || raw === "codex-code") return "codex";
+  if (raw === "claude" || raw === "claude-cli" || raw === "claude-code") return "claude";
+  if (raw === "ufoo") return "ufoo";
+  return "auto";
+}
+
 function configPath(projectRoot) {
   return path.join(projectRoot, ".ufoo", "config.json");
 }
@@ -32,6 +49,14 @@ function loadConfig(projectRoot) {
       ...raw,
       launchMode: normalizeLaunchMode(raw.launchMode),
       agentProvider: normalizeAgentProvider(raw.agentProvider),
+      assistantEngine: normalizeAssistantEngine(raw.assistantEngine),
+      assistantModel: typeof raw.assistantModel === "string" ? raw.assistantModel : "",
+      assistantUfooCmd: typeof raw.assistantUfooCmd === "string" ? raw.assistantUfooCmd : "",
+      ucodeProvider: typeof raw.ucodeProvider === "string" ? raw.ucodeProvider : "",
+      ucodeModel: typeof raw.ucodeModel === "string" ? raw.ucodeModel : "",
+      ucodeBaseUrl: typeof raw.ucodeBaseUrl === "string" ? raw.ucodeBaseUrl : "",
+      ucodeApiKey: typeof raw.ucodeApiKey === "string" ? raw.ucodeApiKey : "",
+      ucodeAgentDir: typeof raw.ucodeAgentDir === "string" ? raw.ucodeAgentDir : "",
       autoResume: raw.autoResume !== false,
     };
   } catch {
@@ -42,15 +67,36 @@ function loadConfig(projectRoot) {
 function saveConfig(projectRoot, config) {
   const target = configPath(projectRoot);
   fs.mkdirSync(path.dirname(target), { recursive: true });
+  let existing = {};
+  try {
+    existing = JSON.parse(fs.readFileSync(target, "utf8"));
+  } catch {
+    existing = {};
+  }
   const merged = {
     ...DEFAULT_CONFIG,
+    ...existing,
     ...config,
   };
   merged.launchMode = normalizeLaunchMode(merged.launchMode);
   merged.agentProvider = normalizeAgentProvider(merged.agentProvider);
+  merged.assistantEngine = normalizeAssistantEngine(merged.assistantEngine);
+  merged.assistantModel = typeof merged.assistantModel === "string" ? merged.assistantModel : "";
+  merged.assistantUfooCmd = typeof merged.assistantUfooCmd === "string" ? merged.assistantUfooCmd : "";
+  merged.ucodeProvider = typeof merged.ucodeProvider === "string" ? merged.ucodeProvider : "";
+  merged.ucodeModel = typeof merged.ucodeModel === "string" ? merged.ucodeModel : "";
+  merged.ucodeBaseUrl = typeof merged.ucodeBaseUrl === "string" ? merged.ucodeBaseUrl : "";
+  merged.ucodeApiKey = typeof merged.ucodeApiKey === "string" ? merged.ucodeApiKey : "";
+  merged.ucodeAgentDir = typeof merged.ucodeAgentDir === "string" ? merged.ucodeAgentDir : "";
   merged.autoResume = merged.autoResume !== false;
   fs.writeFileSync(target, JSON.stringify(merged, null, 2));
   return merged;
 }
 
-module.exports = { loadConfig, saveConfig, normalizeLaunchMode, normalizeAgentProvider };
+module.exports = {
+  loadConfig,
+  saveConfig,
+  normalizeLaunchMode,
+  normalizeAgentProvider,
+  normalizeAssistantEngine,
+};

package/src/context/decisions.js

@@ -130,24 +130,34 @@ class DecisionsManager {
       process.env.USERNAME ||
       "unknown";
 
+    const nicknameRaw =
+      options.nickname ||
+      process.env.UFOO_NICKNAME ||
+      process.env.USER ||
+      process.env.USERNAME ||
+      "unknown";
+
     const status = options.status || "open";
     const num = this.nextNumber();
     const slug = this.slugify(title);
+    const nick = this.slugify(nicknameRaw);
 
     fs.mkdirSync(this.contextDir, { recursive: true });
     fs.mkdirSync(this.decisionsDir, { recursive: true });
 
-    const file = `${num}-${slug}.md`;
+    const file = `${num}-${nick}-${slug}.md`;
     const filePath = path.join(this.decisionsDir, file);
     const date = new Date().toISOString().slice(0, 10);
 
     const content =
       `---\n` +
       `status: ${status}\n` +
+      `nickname: ${nicknameRaw}\n` +
       `---\n` +
       `# DECISION ${num}: ${title}\n\n` +
       `Date: ${date}\n` +
-      `Author: ${author}\n\n` +
+      `Author: ${author}\n` +
+      `Nickname: ${nicknameRaw}\n\n` +
       `Context:\nWhat led to this decision?\n\n` +
       `Decision:\nWhat is now considered true?\n\n` +
       `Implications:\nWhat must follow from this?\n`;

package/src/context/index.js

@@ -1,5 +1,6 @@
 const ContextDoctor = require("./doctor");
 const DecisionsManager = require("./decisions");
+const SyncManager = require("./sync");
 
 /**
  * Context management wrapper for chat commands
@@ -9,6 +10,7 @@ class UfooContext {
     this.projectRoot = projectRoot;
     this.doctorInstance = new ContextDoctor(projectRoot);
     this.decisionsManager = new DecisionsManager(projectRoot);
+    this.syncManager = new SyncManager(projectRoot);
   }
 
   /**
@@ -31,7 +33,22 @@ class UfooContext {
   async status() {
     const decisions = this.decisionsManager.readDecisions();
     const openDecisions = decisions.filter(d => d.status === "open");
-    console.log(`Context: ${openDecisions.length} open decision(s), ${decisions.length} total`);
+    const sync = this.syncManager.parseLines();
+    console.log(`Context: ${openDecisions.length} open decision(s), ${decisions.length} total, ${sync.length} sync note(s)`);
+  }
+
+  /**
+   * Append a sync note
+   */
+  async syncWrite(options = {}) {
+    return this.syncManager.write(options);
+  }
+
+  /**
+   * Show sync notes
+   */
+  async listSync(options = {}) {
+    return this.syncManager.list(options);
   }
 }
 

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,
+};