u-foo 1.0.3 → 1.1.9

package/src/config.js

@@ -2,19 +2,41 @@ const fs = require("fs");
 const path = require("path");
 
 const DEFAULT_CONFIG = {
-  launchMode: "terminal",
+  launchMode: "auto",
   agentProvider: "codex-cli",
   agentModel: "",
+  assistantEngine: "auto",
+  assistantModel: "",
+  assistantUfooCmd: "",
+  ucodeProvider: "",
+  ucodeModel: "",
+  ucodeBaseUrl: "",
+  ucodeApiKey: "",
+  ucodeAgentDir: "",
+  autoResume: false,
 };
 
 function normalizeLaunchMode(value) {
-  return value === "internal" ? "internal" : "terminal";
+  if (value === "auto") return "auto";
+  if (value === "internal") return "internal";
+  if (value === "tmux") return "tmux";
+  if (value === "terminal") return "terminal";
+  return "auto";
 }
 
 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");
 }
@@ -27,6 +49,15 @@ 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 {
     return { ...DEFAULT_CONFIG };
@@ -36,14 +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

@@ -0,0 +1,324 @@
+const fs = require("fs");
+const path = require("path");
+const matter = require("gray-matter");
+
+/**
+ * 决策管理器
+ * 处理项目决策日志的读取、过滤和显示
+ */
+class DecisionsManager {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.contextDir = path.join(projectRoot, ".ufoo", "context");
+    this.decisionsDir = DecisionsManager.resolveDecisionsDir(
+      projectRoot,
+      this.contextDir
+    );
+    this.indexFile = path.join(this.contextDir, "decisions.jsonl");
+  }
+
+  /**
+   * 解析决策目录（优先小写 decisions，兼容旧 DECISIONS）
+   */
+  static resolveDecisionsDir(projectRoot, contextDir = null) {
+    if (process.env.AI_CONTEXT_DECISIONS_DIR) {
+      return process.env.AI_CONTEXT_DECISIONS_DIR;
+    }
+    const ctx = contextDir || path.join(projectRoot, ".ufoo", "context");
+    const lower = path.join(ctx, "decisions");
+    const upper = path.join(ctx, "DECISIONS");
+    if (fs.existsSync(lower)) return lower;
+    if (fs.existsSync(upper)) return upper;
+    return lower;
+  }
+
+  /**
+   * 读取所有决策文件
+   */
+  readDecisions() {
+    if (!fs.existsSync(this.decisionsDir)) {
+      return [];
+    }
+
+    const files = fs
+      .readdirSync(this.decisionsDir)
+      .filter((f) => f.endsWith(".md"))
+      .sort()
+      .reverse(); // Newest first
+
+    return files.map((file) => {
+      const filePath = path.join(this.decisionsDir, file);
+      const content = fs.readFileSync(filePath, "utf8");
+
+      let data = {};
+      let body = content;
+      let title = "";
+
+      try {
+        const parsed = matter(content);
+        data = parsed.data;
+        body = parsed.content;
+
+        // Extract title from first line of content
+        const firstLine = body.trim().split("\n")[0];
+        if (firstLine.startsWith("#")) {
+          title = firstLine.replace(/^#+\s*/, "").trim();
+        }
+      } catch {
+        // No frontmatter, extract title from first line
+        const firstLine = content.trim().split("\n")[0];
+        if (firstLine.startsWith("#")) {
+          title = firstLine.replace(/^#+\s*/, "").trim();
+        }
+      }
+
+      return {
+        file,
+        filePath,
+        status: data.status || "open",
+        title: title || "(no title)",
+        content,
+        data,
+        body,
+      };
+    });
+  }
+
+  /**
+   * 生成下一个 4 位编号
+   */
+  nextNumber() {
+    if (!fs.existsSync(this.decisionsDir)) {
+      return "0001";
+    }
+    const files = fs
+      .readdirSync(this.decisionsDir)
+      .filter((f) => f.endsWith(".md"))
+      .map((f) => {
+        const match = f.match(/^(\d{4})-/);
+        return match ? parseInt(match[1], 10) : 0;
+      });
+    const max = files.length ? Math.max(...files) : 0;
+    return String(max + 1).padStart(4, "0");
+  }
+
+  /**
+   * 简单 slugify
+   */
+  slugify(title) {
+    const cleaned = title
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .replace(/-+/g, "-");
+    return cleaned || "decision";
+  }
+
+  /**
+   * 创建新决策
+   */
+  createDecision(options = {}) {
+    const title = (options.title || "").trim();
+    if (!title) {
+      throw new Error("Missing title. Usage: ufoo ctx decisions new \"Title\"");
+    }
+
+    const author =
+      options.author ||
+      process.env.UFOO_NICKNAME ||
+      process.env.USER ||
+      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}-${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` +
+      `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`;
+
+    fs.writeFileSync(filePath, content, "utf8");
+    console.log(`Created ${filePath}`);
+
+    this.writeIndex();
+    return { file, filePath };
+  }
+
+  /**
+   * 从正文中提取字段（如 Date/Author）
+   */
+  extractField(body, fieldName) {
+    const regex = new RegExp(`^${fieldName}:\\s*(.+)$`, "mi");
+    const match = body.match(regex);
+    return match ? match[1].trim() : "";
+  }
+
+  /**
+   * 规范化时间戳
+   */
+  normalizeTs(value, fallbackPath = null) {
+    if (value) {
+      const parsed = new Date(value);
+      if (!Number.isNaN(parsed.valueOf())) {
+        return parsed.toISOString();
+      }
+      return value;
+    }
+    if (fallbackPath && fs.existsSync(fallbackPath)) {
+      const stat = fs.statSync(fallbackPath);
+      return stat.mtime.toISOString();
+    }
+    return new Date().toISOString();
+  }
+
+  /**
+   * 构建决策索引（jsonl）
+   */
+  buildIndexEntries(decisions) {
+    const entries = [];
+
+    for (const d of decisions) {
+      const createdAt =
+        d.data.created_at ||
+        d.data.createdAt ||
+        this.extractField(d.body, "Date");
+      const author =
+        d.data.author ||
+        this.extractField(d.body, "Author") ||
+        d.data.resolved_by ||
+        d.data.resolvedBy ||
+        "";
+
+      entries.push({
+        ts: this.normalizeTs(createdAt, d.filePath),
+        type: "decision",
+        file: d.file,
+        author,
+        status: d.status,
+        title: d.title,
+      });
+
+      if (d.status && d.status !== "open") {
+        const resolvedAt = d.data.resolved_at || d.data.resolvedAt;
+        const resolvedBy = d.data.resolved_by || d.data.resolvedBy || author;
+        entries.push({
+          ts: this.normalizeTs(resolvedAt, d.filePath),
+          type: "decision_status",
+          file: d.file,
+          author: resolvedBy,
+          status: d.status,
+          title: d.title,
+        });
+      }
+    }
+
+    return entries;
+  }
+
+  /**
+   * 写入索引文件
+   */
+  writeIndex() {
+    const decisions = this.readDecisions();
+    const entries = this.buildIndexEntries(decisions);
+
+    fs.mkdirSync(this.contextDir, { recursive: true });
+
+    const lines = entries.map((e) => JSON.stringify(e));
+    const output = lines.length ? `${lines.join("\n")}\n` : "";
+    fs.writeFileSync(this.indexFile, output, "utf8");
+
+    console.log(`Wrote ${entries.length} entries to ${this.indexFile}`);
+  }
+
+  /**
+   * 过滤决策
+   */
+  filterDecisions(decisions, statusFilter = "open") {
+    if (statusFilter === "all") {
+      return decisions;
+    }
+
+    return decisions.filter((d) => d.status === statusFilter);
+  }
+
+  /**
+   * 列出决策（简要模式）
+   */
+  list(options = {}) {
+    const { status = "open" } = options;
+
+    const decisions = this.readDecisions();
+    const filtered = this.filterDecisions(decisions, status);
+
+    console.log(
+      `=== Decisions (${filtered.length} ${status}, ${decisions.length} total) ===`
+    );
+
+    for (const d of filtered) {
+      console.log(`  [${d.status}] ${d.file}: ${d.title}`);
+    }
+
+    return filtered;
+  }
+
+  /**
+   * 显示决策（完整内容）
+   */
+  show(options = {}) {
+    const { status = "open", num = 1, all = false } = options;
+
+    const decisions = this.readDecisions();
+    const filtered = this.filterDecisions(decisions, status);
+
+    if (filtered.length === 0) {
+      if (decisions.length === 0) {
+        console.log("No decisions found.");
+      } else {
+        console.log(`No decisions with status '${status}' found.`);
+      }
+      return [];
+    }
+
+    console.log(`=== Latest Decision(s) [${status}] ===`);
+    console.log("");
+
+    const count = all ? filtered.length : Math.min(num, filtered.length);
+
+    for (let i = 0; i < count; i++) {
+      const d = filtered[i];
+      console.log(`--- ${d.file} [${d.status}] ---`);
+      console.log(d.content);
+      console.log("");
+    }
+
+    return filtered.slice(0, count);
+  }
+}
+
+module.exports = DecisionsManager;

package/src/context/doctor.js

@@ -0,0 +1,183 @@
+const fs = require("fs");
+const path = require("path");
+const DecisionsManager = require("./decisions");
+
+/**
+ * Context Doctor & Lint
+ * 诊断和验证 context 目录结构
+ */
+class ContextDoctor {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.contextDir = path.join(projectRoot, ".ufoo", "context");
+    this.failed = false;
+  }
+
+  /**
+   * 失败检查
+   */
+  fail(message) {
+    console.error(`FAIL: ${message}`);
+    this.failed = true;
+  }
+
+  /**
+   * 检查文件存在
+   */
+  checkFile(filePath, name) {
+    if (!fs.existsSync(filePath)) {
+      this.fail(`Missing file: ${name || filePath}`);
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * 检查目录存在
+   */
+  checkDir(dirPath, name) {
+    if (!fs.existsSync(dirPath)) {
+      this.fail(`Missing directory: ${name || dirPath}`);
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * 检查 glob 模式有匹配
+   */
+  checkAnyGlob(dir, pattern, name) {
+    try {
+      const files = fs.readdirSync(dir).filter((f) => f.match(pattern));
+      if (files.length === 0) {
+        this.fail(`Missing: ${name || pattern} in ${dir}`);
+        return false;
+      }
+      return true;
+    } catch {
+      this.fail(`Cannot read directory: ${dir}`);
+      return false;
+    }
+  }
+
+  /**
+   * Lint 项目 context
+   */
+  lintProject(projectPath) {
+    const ctxPath = projectPath || this.contextDir;
+
+    console.log(`Linting project context: ${ctxPath}`);
+
+    // Check basic structure
+    this.checkDir(ctxPath, "context directory");
+    this.checkFile(path.join(ctxPath, "decisions.jsonl"), "decisions.jsonl");
+
+    // Check decisions directory
+    const decisionsDir = DecisionsManager.resolveDecisionsDir(
+      this.projectRoot,
+      ctxPath
+    );
+    this.checkDir(decisionsDir, "decisions directory");
+
+    return !this.failed;
+  }
+
+  /**
+   * Lint 协议 repo（modules/context）
+   */
+  lintProtocol() {
+    const moduleRoot = path.join(this.projectRoot, "modules", "context");
+
+    if (!fs.existsSync(moduleRoot)) {
+      console.log("No protocol module found (skipping protocol lint)");
+      return true;
+    }
+
+    console.log(`Linting protocol repo: ${moduleRoot}`);
+
+    // Check minimal module files
+    this.checkFile(path.join(moduleRoot, "README.md"), "README.md");
+    this.checkFile(
+      path.join(moduleRoot, "SKILLS", "uctx", "SKILL.md"),
+      "SKILLS/uctx/SKILL.md"
+    );
+
+    return !this.failed;
+  }
+
+  /**
+   * 运行完整诊断
+   */
+  async run(options = {}) {
+    const { mode = "protocol", projectPath = null } = options;
+
+    console.log("=== context doctor ===");
+    console.log(
+      "Reminder: If you provide evaluation/recommendation/plan, write a decision before replying."
+    );
+    console.log("");
+
+    this.failed = false;
+
+    if (mode === "project") {
+      if (!projectPath) {
+        this.fail("--project requires a path");
+        return false;
+      }
+
+      console.log("Mode: project");
+      console.log(`Project: ${projectPath}`);
+      this.lintProject(projectPath);
+
+      // Test decisions listing
+      try {
+        const decisionsManager = new DecisionsManager(this.projectRoot);
+        decisionsManager.decisionsDir = DecisionsManager.resolveDecisionsDir(
+          this.projectRoot,
+          projectPath
+        );
+        decisionsManager.show({ num: 1 });
+      } catch (err) {
+        this.fail(`Decisions check failed: ${err.message}`);
+      }
+    } else {
+      console.log("Mode: protocol");
+
+      // Check protocol module
+      this.lintProtocol();
+
+      // Test decisions listing (silent)
+      try {
+        const decisionsManager = new DecisionsManager(this.projectRoot);
+        decisionsManager.show({ num: 1 });
+      } catch {
+        // Silent
+      }
+    }
+
+    // Check global modules
+    const globalContext = path.join(
+      process.env.HOME,
+      ".ufoo",
+      "modules",
+      "context"
+    );
+    if (!fs.existsSync(globalContext)) {
+      console.log("");
+      console.log(
+        `WARN: ${globalContext} not found (install via ufoo for best UX)`
+      );
+    }
+
+    console.log("");
+    if (this.failed) {
+      console.log("Status: FAILED");
+      return false;
+    } else {
+      console.log("Status: OK");
+      return true;
+    }
+  }
+}
+
+module.exports = ContextDoctor;

package/src/context/index.js

@@ -0,0 +1,55 @@
+const ContextDoctor = require("./doctor");
+const DecisionsManager = require("./decisions");
+const SyncManager = require("./sync");
+
+/**
+ * Context management wrapper for chat commands
+ */
+class UfooContext {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.doctorInstance = new ContextDoctor(projectRoot);
+    this.decisionsManager = new DecisionsManager(projectRoot);
+    this.syncManager = new SyncManager(projectRoot);
+  }
+
+  /**
+   * Run doctor check
+   */
+  async doctor() {
+    await this.doctorInstance.run({ mode: "project", projectPath: this.projectRoot });
+  }
+
+  /**
+   * List decisions
+   */
+  async listDecisions() {
+    this.decisionsManager.list({ status: "open" });
+  }
+
+  /**
+   * Get context status
+   */
+  async status() {
+    const decisions = this.decisionsManager.readDecisions();
+    const openDecisions = decisions.filter(d => d.status === "open");
+    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);
+  }
+}
+
+module.exports = UfooContext;