u-foo 1.0.6 → 1.2.0

package/src/agent/ucodeBuild.js

@@ -0,0 +1,67 @@
+const fs = require("fs");
+const path = require("path");
+const { loadConfig } = require("../config");
+const {
+  resolveNativeFallbackCommand,
+} = require("./ucode");
+
+function resolveCoreRoot({
+  env = process.env,
+  config = {},
+} = {}) {
+  void env;
+  void config;
+  const native = resolveNativeFallbackCommand();
+  return native.root || path.resolve(__dirname, "..", "code");
+}
+
+function inspectUcodeBuildSetup({
+  projectRoot = process.cwd(),
+  env = process.env,
+  loadConfigImpl = loadConfig,
+} = {}) {
+  const root = path.resolve(projectRoot);
+  const config = loadConfigImpl(root);
+  const coreRoot = resolveCoreRoot({ env, config });
+  const native = resolveNativeFallbackCommand();
+  const workspaceRoot = root;
+  const distCliPath = Array.isArray(native.args) && native.args[0] ? path.resolve(native.args[0]) : "";
+  const distCliExists = Boolean(distCliPath && fs.existsSync(distCliPath));
+  const nodeModulesPath = "";
+  return {
+    projectRoot: root,
+    coreRoot,
+    workspaceRoot,
+    distCliPath,
+    distCliExists,
+    nodeModulesPath,
+    nodeModulesExists: Boolean(nodeModulesPath && fs.existsSync(nodeModulesPath)),
+  };
+}
+
+function buildUcodeCore({
+  projectRoot = process.cwd(),
+  env = process.env,
+  loadConfigImpl = loadConfig,
+  installIfMissing = true,
+  stdio = "inherit",
+} = {}) {
+  const before = inspectUcodeBuildSetup({
+    projectRoot,
+    env,
+    loadConfigImpl,
+  });
+  void installIfMissing;
+  void stdio;
+  void env;
+  if (!before.distCliExists) {
+    throw new Error(`ucode native core entry missing: ${before.distCliPath || "(unknown)"}`);
+  }
+  return { ...before, steps: ["native-check"] };
+}
+
+module.exports = {
+  inspectUcodeBuildSetup,
+  buildUcodeCore,
+  resolveCoreRoot,
+};

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

@@ -4,6 +4,11 @@ const { runCliAgent } = require("./cliRunner");
 const { normalizeCliOutput } = require("./normalizeOutput");
 const { buildStatus } = require("../daemon/status");
 const { getUfooPaths } = require("../ufoo/paths");
+const {
+  resolveRuntimeConfig,
+  resolveCompletionUrl,
+  resolveAnthropicMessagesUrl,
+} = require("../code/nativeRunner");
 
 function loadSessionState(projectRoot) {
   const dir = getUfooPaths(projectRoot).agentDir;
@@ -75,16 +80,18 @@ function buildSystemPrompt(context) {
   const hasAgents = context.agents && context.agents.length > 0;
   const agentGuidance = hasAgents
     ? ""
-    : "\n- IMPORTANT: No agents are currently online. To execute tasks, you MUST launch agents using ops.launch.\n- Example: {\"reply\":\"Creating agent\",\"ops\":[{\"action\":\"launch\",\"agent\":\"claude\",\"count\":1}]}";
+    : "\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":"launch|close|rename","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:",
@@ -92,6 +99,13 @@ function buildSystemPrompt(context) {
     "- If multiple possible agents, use disambiguate with candidates and no dispatch.",
     "- 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,
     "",
@@ -144,6 +158,111 @@ function extractNickname(prompt) {
   return "";
 }
 
+function isUcodeProvider(value = "") {
+  const text = String(value || "").trim().toLowerCase();
+  return text === "ucode" || text === "ufoo" || text === "ufoo-code";
+}
+
+function stripMarkdownFence(text = "") {
+  const raw = String(text || "").trim();
+  const match = raw.match(/^```(?:json)?\s*\n([\s\S]*?)\n```\s*$/);
+  if (match) return match[1].trim();
+  return raw;
+}
+
+function clipText(value = "", maxChars = 500) {
+  const text = String(value || "");
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}...[truncated]`;
+}
+
+async function runNativeRouterCall({ projectRoot, prompt, systemPrompt, model: requestedModel, timeoutMs = 120000 }) {
+  const runtime = resolveRuntimeConfig({
+    workspaceRoot: projectRoot,
+    provider: "",
+    model: requestedModel,
+  });
+
+  const requestModel = String(runtime.model || "").trim();
+  if (!requestModel) {
+    return { ok: false, error: "ucode model is not configured" };
+  }
+
+  const isAnthropic = runtime.transport === "anthropic-messages";
+  const url = isAnthropic
+    ? resolveAnthropicMessagesUrl(runtime.baseUrl)
+    : resolveCompletionUrl(runtime.baseUrl);
+
+  if (!url) {
+    return { ok: false, error: "ucode baseUrl is not configured" };
+  }
+
+  const headers = { "content-type": "application/json" };
+  let body;
+
+  if (isAnthropic) {
+    headers["anthropic-version"] = "2023-06-01";
+    if (runtime.apiKey) headers["x-api-key"] = runtime.apiKey;
+    body = JSON.stringify({
+      model: requestModel,
+      max_tokens: 4096,
+      system: String(systemPrompt || ""),
+      messages: [{ role: "user", content: String(prompt || "") }],
+      temperature: 0,
+    });
+  } else {
+    if (runtime.apiKey) headers.authorization = `Bearer ${runtime.apiKey}`;
+    const messages = [];
+    if (systemPrompt) messages.push({ role: "system", content: String(systemPrompt) });
+    messages.push({ role: "user", content: String(prompt || "") });
+    body = JSON.stringify({
+      model: requestModel,
+      messages,
+      temperature: 0,
+    });
+  }
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => { try { controller.abort(); } catch {} }, timeoutMs);
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body,
+      signal: controller.signal,
+    });
+
+    if (!response.ok) {
+      const errBody = await response.text().catch(() => "");
+      return { ok: false, error: `provider request failed (${response.status}): ${clipText(errBody)}` };
+    }
+
+    const data = await response.json();
+
+    let text = "";
+    if (isAnthropic) {
+      const content = Array.isArray(data.content) ? data.content : [];
+      text = content
+        .filter((item) => item && item.type === "text")
+        .map((item) => String(item.text || ""))
+        .join("");
+    } else {
+      const choice = data.choices && data.choices[0];
+      text = choice && choice.message && typeof choice.message.content === "string"
+        ? choice.message.content
+        : "";
+    }
+
+    return { ok: true, output: text.trim() };
+  } catch (err) {
+    const message = err && err.message ? err.message : "native router call failed";
+    return { ok: false, error: message };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 async function runUfooAgent({ projectRoot, prompt, provider, model }) {
   const state = loadSessionState(projectRoot);
   const bus = loadBusSummary(projectRoot);
@@ -152,36 +271,57 @@ async function runUfooAgent({ projectRoot, prompt, provider, model }) {
   const historyPrompt = buildHistoryPrompt(history);
   const fullPrompt = historyPrompt ? `${historyPrompt}User: ${prompt}` : prompt;
 
-  let res = await runCliAgent({
-    provider,
-    model,
-    prompt: fullPrompt,
-    systemPrompt,
-    sessionId: state.data?.sessionId,
-    disableSession: provider === "claude-cli",
-    cwd: projectRoot,
-  });
+  let res;
 
-  if (!res.ok) {
-    const msg = (res.error || "").toLowerCase();
-    if (msg.includes("session id") || msg.includes("session-id") || msg.includes("already in use")) {
-      res = await runCliAgent({
-        provider,
-        model,
-        prompt: fullPrompt,
-        systemPrompt,
-        sessionId: undefined,
-        disableSession: provider === "claude-cli",
-        cwd: projectRoot,
-      });
+  if (isUcodeProvider(provider)) {
+    // Native path: direct HTTP to LLM API, no CLI binary needed
+    res = await runNativeRouterCall({
+      projectRoot,
+      prompt: fullPrompt,
+      systemPrompt,
+      model,
+    });
+    if (!res.ok) {
+      return { ok: false, error: res.error };
     }
-  }
+    // Native path returns { ok, output } where output is raw text
+    res = { ok: true, output: res.output, sessionId: "" };
+  } else {
+    // CLI path: spawn codex/claude binary
+    res = await runCliAgent({
+      provider,
+      model,
+      prompt: fullPrompt,
+      systemPrompt,
+      sessionId: state.data?.sessionId,
+      disableSession: provider === "claude-cli",
+      cwd: projectRoot,
+    });
 
-  if (!res.ok) {
-    return { ok: false, error: res.error };
+    if (!res.ok) {
+      const msg = (res.error || "").toLowerCase();
+      if (msg.includes("session id") || msg.includes("session-id") || msg.includes("already in use")) {
+        res = await runCliAgent({
+          provider,
+          model,
+          prompt: fullPrompt,
+          systemPrompt,
+          sessionId: undefined,
+          disableSession: provider === "claude-cli",
+          cwd: projectRoot,
+        });
+      }
+    }
+
+    if (!res.ok) {
+      return { ok: false, error: res.error };
+    }
   }
 
-  const text = normalizeCliOutput(res.output);
+  const rawText = isUcodeProvider(provider)
+    ? String(res.output || "").trim()
+    : normalizeCliOutput(res.output);
+  const text = stripMarkdownFence(rawText);
   let payload = null;
   try {
     payload = JSON.parse(text);
@@ -205,7 +345,7 @@ async function runUfooAgent({ projectRoot, prompt, provider, model }) {
   saveSessionState(projectRoot, {
     provider,
     model,
-    sessionId: res.sessionId,
+    sessionId: res.sessionId || "",
     updated_at: new Date().toISOString(),
   });