u-foo 1.9.8 → 2.1.0

package/src/tools/tier0/readOpenDecisions.js

@@ -0,0 +1,14 @@
+const { READ_OPEN_DECISIONS_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { readOpenDecisionsHandler } = require("../handlers/readOpenDecisions");
+
+module.exports = createToolDefinition({
+  name: READ_OPEN_DECISIONS_SCHEMA.name,
+  description: READ_OPEN_DECISIONS_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_0,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER, CALLER_TIERS.WORKER],
+  inputSchema: READ_OPEN_DECISIONS_SCHEMA.input_schema,
+  outputSchema: READ_OPEN_DECISIONS_SCHEMA.output_schema,
+  schemaVersion: READ_OPEN_DECISIONS_SCHEMA.schema_version,
+  handler: readOpenDecisionsHandler,
+});

package/src/tools/tier0/readProjectRegistry.js

@@ -0,0 +1,14 @@
+const { READ_PROJECT_REGISTRY_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { readProjectRegistryHandler } = require("../handlers/readProjectRegistry");
+
+module.exports = createToolDefinition({
+  name: READ_PROJECT_REGISTRY_SCHEMA.name,
+  description: READ_PROJECT_REGISTRY_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_0,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER, CALLER_TIERS.WORKER],
+  inputSchema: READ_PROJECT_REGISTRY_SCHEMA.input_schema,
+  outputSchema: READ_PROJECT_REGISTRY_SCHEMA.output_schema,
+  schemaVersion: READ_PROJECT_REGISTRY_SCHEMA.schema_version,
+  handler: readProjectRegistryHandler,
+});

package/src/tools/tier0/readPromptHistory.js

@@ -0,0 +1,14 @@
+const { READ_PROMPT_HISTORY_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { readPromptHistoryHandler } = require("../handlers/readPromptHistory");
+
+module.exports = createToolDefinition({
+  name: READ_PROMPT_HISTORY_SCHEMA.name,
+  description: READ_PROMPT_HISTORY_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_0,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER, CALLER_TIERS.WORKER],
+  inputSchema: READ_PROMPT_HISTORY_SCHEMA.input_schema,
+  outputSchema: READ_PROMPT_HISTORY_SCHEMA.output_schema,
+  schemaVersion: READ_PROMPT_HISTORY_SCHEMA.schema_version,
+  handler: readPromptHistoryHandler,
+});

package/src/tools/tier1/ackBus.js

@@ -0,0 +1,14 @@
+const { ACK_BUS_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { ackBusHandler } = require("../handlers/ackBus");
+
+module.exports = createToolDefinition({
+  name: ACK_BUS_SCHEMA.name,
+  description: ACK_BUS_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_1,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER, CALLER_TIERS.WORKER],
+  inputSchema: ACK_BUS_SCHEMA.input_schema,
+  outputSchema: ACK_BUS_SCHEMA.output_schema,
+  schemaVersion: ACK_BUS_SCHEMA.schema_version,
+  handler: ackBusHandler,
+});

package/src/tools/tier1/dispatchMessage.js

@@ -0,0 +1,14 @@
+const { DISPATCH_MESSAGE_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { dispatchMessageHandler } = require("../handlers/dispatchMessage");
+
+module.exports = createToolDefinition({
+  name: DISPATCH_MESSAGE_SCHEMA.name,
+  description: DISPATCH_MESSAGE_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_1,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER, CALLER_TIERS.WORKER],
+  inputSchema: DISPATCH_MESSAGE_SCHEMA.input_schema,
+  outputSchema: DISPATCH_MESSAGE_SCHEMA.output_schema,
+  schemaVersion: DISPATCH_MESSAGE_SCHEMA.schema_version,
+  handler: dispatchMessageHandler,
+});

package/src/tools/tier1/routeAgent.js

@@ -0,0 +1,14 @@
+const { ROUTE_AGENT_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { buildDormantHandler } = require("../unimplemented");
+
+module.exports = createToolDefinition({
+  name: ROUTE_AGENT_SCHEMA.name,
+  description: ROUTE_AGENT_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_1,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER, CALLER_TIERS.WORKER],
+  inputSchema: ROUTE_AGENT_SCHEMA.input_schema,
+  outputSchema: ROUTE_AGENT_SCHEMA.output_schema,
+  schemaVersion: ROUTE_AGENT_SCHEMA.schema_version,
+  handler: buildDormantHandler(ROUTE_AGENT_SCHEMA.name),
+});

package/src/tools/tier2/closeAgent.js

@@ -0,0 +1,14 @@
+const { CLOSE_AGENT_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { closeAgentHandler } = require("../handlers/tier2");
+
+module.exports = createToolDefinition({
+  name: CLOSE_AGENT_SCHEMA.name,
+  description: CLOSE_AGENT_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_2,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER],
+  inputSchema: CLOSE_AGENT_SCHEMA.input_schema,
+  outputSchema: CLOSE_AGENT_SCHEMA.output_schema,
+  schemaVersion: CLOSE_AGENT_SCHEMA.schema_version,
+  handler: closeAgentHandler,
+});

package/src/tools/tier2/launchAgent.js

@@ -0,0 +1,14 @@
+const { LAUNCH_AGENT_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { launchAgentHandler } = require("../handlers/tier2");
+
+module.exports = createToolDefinition({
+  name: LAUNCH_AGENT_SCHEMA.name,
+  description: LAUNCH_AGENT_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_2,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER],
+  inputSchema: LAUNCH_AGENT_SCHEMA.input_schema,
+  outputSchema: LAUNCH_AGENT_SCHEMA.output_schema,
+  schemaVersion: LAUNCH_AGENT_SCHEMA.schema_version,
+  handler: launchAgentHandler,
+});

package/src/tools/tier2/manageCron.js

@@ -0,0 +1,14 @@
+const { MANAGE_CRON_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { manageCronHandler } = require("../handlers/tier2");
+
+module.exports = createToolDefinition({
+  name: MANAGE_CRON_SCHEMA.name,
+  description: MANAGE_CRON_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_2,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER],
+  inputSchema: MANAGE_CRON_SCHEMA.input_schema,
+  outputSchema: MANAGE_CRON_SCHEMA.output_schema,
+  schemaVersion: MANAGE_CRON_SCHEMA.schema_version,
+  handler: manageCronHandler,
+});

package/src/tools/tier2/renameAgent.js

@@ -0,0 +1,14 @@
+const { RENAME_AGENT_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { renameAgentHandler } = require("../handlers/tier2");
+
+module.exports = createToolDefinition({
+  name: RENAME_AGENT_SCHEMA.name,
+  description: RENAME_AGENT_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_2,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER],
+  inputSchema: RENAME_AGENT_SCHEMA.input_schema,
+  outputSchema: RENAME_AGENT_SCHEMA.output_schema,
+  schemaVersion: RENAME_AGENT_SCHEMA.schema_version,
+  handler: renameAgentHandler,
+});

package/src/tools/types.js

@@ -0,0 +1,75 @@
+const TOOL_TIERS = Object.freeze({
+  TIER_0: "tier0-read",
+  TIER_1: "tier1-coordination",
+  TIER_2: "tier2-orchestration",
+});
+
+const CALLER_TIERS = Object.freeze({
+  CONTROLLER: "controller",
+  WORKER: "worker",
+});
+
+const DEFAULT_SCHEMA_VERSION = "1.0";
+
+function normalizeCallerTier(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+function createToolDefinition({
+  name,
+  description,
+  tier,
+  allowedCallerTiers,
+  inputSchema,
+  outputSchema,
+  handler,
+  schemaVersion,
+}) {
+  const allowed = Object.freeze([...(allowedCallerTiers || [])]);
+  return Object.freeze({
+    name,
+    description,
+    tier,
+    schema_version: String(schemaVersion || DEFAULT_SCHEMA_VERSION),
+    allowedCallerTiers: allowed,
+    allowed_tiers: allowed,
+    input_schema: Object.freeze(inputSchema),
+    output_schema: outputSchema ? Object.freeze(outputSchema) : null,
+    handler,
+  });
+}
+
+function buildCallerTierError(toolDef, callerTier, auditCtx = {}) {
+  const tier = normalizeCallerTier(callerTier) || "unknown";
+  const message = `caller_tier "${tier}" is not allowed to invoke tool "${toolDef.name}"`;
+  const err = new Error(message);
+  err.code = "forbidden_caller_tier";
+  err.tool_name = toolDef.name;
+  err.caller_tier = tier;
+  err.allowed_tiers = Array.isArray(toolDef.allowed_tiers) ? toolDef.allowed_tiers.slice() : [];
+  if (auditCtx && auditCtx.turn_id) err.turn_id = String(auditCtx.turn_id);
+  if (auditCtx && auditCtx.tool_call_id) err.tool_call_id = String(auditCtx.tool_call_id);
+  return err;
+}
+
+function assertCallerTierAllowed(toolDef, callerTier, auditCtx = {}) {
+  if (!toolDef || !Array.isArray(toolDef.allowed_tiers)) {
+    const err = new Error("tool definition missing allowed_tiers metadata");
+    err.code = "invalid_tool_definition";
+    throw err;
+  }
+  const tier = normalizeCallerTier(callerTier);
+  if (!tier || !toolDef.allowed_tiers.includes(tier)) {
+    throw buildCallerTierError(toolDef, callerTier, auditCtx);
+  }
+}
+
+module.exports = {
+  TOOL_TIERS,
+  CALLER_TIERS,
+  DEFAULT_SCHEMA_VERSION,
+  createToolDefinition,
+  assertCallerTierAllowed,
+  buildCallerTierError,
+  normalizeCallerTier,
+};

package/src/tools/unimplemented.js

@@ -0,0 +1,13 @@
+function buildDormantHandler(name) {
+  return async function dormantToolHandler() {
+    return {
+      ok: false,
+      error: `${name} is not wired in this phase`,
+      phase: "phase0-scaffold",
+    };
+  };
+}
+
+module.exports = {
+  buildDormantHandler,
+};

package/src/ufoo/paths.js

@@ -4,7 +4,9 @@ function getUfooPaths(projectRoot) {
   const ufooDir = path.join(projectRoot, ".ufoo");
   const busDir = path.join(ufooDir, "bus");
   const agentDir = path.join(ufooDir, "agent");
+  const memoryDir = path.join(ufooDir, "memory");
   const agentsFile = path.join(agentDir, "all-agents.json");
+  const memoryFile = path.join(memoryDir, "memory.jsonl");
 
   const busQueuesDir = path.join(busDir, "queues");
   const busEventsDir = path.join(busDir, "events");
@@ -27,7 +29,9 @@ function getUfooPaths(projectRoot) {
     ufooDir,
     busDir,
     agentDir,
+    memoryDir,
     agentsFile,
+    memoryFile,
     busQueuesDir,
     busEventsDir,
     busLogsDir,

package/bin/ufoo-assistant-agent.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-
-const { runAssistantStdio } = require("../src/assistant/stdio");
-
-runAssistantStdio();

package/bin/ufoo-engine.js

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-
-const { runUfooEngineCli } = require("../src/assistant/ufooEngineCli");
-
-function readStdin() {
-  return new Promise((resolve) => {
-    let data = "";
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", (chunk) => {
-      data += chunk;
-    });
-    process.stdin.on("end", () => resolve(data));
-    process.stdin.resume();
-  });
-}
-
-(async () => {
-  const stdinText = await readStdin();
-  const result = await runUfooEngineCli({
-    argv: process.argv.slice(2),
-    stdinText,
-  });
-  process.stdout.write(result.output);
-  process.exitCode = result.exitCode;
-})();

package/src/assistant/agent.js

@@ -1,261 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const { runCliAgent } = require("../agent/cliRunner");
-const { normalizeCliOutput } = require("../agent/normalizeOutput");
-const { resolveAssistantEngine, runExternalAssistantEngine } = require("./engine");
-const { DEFAULT_ASSISTANT_TIMEOUT_MS, normalizeAssistantTimeoutMs } = require("./constants");
-const { getUfooPaths } = require("../ufoo/paths");
-
-const ASSISTANT_JSON_SCHEMA = {
-  type: "object",
-  properties: {
-    ok: { type: "boolean" },
-    summary: { type: "string" },
-    artifacts: {
-      type: "array",
-      items: { type: "string" },
-    },
-    logs: {
-      type: "array",
-      items: { type: "string" },
-    },
-    error: { type: "string" },
-    metrics: {
-      type: "object",
-      additionalProperties: true,
-    },
-  },
-  required: ["ok", "summary"],
-};
-
-function parseTaskPayload(payload = {}) {
-  const projectRoot = typeof payload.project_root === "string" ? payload.project_root : process.cwd();
-  const provider = typeof payload.provider === "string" ? payload.provider : "";
-  const fallbackProvider = typeof payload.fallback_provider === "string" ? payload.fallback_provider : "";
-  const model = typeof payload.model === "string" ? payload.model : "";
-  const task = typeof payload.task === "string" ? payload.task.trim() : "";
-  const kind = typeof payload.kind === "string" && payload.kind ? payload.kind : "mixed";
-  const context = typeof payload.context === "string" ? payload.context : "";
-  const expectText = typeof payload.expect === "string" ? payload.expect : "";
-  const timeoutMs = normalizeAssistantTimeoutMs(payload.timeout_ms, DEFAULT_ASSISTANT_TIMEOUT_MS);
-
-  return {
-    projectRoot,
-    provider,
-    fallbackProvider,
-    model,
-    task,
-    kind,
-    context,
-    expect: expectText,
-    timeoutMs,
-  };
-}
-
-function normalizeAssistantPayload(parsed, fallbackError = "") {
-  if (!parsed || typeof parsed !== "object") {
-    const text = String(parsed || "").trim();
-    if (text) {
-      return {
-        ok: true,
-        summary: text,
-        artifacts: [],
-        logs: [],
-        error: "",
-        metrics: {},
-      };
-    }
-    return {
-      ok: false,
-      summary: "",
-      artifacts: [],
-      logs: [],
-      error: fallbackError || "assistant returned invalid payload",
-      metrics: {},
-    };
-  }
-
-  return {
-    ok: parsed.ok !== false,
-    summary: typeof parsed.summary === "string" ? parsed.summary : "",
-    artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts : [],
-    logs: Array.isArray(parsed.logs) ? parsed.logs : [],
-    error: typeof parsed.error === "string" ? parsed.error : "",
-    metrics: parsed.metrics && typeof parsed.metrics === "object" ? parsed.metrics : {},
-  };
-}
-
-function buildAssistantSystemPrompt(taskInput) {
-  return [
-    "You are ufoo-assistant-agent, a private helper for ufoo-agent.",
-    "You are NOT exposed on the event bus.",
-    "Execute the requested task using local project context and shell/tool access as needed.",
-    "Return ONLY JSON that matches schema: {ok, summary, artifacts, logs, error, metrics}.",
-    "Rules:",
-    "- summary: concise factual result for ufoo-agent to consume.",
-    "- artifacts: key files/commands/findings (short strings).",
-    "- logs: optional concise trace points.",
-    "- error: non-empty only when ok=false.",
-    "- Do not include markdown or prose outside JSON.",
-    "",
-    "Task input:",
-    JSON.stringify(taskInput),
-  ].join("\n");
-}
-
-function getAssistantStatePaths(projectRoot) {
-  const dir = getUfooPaths(projectRoot).agentDir;
-  return {
-    sessionDir: path.join(dir, "sessions"),
-  };
-}
-
-function getAssistantSessionStateFile(projectRoot, engine = "assistant") {
-  const { sessionDir } = getAssistantStatePaths(projectRoot);
-  return path.join(sessionDir, `ufoo-assistant-${engine}.json`);
-}
-
-function loadAssistantState(projectRoot, engine = "assistant") {
-  const file = getAssistantSessionStateFile(projectRoot, engine);
-  try {
-    return JSON.parse(fs.readFileSync(file, "utf8"));
-  } catch {
-    return null;
-  }
-}
-
-function saveAssistantState(projectRoot, engine = "assistant", state = {}) {
-  const { sessionDir } = getAssistantStatePaths(projectRoot);
-  fs.mkdirSync(sessionDir, { recursive: true });
-  const file = getAssistantSessionStateFile(projectRoot, engine);
-  fs.writeFileSync(file, JSON.stringify(state, null, 2));
-}
-
-function isSessionError(errorText = "") {
-  const text = String(errorText || "").toLowerCase();
-  return text.includes("session id")
-    || text.includes("session-id")
-    || text.includes("already in use");
-}
-
-async function runAssistantAgentTask(payload = {}) {
-  const taskInput = parseTaskPayload(payload);
-  const startedAt = Date.now();
-
-  if (!taskInput.task) {
-    return {
-      ok: false,
-      summary: "",
-      artifacts: [],
-      logs: [],
-      error: "missing task",
-      metrics: { duration_ms: Date.now() - startedAt },
-    };
-  }
-
-  const systemPrompt = buildAssistantSystemPrompt(taskInput);
-  const engine = resolveAssistantEngine({
-    projectRoot: taskInput.projectRoot,
-    requestedProvider: taskInput.provider,
-    requestedModel: taskInput.model,
-    fallbackProvider: taskInput.fallbackProvider,
-  });
-  const assistantState = loadAssistantState(taskInput.projectRoot, engine.engine);
-
-  let cliRes = null;
-  if (engine.kind === "external") {
-    cliRes = await runExternalAssistantEngine({
-      engine,
-      timeoutMs: taskInput.timeoutMs,
-      payload: {
-        request_type: "assistant_task",
-        schema_version: 1,
-        engine: engine.engine,
-        project_root: taskInput.projectRoot,
-        task: taskInput.task,
-        kind: taskInput.kind,
-        context: taskInput.context,
-        expect: taskInput.expect,
-        model: engine.model || "",
-        session_id: assistantState && typeof assistantState.sessionId === "string" ? assistantState.sessionId : "",
-        timeout_ms: taskInput.timeoutMs,
-      },
-    });
-  } else {
-    const runCli = async (sessionId) => runCliAgent({
-      provider: engine.provider,
-      model: engine.model,
-      prompt: taskInput.task,
-      systemPrompt,
-      jsonSchema: ASSISTANT_JSON_SCHEMA,
-      disableSession: false,
-      sessionId,
-      cwd: taskInput.projectRoot,
-      timeoutMs: taskInput.timeoutMs,
-      sandbox: taskInput.kind === "explore" ? "read-only" : "workspace-write",
-    });
-
-    const preferredSession = assistantState && typeof assistantState.sessionId === "string"
-      ? assistantState.sessionId
-      : undefined;
-    cliRes = await runCli(preferredSession);
-    if (!cliRes.ok && preferredSession && isSessionError(cliRes.error)) {
-      cliRes = await runCli(undefined);
-    }
-  }
-
-  if (!cliRes || cliRes.ok === false) {
-    return {
-      ok: false,
-      summary: "",
-      artifacts: [],
-      logs: [],
-      error: (cliRes && cliRes.error) || "assistant cli failed",
-      metrics: { duration_ms: Date.now() - startedAt },
-    };
-  }
-
-  let result;
-  if (engine.kind === "external") {
-    result = normalizeAssistantPayload(cliRes);
-  } else {
-    const normalized = normalizeCliOutput(cliRes.output);
-    let parsed;
-    try {
-      parsed = JSON.parse(normalized);
-    } catch {
-      parsed = normalized;
-    }
-    result = normalizeAssistantPayload(parsed);
-  }
-
-  result.metrics = {
-    ...result.metrics,
-    duration_ms: Date.now() - startedAt,
-  };
-  if (!result.ok && !result.error) {
-    result.error = "assistant task failed";
-  }
-
-  saveAssistantState(taskInput.projectRoot, engine.engine, {
-    engine: engine.engine,
-    provider: engine.provider || "",
-    model: engine.model || "",
-    sessionId: cliRes && typeof cliRes.sessionId === "string" ? cliRes.sessionId : "",
-    updated_at: new Date().toISOString(),
-  });
-
-  return result;
-}
-
-module.exports = {
-  runAssistantAgentTask,
-  parseTaskPayload,
-  normalizeAssistantPayload,
-  buildAssistantSystemPrompt,
-  getAssistantSessionStateFile,
-  loadAssistantState,
-  saveAssistantState,
-  isSessionError,
-  ASSISTANT_JSON_SCHEMA,
-};