u-foo 1.0.3 → 1.0.6

package/src/init/index.js

@@ -0,0 +1,264 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * ufoo 初始化管理
+ */
+class UfooInit {
+  constructor(repoRoot) {
+    this.repoRoot = repoRoot;
+    this.contextMod = path.join(repoRoot, "modules", "context");
+    this.busMod = path.join(repoRoot, "modules", "bus");
+    this.resourcesMod = path.join(repoRoot, "modules", "resources");
+    this.agentsTemplate = path.join(repoRoot, "modules", "AGENTS.template.md");
+  }
+
+  /**
+   * 初始化项目
+   */
+  async init(options = {}) {
+    const modules = (options.modules || "context").split(",");
+    const project = options.project || process.cwd();
+
+    console.log("=== ufoo init ===");
+    console.log(`Project directory: ${project}`);
+    console.log(`Modules: ${modules.join(", ")}`);
+    console.log();
+
+    // 确保 AGENTS.md 和 CLAUDE.md 存在
+    this.ensureAgentsFiles(project);
+
+    // 初始化核心
+    this.initCore(project);
+
+    // 初始化 AGENTS.md 模板
+    this.injectAgentsTemplate(project);
+
+    // 初始化各模块
+    for (const module of modules) {
+      switch (module.trim()) {
+        case "context":
+          this.initContext(project);
+          break;
+        case "bus":
+          await this.initBus(project);
+          break;
+        case "resources":
+          this.initResources(project);
+          break;
+        default:
+          console.error(`Unknown module: ${module}`);
+      }
+    }
+
+    console.log();
+    console.log("✓ Initialization complete");
+  }
+
+  /**
+   * 确保 AGENTS.md 和 CLAUDE.md 存在
+   */
+  ensureAgentsFiles(project) {
+    const agentsFile = path.join(project, "AGENTS.md");
+    const claudeFile = path.join(project, "CLAUDE.md");
+
+    // 创建 AGENTS.md（如果不存在）
+    if (!fs.existsSync(agentsFile)) {
+      const content = `# Project Instructions
+
+\`CLAUDE.md\` points to this file. Please keep project instructions here (prefer edits in \`AGENTS.md\`).
+
+`;
+      fs.writeFileSync(agentsFile, content, "utf8");
+    }
+
+    // CLAUDE.md 指向 AGENTS.md
+    fs.writeFileSync(claudeFile, "AGENTS.md\n", "utf8");
+  }
+
+  /**
+   * 初始化核心 .ufoo 目录
+   */
+  initCore(project) {
+    console.log("[core] Initializing .ufoo core...");
+
+    const ufooDir = path.join(project, ".ufoo");
+    if (!fs.existsSync(ufooDir)) {
+      fs.mkdirSync(ufooDir, { recursive: true });
+    }
+
+    // 创建 docs 符号链接
+    const docsLink = path.join(ufooDir, "docs");
+    const docsTarget = path.join(this.repoRoot, "docs");
+
+    if (fs.existsSync(docsTarget)) {
+      if (fs.existsSync(docsLink)) {
+        fs.unlinkSync(docsLink);
+      }
+      fs.symlinkSync(docsTarget, docsLink);
+      console.log(`[core] Created docs symlink: .ufoo/docs -> ${docsTarget}`);
+    }
+
+    console.log("[core] Done");
+  }
+
+  /**
+   * 注入 ufoo 模板到 AGENTS.md
+   */
+  injectAgentsTemplate(project) {
+    if (!fs.existsSync(this.agentsTemplate)) {
+      console.log("[template] AGENTS.template.md not found, skipping");
+      return;
+    }
+
+    console.log("[template] Injecting ufoo template into AGENTS.md...");
+
+    const agentsFile = path.join(project, "AGENTS.md");
+    let content = fs.readFileSync(agentsFile, "utf8");
+
+    const template = fs.readFileSync(this.agentsTemplate, "utf8");
+
+    // 查找或添加 ufoo 标记块
+    const marker = "<!-- ufoo-template -->";
+    if (content.includes(marker)) {
+      // 替换现有块
+      const startIdx = content.indexOf(marker);
+      const endIdx = content.indexOf(marker, startIdx + marker.length);
+
+      if (endIdx !== -1) {
+        content =
+          content.slice(0, startIdx) +
+          `${marker}\n${template}\n${marker}` +
+          content.slice(endIdx + marker.length);
+      } else {
+        // 只有开始标记，追加到末尾
+        content += `\n${marker}\n${template}\n${marker}\n`;
+      }
+    } else {
+      // 追加到末尾
+      content += `\n${marker}\n${template}\n${marker}\n`;
+    }
+
+    fs.writeFileSync(agentsFile, content, "utf8");
+    console.log("[template] Done");
+  }
+
+  /**
+   * 初始化 context 模块
+   */
+  initContext(project) {
+    console.log("[context] Initializing decision-only context...");
+
+    const targetDir = path.join(project, ".ufoo", "context");
+    const decisionsDir = path.join(targetDir, "decisions");
+    const legacyDir = path.join(targetDir, "DECISIONS");
+    const indexFile = path.join(targetDir, "decisions.jsonl");
+
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+    if (!fs.existsSync(decisionsDir) && fs.existsSync(legacyDir)) {
+      fs.renameSync(legacyDir, decisionsDir);
+    }
+    if (!fs.existsSync(decisionsDir)) {
+      fs.mkdirSync(decisionsDir, { recursive: true });
+    }
+    if (!fs.existsSync(indexFile)) {
+      fs.writeFileSync(indexFile, "", "utf8");
+    }
+
+    console.log("[context] Done");
+  }
+
+  /**
+   * 初始化 bus 模块
+   */
+  async initBus(project) {
+    console.log("[bus] Initializing bus module...");
+
+    const EventBus = require("../bus");
+    const bus = new EventBus(project);
+
+    try {
+      await bus.init();
+      console.log("[bus] Done");
+    } catch (err) {
+      console.error(`[bus] Error: ${err.message}`);
+    }
+  }
+
+  /**
+   * 初始化 resources 模块
+   */
+  initResources(project) {
+    if (!fs.existsSync(this.resourcesMod)) {
+      console.log("[resources] Module not found, skipping");
+      return;
+    }
+
+    console.log("[resources] Initializing resources module...");
+
+    const targetDir = path.join(project, ".ufoo", "resources");
+
+    // 复制模块内容
+    this.copyModuleContent(this.resourcesMod, targetDir);
+
+    console.log("[resources] Done");
+  }
+
+  /**
+   * 复制模块内容
+   */
+  copyModuleContent(src, dest) {
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    // 复制所有文件和目录（排除 .git、node_modules 等）
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      // 跳过特殊目录
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        this.copyRecursive(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+
+  /**
+   * 递归复制目录
+   */
+  copyRecursive(src, dest) {
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        this.copyRecursive(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+}
+
+module.exports = UfooInit;

package/src/skills/index.js

@@ -0,0 +1,159 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * 技能管理
+ */
+class SkillsManager {
+  constructor(repoRoot) {
+    this.repoRoot = repoRoot;
+    this.skillRoots = this.findSkillRoots();
+  }
+
+  /**
+   * 查找所有技能根目录
+   */
+  findSkillRoots() {
+    const roots = [];
+
+    // 检查 SKILLS 目录
+    const mainSkills = path.join(this.repoRoot, "SKILLS");
+    if (fs.existsSync(mainSkills)) {
+      roots.push(mainSkills);
+    }
+
+    // 检查 modules 中的 SKILLS
+    const modulesDir = path.join(this.repoRoot, "modules");
+    if (fs.existsSync(modulesDir)) {
+      const modules = fs.readdirSync(modulesDir);
+      for (const module of modules) {
+        const moduleSkills = path.join(modulesDir, module, "SKILLS");
+        if (fs.existsSync(moduleSkills)) {
+          roots.push(moduleSkills);
+        }
+      }
+    }
+
+    return roots;
+  }
+
+  /**
+   * 列出所有技能
+   */
+  list() {
+    const skills = new Set();
+
+    for (const root of this.skillRoots) {
+      if (!fs.existsSync(root)) {
+        continue;
+      }
+
+      const entries = fs.readdirSync(root, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          skills.add(entry.name);
+        }
+      }
+    }
+
+    return Array.from(skills).sort();
+  }
+
+  /**
+   * 查找技能路径
+   */
+  findSkill(name) {
+    for (const root of this.skillRoots) {
+      const skillPath = path.join(root, name);
+      if (fs.existsSync(skillPath)) {
+        return skillPath;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 安装技能
+   */
+  async install(name, options = {}) {
+    // 确定目标目录
+    let target = options.target;
+
+    if (!target) {
+      if (options.codex) {
+        const codexHome = process.env.CODEX_HOME || path.join(process.env.HOME, ".codex");
+        target = path.join(codexHome, "skills");
+      } else if (options.agents) {
+        target = path.join(process.env.HOME, ".agents", "skills");
+      } else {
+        target = path.join(process.env.HOME, ".claude", "skills");
+      }
+    }
+
+    console.log(`Installing to: ${target}`);
+
+    // 确保目标目录存在
+    if (!fs.existsSync(target)) {
+      fs.mkdirSync(target, { recursive: true });
+    }
+
+    if (name === "all") {
+      // 安装所有技能
+      const skills = this.list();
+      for (const skill of skills) {
+        await this.installOne(skill, target);
+      }
+      console.log(`\nInstalled ${skills.length} skills to ${target}`);
+    } else {
+      // 安装单个技能
+      await this.installOne(name, target);
+      console.log(`\nInstalled "${name}" to ${target}`);
+    }
+  }
+
+  /**
+   * 安装单个技能
+   */
+  async installOne(name, target) {
+    const sourcePath = this.findSkill(name);
+    if (!sourcePath) {
+      throw new Error(`Skill not found: ${name}`);
+    }
+
+    const targetPath = path.join(target, name);
+
+    // 如果目标已存在，先删除
+    if (fs.existsSync(targetPath)) {
+      fs.rmSync(targetPath, { recursive: true, force: true });
+    }
+
+    // 复制技能目录
+    console.log(`  - ${name}`);
+    this.copyRecursive(sourcePath, targetPath);
+  }
+
+  /**
+   * 递归复制目录
+   */
+  copyRecursive(src, dest) {
+    // 创建目标目录
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        this.copyRecursive(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+}
+
+module.exports = SkillsManager;

package/src/status/index.js

@@ -0,0 +1,252 @@
+const fs = require("fs");
+const path = require("path");
+const { readJSON } = require("../bus/utils");
+const { getUfooPaths } = require("../ufoo/paths");
+
+/**
+ * 显示项目状态
+ */
+class StatusDisplay {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.paths = getUfooPaths(projectRoot);
+    this.ufooDir = this.paths.ufooDir;
+  }
+
+  /**
+   * 检查 .ufoo 目录是否存在
+   */
+  checkUfooDir() {
+    if (!fs.existsSync(this.ufooDir)) {
+      console.error("FAIL: .ufoo not found. Run: ufoo init");
+      process.exit(1);
+    }
+  }
+
+  /**
+   * 获取当前订阅者信息
+   */
+  getCurrentSubscriber() {
+    // 优先使用 UFOO_SUBSCRIBER_ID（daemon 启动的情况）
+    if (process.env.UFOO_SUBSCRIBER_ID) {
+      return process.env.UFOO_SUBSCRIBER_ID;
+    }
+
+    const agentsFile = this.paths.agentsFile;
+    if (!fs.existsSync(agentsFile)) {
+      return null;
+    }
+
+    // 尝试通过 tty 查找订阅者
+    let currentTty = null;
+    try {
+      currentTty = fs.readFileSync("/dev/tty", "utf8").trim();
+    } catch {
+      // tty 不可用
+    }
+
+    if (currentTty && currentTty.startsWith("/dev/")) {
+      const busData = readJSON(agentsFile);
+      if (busData && busData.agents) {
+        for (const [id, meta] of Object.entries(busData.agents)) {
+          if (meta.tty === currentTty) {
+            return id;
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * 统计未读消息
+   */
+  countUnreadMessages() {
+    const queuesDir = this.paths.busQueuesDir;
+    if (!fs.existsSync(queuesDir)) {
+      return { total: 0, details: [] };
+    }
+
+    const agentsFile = this.paths.agentsFile;
+    const busData = readJSON(agentsFile, {});
+
+    let total = 0;
+    const details = [];
+
+    const subscribers = fs.readdirSync(queuesDir);
+    for (const safeName of subscribers) {
+      const pendingFile = path.join(queuesDir, safeName, "pending.jsonl");
+      if (!fs.existsSync(pendingFile)) {
+        continue;
+      }
+
+      const stat = fs.statSync(pendingFile);
+      if (stat.size === 0) {
+        continue;
+      }
+
+      const content = fs.readFileSync(pendingFile, "utf8").trim();
+      const count = content ? content.split("\n").length : 0;
+
+      if (count > 0) {
+        total += count;
+
+        // 找到订阅者名称
+        let subscriberName = safeName.replace(/_/, ":");
+        if (busData.agents) {
+          for (const [id, meta] of Object.entries(busData.agents)) {
+            if (id.replace(/:/, "_") === safeName) {
+              subscriberName = id;
+              break;
+            }
+          }
+        }
+
+        details.push({ subscriber: subscriberName, count });
+      }
+    }
+
+    return { total, details };
+  }
+
+  /**
+   * 统计开放的决策
+   */
+  countOpenDecisions() {
+    const DecisionsManager = require("../context/decisions");
+    const manager = new DecisionsManager(this.projectRoot);
+    const decisionsDir = manager.decisionsDir;
+    if (!fs.existsSync(decisionsDir)) {
+      return { total: 0, details: [] };
+    }
+
+    let total = 0;
+    const details = [];
+
+    const files = fs.readdirSync(decisionsDir)
+      .filter((f) => f.endsWith(".md"))
+      .sort();
+
+    for (const file of files) {
+      const filePath = path.join(decisionsDir, file);
+      const content = fs.readFileSync(filePath, "utf8");
+
+      // 提取状态
+      const status = this.extractStatus(content);
+      if (status === "open") {
+        total++;
+
+        // 提取标题
+        const title = this.extractTitle(content);
+        details.push({ file, title: title || "(no title)" });
+      }
+    }
+
+    return { total, details };
+  }
+
+  /**
+   * 从决策文件提取状态
+   */
+  extractStatus(content) {
+    const lines = content.split("\n");
+    let inFrontmatter = false;
+    let frontmatterCount = 0;
+
+    for (const line of lines) {
+      if (line.trim() === "---") {
+        frontmatterCount++;
+        if (frontmatterCount === 2) {
+          break;
+        }
+        inFrontmatter = frontmatterCount === 1;
+        continue;
+      }
+
+      if (inFrontmatter && line.startsWith("status:")) {
+        return line.split(":")[1].trim();
+      }
+    }
+
+    return "open";
+  }
+
+  /**
+   * 从决策文件提取标题
+   */
+  extractTitle(content) {
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (line.startsWith("#")) {
+        return line.replace(/^#\s*/, "").trim();
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 获取订阅者昵称（如果存在）
+   */
+  getSubscriberNickname(subscriber) {
+    if (!subscriber) return null;
+    const agentsFile = this.paths.agentsFile;
+    const busData = readJSON(agentsFile);
+    if (!busData || !busData.agents) return null;
+    const meta = busData.agents[subscriber];
+    return meta && meta.nickname ? meta.nickname : null;
+  }
+
+  /**
+   * 显示横幅（如果存在）
+   */
+  showBanner(subscriber) {
+    if (!subscriber) {
+      console.log("=== ufoo status ===");
+      console.log();
+      return;
+    }
+
+    const { showBanner } = require("../utils/banner");
+    const agentType = subscriber.startsWith("codex:") ? "codex" : "claude";
+    const sessionId = subscriber.split(":")[1] || "unknown";
+    const nickname = this.getSubscriberNickname(subscriber);
+
+    showBanner({ agentType, sessionId, nickname });
+  }
+
+  /**
+   * 显示完整状态
+   */
+  async show() {
+    this.checkUfooDir();
+
+    const subscriber = this.getCurrentSubscriber();
+
+    // 显示横幅
+    this.showBanner(subscriber);
+
+    // 显示项目路径
+    console.log(`Project: ${this.projectRoot}`);
+
+    // 显示未读消息
+    const unread = this.countUnreadMessages();
+    console.log(`Unread messages: ${unread.total}`);
+    if (unread.details.length > 0) {
+      for (const { subscriber: sub, count } of unread.details) {
+        console.log(`  - ${sub}: ${count}`);
+      }
+    }
+
+    // 显示开放的决策
+    const decisions = this.countOpenDecisions();
+    console.log(`Open decisions: ${decisions.total}`);
+    if (decisions.details.length > 0) {
+      for (const { file, title } of decisions.details) {
+        console.log(`  - ${file}: ${title}`);
+      }
+    }
+  }
+}
+
+module.exports = StatusDisplay;