@agentprojectcontext/apx 1.8.2 → 1.10.0

package/src/daemon/super-agent-tools/tools/call-runtime.js

@@ -1,4 +1,12 @@
+import fs from "node:fs";
+import path from "node:path";
 import { readAgents } from "../../../core/parser.js";
+import {
+  buildApfHint,
+  closeRuntimeSession,
+  createRuntimeSession,
+  extractApfResult,
+} from "../../apc-runtime-context.js";
 import { getRuntime, RUNTIME_IDS } from "../../runtimes/index.js";
 import { buildAgentSystem, confirmedProperty, resolveProject } from "../helpers.js";
 
@@ -20,37 +28,70 @@ function resolveProjectForAgent(projects, project, slug) {
   return resolveProject(projects, project);
 }
 
+function projectName(project) {
+  try {
+    const meta = JSON.parse(fs.readFileSync(path.join(project.path, ".apc", "project.json"), "utf8"));
+    if (meta.name) return meta.name;
+  } catch {}
+  return path.basename(project.path);
+}
+
+function buildRuntimeSystem(project, agent, runtime, sessionId, caller) {
+  const agentSlug = agent?.slug || "apx";
+  const hint = buildApfHint({
+    projectName: projectName(project),
+    projectPath: project.path,
+    agentSlug,
+    sessionId,
+  });
+  if (agent) {
+    return buildAgentSystem(project, agent, {
+      invocation: "runtime",
+      runtime,
+      caller,
+      extraParts: [hint],
+    });
+  }
+
+  return [
+    "You are APX running inside an external coding runtime.",
+    "No APC agent was explicitly selected for this run.",
+    "Use the project context and runtime tools directly. Do not impersonate a project agent.",
+    hint,
+  ].join("\n\n");
+}
+
 export default {
   name: "call_runtime",
   schema: {
     type: "function",
     function: {
       name: "call_runtime",
-      description: "Spawn an external CLI runtime (Claude Code, Codex, OpenCode, Aider) impersonating an APC agent.",
+      description: "Spawn an external CLI runtime (Claude Code, Codex, OpenCode, Aider, Cursor Agent, Gemini CLI, Qwen Code), optionally impersonating an APC agent.",
       parameters: {
         type: "object",
         properties: {
           project: { type: "string" },
-          agent: { type: "string", description: "APC agent slug from AGENTS.md, not runtime name" },
+          agent: { type: "string", description: "Optional APC agent slug from AGENTS.md, not runtime name. Omit when the user did not name an agent." },
           runtime: {
             type: "string",
-            enum: ["claude-code", "codex", "opencode", "aider"],
+            enum: RUNTIME_IDS,
             description: "external CLI runtime",
           },
           prompt: { type: "string" },
           timeout_s: { type: "integer", description: "seconds before SIGTERM; default 300" },
           confirmed: confirmedProperty("true only after explicit user confirmation for this exact runtime command"),
         },
-        required: ["agent", "runtime", "prompt"],
+        required: ["runtime", "prompt"],
       },
     },
   },
   makeHandler: ({ projects, requirePermission }) => async ({ project, agent: slug, runtime, prompt, timeout_s = 300, confirmed = false }) => {
     requirePermission("call_runtime", { dangerous: true, confirmed });
 
-    const p = resolveProjectForAgent(projects, project, slug);
-    const agent = readAgents(p.path).find((a) => a.slug === slug);
-    if (!agent) {
+    const p = slug ? resolveProjectForAgent(projects, project, slug) : resolveProject(projects, project);
+    const agent = slug ? readAgents(p.path).find((a) => a.slug === slug) : null;
+    if (slug && !agent) {
       const directory = projects.list().map((entry) => ({
         project: entry.name,
         kind: entry.id === 0 ? "default" : "project",
@@ -67,45 +108,74 @@ export default {
       return { error: `${e.message}. Available runtimes: ${RUNTIME_IDS.join(", ")}` };
     }
 
-    const r = await rt.run({
-      system: buildAgentSystem(p, agent, {
-        invocation: "runtime",
-        runtime,
-        caller: "super_agent_tool",
-      }),
-      prompt,
-      cwd: p.path,
-      timeoutMs: timeout_s * 1000,
+    const actor = agent?.slug || "apx";
+    const session = createRuntimeSession({
+      projectRoot: p.path,
+      storageRoot: p.storagePath,
+      agentSlug: actor,
+      runtime,
+      title: `Runtime: ${runtime}${agent ? ` (${agent.slug})` : ""}`,
     });
 
-    p.logMessage({
-      agent_slug: slug,
-      channel: "runtime",
-      direction: "in",
-      author: "user",
-      body: prompt,
-      meta: { runtime, invoked_by: "super_agent_tool" },
-    });
-    p.logMessage({
-      agent_slug: slug,
-      channel: "runtime",
-      direction: "out",
-      author: slug,
-      body: r.output || "",
-      meta: {
+    try {
+      const r = await rt.run({
+        system: buildRuntimeSystem(p, agent, runtime, session.id, "super_agent_tool"),
+        prompt,
+        cwd: p.path,
+        timeoutMs: timeout_s * 1000,
+      });
+
+      const result = extractApfResult(r.output) || (r.output || "").slice(0, 200);
+      closeRuntimeSession({
+        filePath: session.path,
+        externalSessionPath: r.externalSessionPath || null,
+        exitCode: r.exitCode,
+        result,
+      });
+
+      p.logMessage({
+        agent_slug: actor,
+        channel: "runtime",
+        direction: "in",
+        author: "user",
+        body: prompt,
+        meta: { runtime, invoked_by: "super_agent_tool", apc_session: session.id },
+      });
+      p.logMessage({
+        agent_slug: actor,
+        channel: "runtime",
+        direction: "out",
+        author: actor,
+        body: r.output || "",
+        meta: {
+          runtime,
+          exit_code: r.exitCode,
+          external_session_path: r.externalSessionPath || null,
+          session_id: r.sessionId || null,
+          apc_session: session.id,
+          invoked_by: "super_agent_tool",
+        },
+      });
+
+      return {
         runtime,
+        agent: agent?.slug || null,
+        apc_session: session.id,
         exit_code: r.exitCode,
+        output: (r.output || "").slice(0, 4000),
+        truncated: (r.output || "").length > 4000,
         external_session_path: r.externalSessionPath || null,
-        invoked_by: "super_agent_tool",
-      },
-    });
-
-    return {
-      runtime,
-      exit_code: r.exitCode,
-      output: (r.output || "").slice(0, 4000),
-      truncated: (r.output || "").length > 4000,
-      external_session_path: r.externalSessionPath || null,
-    };
+        session_id: r.sessionId || null,
+      };
+    } catch (e) {
+      try {
+        closeRuntimeSession({
+          filePath: session.path,
+          exitCode: -1,
+          result: `error: ${e.message.slice(0, 200)}`,
+        });
+      } catch {}
+      throw e;
+    }
   },
 };

package/src/daemon/super-agent-tools/tools/search-files.js

@@ -0,0 +1,66 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { resolveProject, safePathJoin } from "../helpers.js";
+
+const execFileAsync = promisify(execFile);
+
+export default {
+  name: "search_files",
+  schema: {
+    type: "function",
+    function: {
+      name: "search_files",
+      description: "Search for text patterns inside project files using ripgrep or grep.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "The text or regex pattern to search for." },
+          project: { type: "string" },
+          path: { type: "string", description: "relative path inside the project to restrict search; default '.'" },
+        },
+        required: ["query"],
+      },
+    },
+  },
+  makeHandler: ({ projects, requirePermission }) => async ({ query, project, path: sub = "." } = {}) => {
+    // Optional permission check if it's considered destructive, but search is safe read-only
+    await requirePermission("search_files", { query, project, path: sub }, "safe");
+    
+    const p = resolveProject(projects, project);
+    const target = safePathJoin(p.path, sub);
+
+    try {
+      const { stdout } = await execFileAsync("rg", ["-n", "--no-heading", "--color=never", query, target], {
+        cwd: p.path,
+        maxBuffer: 5 * 1024 * 1024,
+      });
+      return formatResults(stdout);
+    } catch (e) {
+      if (e.code === "ENOENT" || e.message.includes("ENOENT")) {
+        try {
+          const { stdout } = await execFileAsync("grep", ["-rn", query, target], {
+            cwd: p.path,
+            maxBuffer: 5 * 1024 * 1024,
+          });
+          return formatResults(stdout);
+        } catch (e2) {
+           if (e2.code === 1) return { result: "No matches found." };
+           throw new Error(`grep failed: ${e2.message}`);
+        }
+      }
+      if (e.code === 1) return { result: "No matches found." };
+      return { error: `search failed: ${e.message}` };
+    }
+  },
+};
+
+function formatResults(stdout) {
+  if (!stdout) return { result: "No matches found." };
+  const lines = stdout.split('\n').slice(0, 100);
+  const out = lines.join('\n');
+  if (lines.length >= 100) {
+    return { result: out + '\n...(truncated)' };
+  }
+  return { result: out };
+}
+

package/src/daemon/super-agent.js

@@ -34,6 +34,7 @@ Useful CLI facts:
 - Permission mode: apx permission show; apx permission set total|automatico|permiso.
 - Routines: apx routine list|get|history|run|add. Autonomous super-agent routines use kind super_agent.
 - Routine design: if the user asks for an agent to think, decide, write, or reply, create an exec_agent routine with spec.agent and spec.prompt. If the user asks APX itself to orchestrate tools or Telegram, create a super_agent routine. If the request is only a deterministic command, create a shell routine. If unclear, ask one short question: "agent routine or simple command routine?"
+- Routine schedules: APX supports standard cron expressions (e.g. '*/5 * * * *'), OR 'every:<number><s|m|h|d>' (e.g. 'every:60s'), OR 'once:<iso-8601>'.
 - Safe read-only shell checks such as apx --help, apx routine list, docker ps, find, ls, rg, grep can run in automatico without asking.
 
 Channel context:
@@ -42,20 +43,6 @@ Channel context:
 
 You HAVE tools. THE FIRST THING you do for any factual question is call a tool. Do not ask the user to specify a project unless the tool itself fails.
 
-Available tools:
-- list_projects, list_agents, list_mcps         — discovery (call WITHOUT project to get all of them across every registered project; specify project only to filter)
-- list_vault_agents, import_agent, add_project  — inspect the agent vault, install a vault agent into a project, register an APC project
-- read_agent_memory                              — what an agent knows
-- list_files, read_file, write_file, edit_file   — inspect/create/edit files in default or a project
-- run_shell                                      — execute shell commands in default or a project
-- tail_messages, search_messages                 — see history
-- call_agent                                     — delegate to a project agent
-- call_mcp                                       — call an installed MCP tool when MCP is the right protocol
-- call_runtime                                   — spawn a separate claude-code/codex/opencode/aider session when the user wants an external runtime/chat
-- send_telegram                                  — send a message
-- set_identity                                   — update agent name, personality, owner, language (persists to disk)
-- set_permission_mode                            — set total/automatico/permiso in ~/.apx/config.json
-
 HARD RULES (do not deviate):
 1. NEVER invent project names, agent slugs, model ids, MCP names or paths. ALWAYS look them up via list_* first.
 2. If the user asks for agents, lists, inventory, or "what exists" without specifying a project, that means **all of them** — call the tool WITHOUT a project argument and the result will include every project.
@@ -66,8 +53,8 @@ HARD RULES (do not deviate):
 7. Stay brief: under 6 sentences unless asked for detail.
 8. You DO see recent prior turns of this chat as previous messages when applicable. **Use them ONLY to disambiguate references** (e.g. "el primero" → first project mentioned earlier). For ANY factual data — agent details, MCP details, file contents, memory — RE-CALL the tool. Past turns are context, not a cache. Models change, agents change, files change.
 9. /reset or /new from the user means "forget previous turns and answer this one fresh" — if you see those prefixes the operator already cleared the context for you.
-10. ACTION RULE: use direct tools for direct work. run_shell executes commands; write_file/edit_file modify files. call_runtime is only for spawning a separate external runtime/chat. call_mcp is only for an MCP server/tool.
-11. DISPATCH RULE: when the user asks a named agent to work inside Claude, Codex, OpenCode, or Aider, that is a call_runtime request. Look up the agent slug with list_agents if needed, then call call_runtime({agent: <slug>, runtime: 'claude-code'|'codex'|'opencode'|'aider', prompt: <user's request>}). The agent's declared model (in AGENTS.md) is IGNORED in this case; the runtime supplies the model. Memory + skills of the agent become the system prompt of the runtime.
+10. DELEGATION RULE: when the user asks an agent to do a task, use call_agent (unless they specify opening it in a runtime, then see rule 11).
+11. DISPATCH RULE: when the user asks to work inside Claude, Codex, OpenCode, Aider, Cursor, Gemini CLI, or Qwen Code, use call_runtime({runtime: 'claude-code'|'codex'|'opencode'|'aider'|'cursor-agent'|'gemini-cli'|'qwen-code', prompt: <user's request>}). If they explicitly name an agent to spawn, pass agent: <slug>. If they don't name an agent, DO NOT pass an agent argument. When an agent is passed, its memory + skills become the system prompt of the runtime.
 12. PROJECT RULE: when the user gives no project, use project "default". Do not infer a non-default project from old chat history unless the user references it. If they mention a path or project name, look it up or add it with add_project.
 13. VAULT RULE: when the user wants a new existing agent/template, call list_vault_agents first. If a suitable vault agent exists, import_agent into the chosen project. If none fits, say briefly what is missing.
 14. NO-PENDING RULE: never say "give me a second", "I will do it", or "I will try later" as a final answer. Either call the tool in this same turn or say what blocks you.
@@ -99,11 +86,13 @@ export async function runSuperAgent({
   prompt,
   contextNote = "",
   previousMessages = [],
+  overrideModel = null,
 }) {
   if (!isSuperAgentEnabled(globalConfig)) {
     throw new Error("super-agent not enabled (set super_agent.enabled and .model in ~/.apx/config.json)");
   }
   const sa = globalConfig.super_agent;
+  const activeModel = overrideModel || sa.model;
 
   // Tiny project hint — JUST names + ids, no detail. The model is expected to
   // call list_agents / list_mcps / read_agent_memory / etc. for everything
@@ -153,7 +142,7 @@ export async function runSuperAgent({
 
   for (let iter = 0; iter < MAX_TOOL_ITERS; iter++) {
     const result = await callEngine({
-      modelId: sa.model,
+      modelId: activeModel,
       system,
       messages: conversation,
       config: globalConfig,

package/src/mcp/index.js

@@ -95,7 +95,7 @@ server.tool(
   {
     slug: z.string().describe("Agent slug"),
     prompt: z.string().describe("Prompt / task for the agent"),
-    runtime: z.string().optional().describe("Runtime: claude-code | codex (default: claude-code)"),
+    runtime: z.string().optional().describe("Runtime: claude-code | codex | opencode | aider | cursor-agent | gemini-cli | qwen-code (default: claude-code)"),
   },
   async ({ slug, prompt, runtime }) => {
     const proj = await resolveProject();