u-foo 1.0.3 → 1.1.9

package/src/agent/ucodeDoctor.js

@@ -0,0 +1,184 @@
+const fs = require("fs");
+const path = require("path");
+const { loadConfig } = require("../config");
+const {
+  resolveNativeFallbackCommand,
+  defaultBundledPromptFile,
+} = require("./ucode");
+const { inspectUcodeBuildSetup } = require("./ucodeBuild");
+const { inspectUcodeRuntimeConfig } = require("./ucodeRuntimeConfig");
+const { prepareUcodeBootstrap } = require("./ucodeBootstrap");
+
+function inspectUcodeSetup({
+  projectRoot = process.cwd(),
+  env = process.env,
+  loadConfigImpl = loadConfig,
+  resolveNativeImpl = resolveNativeFallbackCommand,
+} = {}) {
+  const root = path.resolve(projectRoot);
+  const config = loadConfigImpl(root);
+  const native = resolveNativeImpl({ env, config, cwd: root });
+  const coreAvailable = Boolean(native && native.available !== false && native.command);
+  const core = native ? {
+    root: native.root || path.resolve(__dirname, "..", "code"),
+    command: native.command,
+    args: native.args || [],
+    available: coreAvailable,
+    missingReason: String(native.missingReason || "").trim(),
+    resolvedPath: String(native.resolvedPath || "").trim(),
+  } : null;
+  const promptFile = String(
+    env.UFOO_UCODE_PROMPT_FILE
+      || config.ucodePromptFile
+      || defaultBundledPromptFile()
+  ).trim();
+  const bootstrapFile = String(
+    env.UFOO_UCODE_BOOTSTRAP_FILE
+      || config.ucodeBootstrapFile
+      || path.join(root, ".ufoo", "agent", "ucode", "bootstrap.md")
+  ).trim();
+  const build = inspectUcodeBuildSetup({
+    projectRoot: root,
+    env,
+    loadConfigImpl,
+  });
+  const runtime = inspectUcodeRuntimeConfig({
+    projectRoot: root,
+    env,
+    loadConfigImpl,
+  });
+  let importMeta = null;
+  if (core && core.root) {
+    const candidates = [
+      path.join(core.root, ".ufoo-import.json"),
+      path.join(core.root, "..", ".ufoo-import.json"),
+      path.join(core.root, "..", "..", ".ufoo-import.json"),
+      path.join(core.root, "..", "..", "..", ".ufoo-import.json"),
+    ].map((item) => path.resolve(item));
+    for (const candidate of candidates) {
+      try {
+        if (!fs.existsSync(candidate)) continue;
+        const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
+        if (parsed && typeof parsed === "object") {
+          importMeta = {
+            file: candidate,
+            importedAt: String(parsed.imported_at || "").trim(),
+            upstreamCommit: String(parsed.upstream_commit || "").trim(),
+            upstreamBranch: String(parsed.upstream_branch || "").trim(),
+            upstreamRemote: String(parsed.upstream_remote || "").trim(),
+          };
+          break;
+        }
+      } catch {
+        // ignore malformed metadata
+      }
+    }
+  }
+
+  return {
+    projectRoot: root,
+    expectedBundledCoreRoot: core ? core.root : "",
+    core: {
+      found: Boolean(core && core.available),
+      root: core ? core.root : "",
+      command: core ? core.command : "",
+      args: core ? core.args : [],
+      available: Boolean(core && core.available),
+      missingReason: core ? core.missingReason : "",
+      resolvedPath: core ? core.resolvedPath : "",
+    },
+    promptFile,
+    promptExists: Boolean(promptFile && fs.existsSync(promptFile)),
+    bootstrapFile,
+    build,
+    runtime,
+    importMeta,
+    configuredCommand: String(
+      env.UFOO_UCODE_CMD
+        || env.UFOO_UFOO_CODE_CMD
+        || config.ucodeCommand
+        || config.ufooCodeCommand
+        || ""
+    ).trim(),
+  };
+}
+
+function formatUcodeDoctor(result = {}) {
+  const lines = [];
+  lines.push("=== ucode doctor ===");
+  lines.push(`project: ${result.projectRoot || process.cwd()}`);
+  lines.push(`core: ${result.core && result.core.found ? "ready" : "missing"}`);
+  if (result.core && result.core.found) {
+    lines.push(`  root: ${result.core.root}`);
+    lines.push(`  launch: ${result.core.command} ${(result.core.args || []).join(" ")}`.trim());
+    if (result.core.resolvedPath) {
+      lines.push(`  resolved path: ${result.core.resolvedPath}`);
+    }
+  } else {
+    if (result.expectedBundledCoreRoot) {
+      lines.push(`  expected bundled root: ${result.expectedBundledCoreRoot}`);
+    }
+    if (result.core && result.core.command) {
+      lines.push(`  attempted launch: ${result.core.command} ${(result.core.args || []).join(" ")}`.trim());
+    }
+    if (result.core && result.core.missingReason) {
+      lines.push(`  missing reason: ${result.core.missingReason}`);
+    } else {
+      lines.push("  missing reason: native executable is unavailable");
+    }
+  }
+  if (result.configuredCommand) {
+    lines.push(`configured command override (ignored in native-only mode): ${result.configuredCommand}`);
+  }
+  lines.push(`prompt: ${result.promptFile || "(none)"}${result.promptExists ? "" : " (missing)"}`);
+  lines.push(`bootstrap: ${result.bootstrapFile || "(none)"}`);
+  if (result.build && result.build.coreRoot) {
+    lines.push(`build: ${result.build.distCliExists ? "ready" : "missing dist"}`);
+    lines.push(`  core root: ${result.build.coreRoot}`);
+    lines.push(`  workspace root: ${result.build.workspaceRoot || "(none)"}`);
+    lines.push(`  dist entry: ${result.build.distCliPath || "(none)"}${result.build.distCliExists ? "" : " (missing)"}`);
+  } else {
+    lines.push("build: unresolved core root");
+  }
+  if (result.importMeta) {
+    lines.push(`import metadata: ${result.importMeta.file || "(unknown)"}`);
+    lines.push(`  imported at: ${result.importMeta.importedAt || "(unknown)"}`);
+    lines.push(`  upstream commit: ${result.importMeta.upstreamCommit || "(unknown)"}`);
+    lines.push(`  upstream branch: ${result.importMeta.upstreamBranch || "(unknown)"}`);
+    lines.push(`  upstream remote: ${result.importMeta.upstreamRemote ? "(set)" : "(unset)"}`);
+  }
+  if (result.runtime) {
+    lines.push(`runtime: ${result.runtime.agentDir || "(none)"}`);
+    lines.push(`  provider: ${result.runtime.provider || "(unset)"}`);
+    lines.push(`  model: ${result.runtime.model || "(unset)"}`);
+    lines.push(`  base url: ${result.runtime.baseUrl ? "(set)" : "(unset)"}`);
+    lines.push(`  api key: ${result.runtime.apiKey ? "(set)" : "(unset)"}`);
+  }
+  if (!(result.core && result.core.found) && !result.configuredCommand) {
+    lines.push("hint: verify native entry exists at src/code/agent.js");
+  }
+  return lines.join("\n");
+}
+
+function prepareAndInspectUcode({
+  projectRoot = process.cwd(),
+  env = process.env,
+  loadConfigImpl = loadConfig,
+} = {}) {
+  const inspection = inspectUcodeSetup({ projectRoot, env, loadConfigImpl });
+  const prepared = prepareUcodeBootstrap({
+    projectRoot: inspection.projectRoot,
+    promptFile: inspection.promptFile,
+    targetFile: inspection.bootstrapFile,
+  });
+  return {
+    ...inspection,
+    bootstrapPrepared: prepared,
+  };
+}
+
+module.exports = {
+  inspectUcodeSetup,
+  formatUcodeDoctor,
+  prepareAndInspectUcode,
+};

package/src/agent/ucodeRuntimeConfig.js

@@ -0,0 +1,129 @@
+const fs = require("fs");
+const path = require("path");
+const { loadConfig } = require("../config");
+
+function readJson(filePath = "", fallback = {}) {
+  if (!filePath) return fallback;
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return fallback;
+    return parsed;
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJson(filePath = "", data = {}) {
+  if (!filePath) return;
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+
+function resolveRuntimeValues({
+  env = process.env,
+  config = {},
+  projectRoot = process.cwd(),
+} = {}) {
+  const root = path.resolve(projectRoot);
+  const provider = String(env.UFOO_UCODE_PROVIDER || config.ucodeProvider || "").trim();
+  const model = String(env.UFOO_UCODE_MODEL || config.ucodeModel || "").trim();
+  const apiKey = String(env.UFOO_UCODE_API_KEY || config.ucodeApiKey || "").trim();
+  const baseUrl = String(env.UFOO_UCODE_BASE_URL || config.ucodeBaseUrl || "").trim();
+  const agentDir = path.resolve(
+    String(
+      env.PI_CODING_AGENT_DIR
+        || env.UFOO_UCODE_AGENT_DIR
+        || config.ucodeAgentDir
+        || path.join(root, ".ufoo", "agent", "ucode", "pi-agent")
+    ).trim()
+  );
+  return {
+    projectRoot: root,
+    provider,
+    model,
+    apiKey,
+    baseUrl,
+    agentDir,
+  };
+}
+
+function inspectUcodeRuntimeConfig({
+  projectRoot = process.cwd(),
+  env = process.env,
+  loadConfigImpl = loadConfig,
+} = {}) {
+  const root = path.resolve(projectRoot);
+  const config = loadConfigImpl(root);
+  const resolved = resolveRuntimeValues({
+    env,
+    config,
+    projectRoot: root,
+  });
+  const settingsFile = path.join(resolved.agentDir, "settings.json");
+  const authFile = path.join(resolved.agentDir, "auth.json");
+  const modelsFile = path.join(resolved.agentDir, "models.json");
+  return {
+    ...resolved,
+    settingsFile,
+    authFile,
+    modelsFile,
+    settingsExists: fs.existsSync(settingsFile),
+    authExists: fs.existsSync(authFile),
+    modelsExists: fs.existsSync(modelsFile),
+  };
+}
+
+function prepareUcodeRuntimeConfig({
+  projectRoot = process.cwd(),
+  env = process.env,
+  loadConfigImpl = loadConfig,
+} = {}) {
+  const inspection = inspectUcodeRuntimeConfig({
+    projectRoot,
+    env,
+    loadConfigImpl,
+  });
+
+  const settings = readJson(inspection.settingsFile, {});
+  if (inspection.provider) settings.defaultProvider = inspection.provider;
+  if (inspection.model) settings.defaultModel = inspection.model;
+  writeJson(inspection.settingsFile, settings);
+
+  if (inspection.provider && inspection.apiKey) {
+    const auth = readJson(inspection.authFile, {});
+    auth[inspection.provider] = {
+      type: "api_key",
+      key: inspection.apiKey,
+    };
+    writeJson(inspection.authFile, auth);
+  }
+
+  if (inspection.provider && inspection.baseUrl) {
+    const models = readJson(inspection.modelsFile, {});
+    if (!models.providers || typeof models.providers !== "object" || Array.isArray(models.providers)) {
+      models.providers = {};
+    }
+    const providerConfig = models.providers[inspection.provider];
+    const nextProviderConfig = (providerConfig && typeof providerConfig === "object" && !Array.isArray(providerConfig))
+      ? { ...providerConfig }
+      : {};
+    nextProviderConfig.baseUrl = inspection.baseUrl;
+    models.providers[inspection.provider] = nextProviderConfig;
+    writeJson(inspection.modelsFile, models);
+  }
+
+  return {
+    ...inspection,
+    env: {
+      PI_CODING_AGENT_DIR: inspection.agentDir,
+    },
+  };
+}
+
+module.exports = {
+  resolveRuntimeValues,
+  inspectUcodeRuntimeConfig,
+  prepareUcodeRuntimeConfig,
+};
+

package/src/agent/ufooAgent.js

@@ -2,9 +2,11 @@ const fs = require("fs");
 const path = require("path");
 const { runCliAgent } = require("./cliRunner");
 const { normalizeCliOutput } = require("./normalizeOutput");
+const { buildStatus } = require("../daemon/status");
+const { getUfooPaths } = require("../ufoo/paths");
 
 function loadSessionState(projectRoot) {
-  const dir = path.join(projectRoot, ".ufoo", "agent");
+  const dir = getUfooPaths(projectRoot).agentDir;
   const file = path.join(dir, "ufoo-agent.json");
   try {
     const data = JSON.parse(fs.readFileSync(file, "utf8"));
@@ -15,52 +17,38 @@ function loadSessionState(projectRoot) {
 }
 
 function saveSessionState(projectRoot, state) {
-  const dir = path.join(projectRoot, ".ufoo", "agent");
+  const dir = getUfooPaths(projectRoot).agentDir;
   fs.mkdirSync(dir, { recursive: true });
   fs.writeFileSync(path.join(dir, "ufoo-agent.json"), JSON.stringify(state, null, 2));
 }
 
-function isPidAlive(pid) {
-  if (!pid || typeof pid !== "number") return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return Boolean(err && err.code === "EPERM");
-  }
-}
-
 function loadBusSummary(projectRoot, maxLines = 20) {
-  const busPath = path.join(projectRoot, ".ufoo", "bus", "bus.json");
-  let subscribers = [];
+  // Use daemon's buildStatus as the single source of truth
+  let agents = [];
   let nicknames = {};
   try {
-    const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
-    subscribers = Object.entries(bus.subscribers || {})
-      .map(([id, meta]) => {
-        const pid = typeof meta.pid === "number" ? meta.pid : Number(meta.pid || 0);
-        const status = meta.status || "unknown";
-        const online = status === "active" && isPidAlive(pid);
-        const nickname = meta.nickname || "";
-        if (nickname) {
-          nicknames[nickname] = id;
-        }
-        return {
-          id,
-          status,
-          online,
-          agent_type: meta.agent_type || "",
-          nickname,
-          last_heartbeat: meta.last_heartbeat || "",
-        };
-      })
-      .filter((item) => item.online);
+    const status = buildStatus(projectRoot);
+    const activeMeta = status.active_meta || [];
+    agents = activeMeta.map((item) => {
+      const nickname = item.nickname || "";
+      if (nickname) {
+        nicknames[nickname] = item.id;
+      }
+      return {
+        id: item.id,
+        status: "active",
+        online: true,
+        agent_type: "", // Not included in active_meta, but not needed
+        nickname,
+        last_heartbeat: "",
+      };
+    });
   } catch {
-    subscribers = [];
+    agents = [];
     nicknames = {};
   }
 
-  const eventsDir = path.join(projectRoot, ".ufoo", "bus", "events");
+  const eventsDir = getUfooPaths(projectRoot).busEventsDir;
   let recent = [];
   try {
     const files = fs
@@ -80,25 +68,41 @@ function loadBusSummary(projectRoot, maxLines = 20) {
     recent = [];
   }
 
-  return { subscribers, nicknames, recent };
+  return { agents, nicknames, recent };
 }
 
 function buildSystemPrompt(context) {
+  const hasAgents = context.agents && context.agents.length > 0;
+  const agentGuidance = hasAgents
+    ? ""
+    : "\n- IMPORTANT: No coding agents are currently online. For lightweight exploration or temporary command execution, prefer top-level assistant_call.\n- Use ops.launch only when persistent coding-agent sessions are necessary.";
+
   return [
     "You are ufoo-agent, a headless routing controller.",
+    "You can call a private execution helper via top-level assistant_call (not visible on bus).",
     "Return ONLY valid JSON. No extra text.",
     "Schema:",
     "{",
     '  "reply": "string",',
+    '  "assistant_call": {"kind":"explore|bash|mixed","task":"string","context":"optional","expect":"optional","provider":"codex|claude|ufoo (optional)","model":"optional","timeout_ms":60000},',
     '  "dispatch": [{"target":"broadcast|<agent-id>|<nickname>","message":"string"}],',
-    '  "ops": [{"action":"spawn|close","agent":"codex|claude","count":1,"agent_id":"id","nickname":"optional"}],',
+    '  "ops": [{"action":"launch|close|rename|cron","agent":"codex|claude|ucode","count":1,"agent_id":"id","nickname":"optional","operation":"start|list|stop","every":"30m","interval_ms":1800000,"target":"agent-id|nickname|csv","targets":["agent-id"],"prompt":"message","id":"task-id|all"}],',
     '  "disambiguate": {"prompt":"string","candidates":[{"agent_id":"id","reason":"string"}]}',
     "}",
     "Rules:",
     "- target must be 'broadcast', concrete agent-id, or a known nickname",
     "- If multiple possible agents, use disambiguate with candidates and no dispatch.",
-    "- If user specifies a nickname for a new agent, include ops.spawn with nickname so daemon can rename.",
+    "- If user specifies a nickname for a new agent, include ops.launch with nickname so daemon can rename.",
+    "- If user requests rename, use ops.rename with agent_id and nickname (do NOT launch).",
+    "- For scheduled follow-up (cron/corn), use ops.cron with operation=start and include every+target(s)+prompt.",
+    "- To check scheduled tasks, use ops.cron with operation=list.",
+    "- To stop scheduled tasks, use ops.cron with operation=stop and id (or id=all).",
+    "- Use top-level assistant_call for project exploration, temporary shell tasks, and quick execution support.",
+    "- assistant_call fields: kind (explore|bash|mixed), task (required), context/expect (optional), provider (codex|claude|ufoo, optional), model/timeout_ms (optional).",
+    "- Prefer assistant_call over launching coding agents when the task is short-lived.",
+    "- Legacy compatibility: if model emits ops.assistant_call, daemon will still process it.",
     "- If no action needed, return reply with empty dispatch/ops.",
+    agentGuidance,
     "",
     "Context: online agents and recent bus events:",
     JSON.stringify(context),
@@ -106,7 +110,7 @@ function buildSystemPrompt(context) {
 }
 
 function loadHistory(projectRoot, maxTurns = 6) {
-  const file = path.join(projectRoot, ".ufoo", "agent", "ufoo-agent.history.jsonl");
+  const file = path.join(getUfooPaths(projectRoot).agentDir, "ufoo-agent.history.jsonl");
   try {
     const lines = fs.readFileSync(file, "utf8").trim().split(/\r?\n/).filter(Boolean);
     const items = lines.map((l) => JSON.parse(l));
@@ -117,7 +121,7 @@ function loadHistory(projectRoot, maxTurns = 6) {
 }
 
 function appendHistory(projectRoot, item) {
-  const dir = path.join(projectRoot, ".ufoo", "agent");
+  const dir = getUfooPaths(projectRoot).agentDir;
   fs.mkdirSync(dir, { recursive: true });
   const file = path.join(dir, "ufoo-agent.history.jsonl");
   fs.appendFileSync(file, `${JSON.stringify(item)}\n`);
@@ -200,7 +204,7 @@ async function runUfooAgent({ projectRoot, prompt, provider, model }) {
   const fallbackNickname = extractNickname(prompt);
   if (fallbackNickname && payload && Array.isArray(payload.ops)) {
     for (const op of payload.ops) {
-      if (op && op.action === "spawn" && !op.nickname) {
+      if (op && (op.action === "launch" || op.action === "rename") && !op.nickname) {
         op.nickname = fallbackNickname;
         break;
       }