@agentprojectcontext/apx 1.33.1 → 1.35.0

package/src/host/daemon/api/vars.js

@@ -0,0 +1,137 @@
+// Variable management per project. Reads/writes the two APX-owned scopes
+// (project = <storagePath>/vars.json, global = ~/.apx/vars.json) and
+// surfaces a merged effective view with sources annotated.
+//
+//   GET    /projects/:pid/vars              -> { project, global, effective, sources }
+//                                              values masked unless ?reveal=1
+//   GET    /projects/:pid/vars/:name        -> { name, scope, value, masked }
+//                                              ?reveal=1 unmasks
+//   POST   /projects/:pid/vars              -> { ok, name, scope }
+//                                              body { name, value, scope }
+//                                              scope defaults to "project" (or
+//                                              "global" if pid=0).
+//   DELETE /projects/:pid/vars/:name?scope=… 204
+//
+// pid=0 (base project) is the conventional bucket for editing global vars
+// from the web UI; project scope is rejected there because there is no
+// storagePath that belongs to a real project.
+import {
+  loadAllVars,
+  readGlobalVars,
+  readProjectVars,
+  setVar,
+  deleteVar,
+  maskValue,
+} from "#core/vars/index.js";
+
+function normalizeScope(raw, { isBase }) {
+  if (!raw) return isBase ? "global" : "project";
+  const s = String(raw).toLowerCase();
+  if (s === "project" || s === "global") return s;
+  return null;
+}
+
+function maskAll(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) out[k] = maskValue(v);
+  return out;
+}
+
+export function register(app, { project }) {
+  app.get("/projects/:pid/vars", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const reveal = req.query?.reveal === "1" || req.query?.reveal === "true";
+    const { project: proj, global, effective, sources } = loadAllVars({
+      storagePath: p.storagePath,
+    });
+    res.json({
+      scope_hint: String(p.id) === "0" ? "global" : "project",
+      project: reveal ? proj : maskAll(proj),
+      global: reveal ? global : maskAll(global),
+      effective: reveal ? effective : maskAll(effective),
+      sources,
+    });
+  });
+
+  app.get("/projects/:pid/vars/:name", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const name = req.params.name;
+    const proj = p.storagePath ? readProjectVars(p.storagePath) : {};
+    const global = readGlobalVars();
+    let scope = null;
+    let value = null;
+    if (Object.prototype.hasOwnProperty.call(proj, name)) {
+      scope = "project";
+      value = proj[name];
+    } else if (Object.prototype.hasOwnProperty.call(global, name)) {
+      scope = "global";
+      value = global[name];
+    } else {
+      return res.status(404).json({ error: `variable "${name}" not found` });
+    }
+    const reveal = req.query?.reveal === "1" || req.query?.reveal === "true";
+    res.json({
+      name,
+      scope,
+      value: reveal ? value : maskValue(value),
+      masked: !reveal,
+    });
+  });
+
+  app.post("/projects/:pid/vars", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const { name, value } = req.body || {};
+    if (!name || typeof name !== "string") {
+      return res.status(400).json({ error: "name required" });
+    }
+    if (value === undefined || value === null) {
+      return res.status(400).json({ error: "value required" });
+    }
+    const isBase = String(p.id) === "0";
+    const scope = normalizeScope(req.body?.scope, { isBase });
+    if (scope === null) {
+      return res
+        .status(400)
+        .json({ error: `unknown scope "${req.body?.scope}" (use project|global)` });
+    }
+    if (scope === "project" && (!p.storagePath || isBase)) {
+      return res.status(400).json({
+        error: "project scope is not available for the base workspace — use scope=global",
+      });
+    }
+    try {
+      setVar({ storagePath: p.storagePath, scope, name, value });
+    } catch (e) {
+      return res.status(400).json({ error: e.message });
+    }
+    res.status(201).json({ ok: true, name, scope });
+  });
+
+  app.delete("/projects/:pid/vars/:name", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const isBase = String(p.id) === "0";
+    const scope = normalizeScope(req.query?.scope, { isBase });
+    if (scope === null) {
+      return res
+        .status(400)
+        .json({ error: `unknown scope "${req.query?.scope}" (use project|global)` });
+    }
+    if (scope === "project" && (!p.storagePath || isBase)) {
+      return res.status(400).json({
+        error: "project scope is not available for the base workspace",
+      });
+    }
+    let removed;
+    try {
+      removed = deleteVar({ storagePath: p.storagePath, scope, name: req.params.name });
+    } catch (e) {
+      return res.status(400).json({ error: e.message });
+    }
+    if (!removed) return res.status(404).end();
+    res.status(204).end();
+  });
+}

package/src/host/daemon/api/voice.js

@@ -1,5 +1,3 @@
-// eslint-disable-next-line -- import below
-import { CHANNELS } from "#core/constants/channels.js";
 // Daemon HTTP routes for the unified "voice" channel.
 //
 //   POST /voice/turn  { audio?: <base64 or path>, format?, text?, agent?,
@@ -17,268 +15,21 @@ import { CHANNELS } from "#core/constants/channels.js";
 //
 // Channel/agent surfaces (Telegram plugin, overlay) can keep their own
 // pipelines, but they should delegate here when they want a hablada reply.
+//
+// Domain logic (channel context, suggestion parsing, audio decoding) lives in
+// core/. This file is just glue: parse request → call core → format response.
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
-import { randomUUID } from "node:crypto";
 import { readConfig } from "#core/config/index.js";
 import { synthesize } from "#core/voice/tts.js";
-import { transcribe } from "../transcription.js";
+import { transcribe } from "#core/voice/transcription.js";
+import { decodeAudioInput } from "#core/voice/audio-decode.js";
 import { runSuperAgent, isSuperAgentEnabled } from "#core/agent/super-agent.js";
+import { buildVoiceChannelContext } from "#core/agent/channels/voice-context.js";
+import { extractSuggestions } from "#core/agent/suggestions.js";
 import { appendGlobalMessage } from "#core/stores/messages.js";
 import { appendErrorTrace, previewText } from "#core/logging.js";
 
-// ── Channel-aware pre-processor ────────────────────────────────────
-//
-// Each surface that talks to the super-agent (voice overlay on the
-// deck, deck buttons, telegram, raw API) has different ergonomics:
-// what the response will look like, how long it can be, whether the
-// UI can render structured suggestions. `buildChannelContext` is the
-// single place where those decisions live — voice.js passes the
-// channel string from the request body and gets back the context
-// note + system suffix to feed into the super-agent.
-//
-// The shape is intentionally tiny: contextNote becomes the
-// `contextNote` field on the super-agent call (gets prepended to the
-// prompt), systemSuffix is concatenated onto the system prompt to
-// teach the model surface-specific output rules (e.g. trailing
-// ```suggestions JSON block``` on voice/deck).
-function buildChannelContext(channel, { projectId, language = "es" } = {}) {
-  const base = {
-    contextNote: "",
-    systemSuffix: "",
-    wantsSuggestions: false,
-    // Channel id forwarded to runSuperAgent so the matching channels/*.md
-    // formatting block is injected.
-    channel: "",
-    // Forwarded as channelMeta; { voice: true } flags spoken mode.
-    channelMeta: {},
-  };
-  // Project resolution hint.
-  //   - per-project mic (projectId set): use it imperatively, don't ask.
-  //   - global deck mic (no projectId): default to project id=0
-  //     ("default") for actions unless the user names a project out
-  //     loud. Either way, don't pester the user with "¿en qué
-  //     proyecto?" — pick a sensible default and act.
-  const projectHint = projectId
-    ? `\nThe active project is id=${projectId}. For ANY task/note/list ` +
-      `action, pass project_id=${projectId} automatically. Do NOT ask the ` +
-      `user which project — only switch if they explicitly name another.`
-    : `\nThis is the GLOBAL mic (no project in focus). For task/note/list ` +
-      `actions, default to project_id=0 ("default") UNLESS the user names ` +
-      `a project out loud (e.g. "en evolution-registry…", "en el proyecto ` +
-      `apx…") — then resolve that project by name. Never ask "¿en qué ` +
-      `proyecto?"; pick the default and act.`;
-  // Hard language directive — without this the model defaults to its
-  // training-bias English on short Spanish prompts, especially when
-  // the user mixes English-ish product names ("aicrm").
-  const langDirective = language === "es"
-    ? "IMPORTANT: Reply ALWAYS in Spanish (rioplatense/Argentina). The user speaks Spanish."
-    : `IMPORTANT: Reply in language "${language}".`;
-
-  // Surface mapping. Channels are surfaces; "voice" is NOT a surface — it's the
-  // spoken MODE of the deck. All channel FORMATTING now lives in the
-  // channels/*.md + modes/voice.md blocks (injected by buildSuperAgentSystem);
-  // contextNote here carries ONLY per-request dynamic bits (language + project).
-  //   incoming "voice"   → deck surface, spoken
-  //   incoming "deck"    → deck surface, text card
-  //   incoming "desktop" → desktop module, spoken (voice-first)
-  const dynamicNote = `${langDirective}${projectHint}`;
-  switch (channel) {
-    case "voice":
-      return { ...base, contextNote: dynamicNote, systemSuffix: SUGGESTIONS_INSTRUCTION, wantsSuggestions: true, channel: CHANNELS.DECK, channelMeta: { voice: true } };
-    case "deck":
-      return { ...base, contextNote: dynamicNote, systemSuffix: SUGGESTIONS_INSTRUCTION, wantsSuggestions: true, channel: CHANNELS.DECK, channelMeta: {} };
-    case "desktop":
-      return { ...base, contextNote: dynamicNote, systemSuffix: SUGGESTIONS_INSTRUCTION, wantsSuggestions: true, channel: CHANNELS.DESKTOP, channelMeta: { voice: true } };
-    case "telegram":
-      // Format rules live in channels/telegram.md; keep only the dynamic note.
-      return { ...base, contextNote: dynamicNote, channel: CHANNELS.TELEGRAM, channelMeta: {} };
-    default:
-      return { ...base, contextNote: dynamicNote, channel: channel || "api", channelMeta: {} };
-  }
-}
-
-// Balanced suffix. An earlier, more aggressive version ("EJECUTA, no
-// narres — LLAMÁ A LA TOOL") made Gemini call tools for EVERYTHING,
-// even "hola" → it fired send_telegram("hola"). The rule below gates
-// tool use on a *clear* action request and explicitly tells the model
-// to just talk for chit-chat.
-const SUGGESTIONS_INSTRUCTION = `
-
-# Cuándo usar tools
-SOLO llamá una tool cuando el usuario pide CLARAMENTE una acción
-concreta: "creá una tarea …", "mandá un telegram …", "listá …",
-"abrí …", "marcá como hecha …". En esos casos ejecutá la tool (no
-digas "lo voy a hacer" — hacelo) y después confirmá en una frase corta
-en castellano lo que YA hiciste.
-
-Si el mensaje es un saludo, una pregunta, o charla ("hola", "cómo
-andás", "qué podés hacer") NO llames ninguna tool: respondé en texto,
-breve, en castellano.
-
-Nunca llames la misma tool dos veces en el mismo turno.
-
-# Sugerencias (opcional)
-Al final, en su propia línea, podés agregar un bloque fenced
-\`suggestions\` con 2-3 próximos pasos. El usuario NO lo ve (la deck lo
-quita):
-\`\`\`suggestions
-[{"label":"Ver tareas","command":"deck.view:tasks"}]
-\`\`\`
-Si no hay próximos pasos útiles, omití el bloque.`;
-
-// Pull the trailing ```suggestions ... ``` block off the agent's
-// reply. Returns { cleanText, suggestions[] } — cleanText is the
-// reply with the block removed so the user (and TTS) never sees it.
-const SUGGESTIONS_BLOCK_RE = /\n*```\s*suggestions\s*\n([\s\S]*?)\n?```\s*$/i;
-
-function extractSuggestions(text) {
-  if (typeof text !== "string" || !text) return { cleanText: text || "", suggestions: [] };
-  const m = SUGGESTIONS_BLOCK_RE.exec(text);
-  if (!m) return { cleanText: text, suggestions: [] };
-  const cleanText = text.slice(0, m.index).trim();
-  let suggestions = [];
-  try {
-    const parsed = JSON.parse(m[1]);
-    if (Array.isArray(parsed)) {
-      suggestions = parsed
-        .filter((s) => s && typeof s === "object" && typeof s.label === "string")
-        .slice(0, 4)
-        .map((s) => ({
-          label: String(s.label).slice(0, 48),
-          ...(typeof s.command === "string" ? { command: s.command.slice(0, 96) } : {}),
-        }));
-    }
-  } catch {
-    // Malformed JSON — drop suggestions silently rather than fail the
-    // turn. Better UX to show the reply without chips than an error.
-  }
-  return { cleanText, suggestions };
-}
-
-// ── Voice intent classifier ────────────────────────────────────────
-//
-// A very small, regex-based router that catches a handful of "verb-y"
-// utterances we want to short-circuit instead of sending to the LLM.
-// Right now: "crear tarea ...", "creá tarea ...", "agregá una tarea ...",
-// "nueva tarea ..." → POST to the project's tasks store directly.
-//
-// The classifier always returns either:
-//   - { handled: false } → caller falls through to the super-agent
-//   - { handled: true, reply: "...", meta?: {...} } → caller returns
-//
-// Keeping it dependency-free + sync lets us run it before any heavy
-// work in the voice handler.
-const TASK_INTENT_RE = new RegExp(
-  // Optional polite preamble: "podés / por favor"
-  "^\\s*(?:por favor|porfa|porfis|dale|che|apx)?[,!\\s]*" +
-    // Either:
-    //   (a) verb cluster + optional article + "tarea"
-    //   (b) standalone "nueva|otra tarea" (no verb)
-    "(?:" +
-      // (a) verbs — with optional clitic pronouns (-me, -te, -le)
-      "(?:crea[r]?|cre[áa]|agreg[áa](?:me|le)?|agreg[uú]e|sum[áa](?:me)?|" +
-      "anot[áa](?:me)?|an[oó]tame|guard[áa](?:me)?|met[ée](?:me)?|" +
-      "añad[íi]|añad[ée]|pone(?:me|le)?|recor[dáa]me)" +
-      "\\s+(?:una|la|el|esta|ese|otra|otro)?\\s*" +
-      "(?:tarea|task|pendiente|todo|to-do)" +
-    "|" +
-      // (b) "nueva tarea X" / "otra tarea X" without a verb
-      "(?:nueva|otra|nuevo)\\s+(?:tarea|task|pendiente)" +
-    ")" +
-    // Optional connectors before the title
-    "\\s+(?:que\\s+(?:diga|sea|es)|para|de|sobre|llamada|titulada|titul[áa]da|:|-|de:)?\\s*",
-  "i"
-);
-
-function extractTaskTitle(text) {
-  if (typeof text !== "string") return null;
-  const cleaned = text.trim().replace(/^[«"']|[«"'.,;:!?]+$/g, "");
-  if (!cleaned) return null;
-  const m = TASK_INTENT_RE.exec(cleaned);
-  if (!m) return null;
-  const title = cleaned.slice(m[0].length).trim().replace(/[.!?]+$/, "");
-  if (!title) return null;
-  return title;
-}
-
-function pickIntentProject({ projects, hintId }) {
-  if (!projects?.list) return null;
-  const list = projects.list();
-  if (hintId !== undefined && hintId !== null) {
-    const hit = list.find((p) => String(p.id) === String(hintId));
-    if (hit) return hit;
-  }
-  // Prefer the first non-default real project; fall back to default.
-  return list.find((p) => Number(p.id) !== 0) || list[0] || null;
-}
-
-async function tryVoiceTaskIntent({ projects, userText, hintProjectId }) {
-  const title = extractTaskTitle(userText);
-  if (!title) return { handled: false };
-  const listEntry = pickIntentProject({ projects, hintId: hintProjectId });
-  if (!listEntry) {
-    return {
-      handled: true,
-      reply: "No hay proyectos APX registrados. Agregá uno con `apx project add` y volvé a intentar.",
-    };
-  }
-  // projects.list() returns flat entries without storagePath; the
-  // resolver returns the full record. We need that for the JSONL store.
-  const project = projects.get(listEntry.id) || listEntry;
-  if (!project?.storagePath) {
-    return {
-      handled: true,
-      reply: `No pude crear la tarea: no encuentro el storage del proyecto ${project?.name || listEntry.name}.`,
-    };
-  }
-  try {
-    const { createTask } = await import("#core/stores/tasks.js");
-    const task = createTask(project.storagePath, {
-      title,
-      source: "voice",
-    });
-    // Resolver may strip the human-readable name; fall back to the
-    // list entry which always has it.
-    const displayName = project.name || listEntry.name || `proyecto #${project.id}`;
-    return {
-      handled: true,
-      reply: `Listo. Anoté "${title}" en ${displayName}.`,
-      meta: { task_id: task.id, project_id: project.id },
-    };
-  } catch (e) {
-    return {
-      handled: true,
-      reply: `No pude crear la tarea: ${e.message || "error desconocido"}`,
-    };
-  }
-}
-
-async function decodeAudioInput({ audio, format = "webm" }) {
-  if (!audio) return null;
-  // A short string that starts with "/" and exists on disk is treated as a
-  // path. Anything else is interpreted as base64 (optionally with a data:
-  // prefix).
-  if (
-    typeof audio === "string" &&
-    audio.length < 1024 &&
-    audio.startsWith("/") &&
-    fs.existsSync(audio)
-  ) {
-    return { path: audio, cleanup: false };
-  }
-  let b64 = audio;
-  const m = /^data:[^;]+;base64,(.+)$/.exec(b64);
-  if (m) b64 = m[1];
-  const buf = Buffer.from(b64, "base64");
-  if (!buf.length) throw new Error("voice/turn: decoded audio is empty");
-  const ext = String(format || "webm").replace(/^\./, "");
-  const tmp = path.join(os.tmpdir(), `apx-voice-${Date.now()}-${randomUUID()}.${ext}`);
-  fs.writeFileSync(tmp, buf);
-  return { path: tmp, cleanup: true };
-}
-
 export function register(app, { projects, plugins, registries }) {
   // GET /voice/tts?path=<abs>
   //
@@ -345,45 +96,20 @@ export function register(app, { projects, plugins, registries }) {
         });
       }
 
-      // ── 1.5 Intent classifier (DISABLED) ──────────────────────────
-      // We used to regex-match "creá una tarea X" here and short-circuit
-      // the LLM. That fired far too eagerly — any sentence containing
-      // those words became a task title, even when the user's actual
-      // intent was different ("explicame cómo funciona crear una
-      // tarea" would create a bogus task).
-      //
-      // The right path is the agent's own tool calling: the super-agent
-      // already has `create_task`, `send_telegram`, `list_tasks`, etc.
-      // in its CORE schema (see super-agent-tools/index.js). We let
-      // the model decide; the system prompt below pushes it toward
-      // tool use instead of narrating the action in prose.
-      const intentResult = { handled: false };
       let replyText = "";
       const previousMessages = Array.isArray(body.previousMessages)
         ? body.previousMessages
         : [];
       const channel = body.channel || "voice";
-
-      let intentMeta = null;
       let suggestions = [];
       let toolsUsed = [];
-      const channelCtx = buildChannelContext(channel, {
+
+      const channelCtx = buildVoiceChannelContext(channel, {
         projectId: body.projectId,
         language: body.language && body.language !== "auto" ? body.language : "es",
       });
-      if (intentResult.handled) {
-        replyText = intentResult.reply;
-        intentMeta = intentResult.meta || null;
-        // Intent shortcut bypasses the LLM, so no model-generated
-        // suggestions either; we hand-craft a couple based on the
-        // outcome so the chips area isn't empty.
-        if (intentMeta?.task_id) {
-          suggestions = [
-            { label: "Ver tareas", command: "deck.view:tasks" },
-            { label: "Anotar otra", command: "voice.again" },
-          ];
-        }
-      } else if (isSuperAgentEnabled(cfg)) {
+
+      if (isSuperAgentEnabled(cfg)) {
         try {
           const result = await runSuperAgent({
             globalConfig: cfg,
@@ -423,9 +149,7 @@ export function register(app, { projects, plugins, registries }) {
             // text to TTS — synthesize a generic confirmation so the
             // user gets audible feedback that something happened.
             if (!replyText && raw) {
-              replyText = suggestions.length
-                ? "Listo."
-                : raw;
+              replyText = suggestions.length ? "Listo." : raw;
             }
           } else {
             replyText = raw;
@@ -493,10 +217,9 @@ export function register(app, { projects, plugins, registries }) {
         reply_mime: tts.mime,
         provider: tts.provider,
         tts_error: tts.error || undefined,
-        intent: intentMeta || undefined,
         suggestions: suggestions.length ? suggestions : undefined,
         tools_used: toolsUsed.length ? toolsUsed : undefined,
-        channel: channel,
+        channel,
       });
     } catch (e) {
       res.status(500).json({ error: e.message });

package/src/host/daemon/api.js

@@ -18,6 +18,7 @@ import { register as registerProjects } from "./api/projects.js";
 import { register as registerAgents } from "./api/agents.js";
 import { register as registerSessions } from "./api/sessions.js";
 import { register as registerMcps } from "./api/mcps.js";
+import { register as registerVars } from "./api/vars.js";
 import { register as registerMessages } from "./api/messages.js";
 import { register as registerTelegram } from "./api/telegram.js";
 import { register as registerPlugins } from "./api/plugins.js";
@@ -106,6 +107,7 @@ export function buildApi({
   registerAgents(app, ctx);
   registerSessions(app, ctx);
   registerMcps(app, ctx);
+  registerVars(app, ctx);
   registerMessages(app, ctx);
   registerEngines(app, ctx);
   registerSkills(app, ctx);

package/src/host/daemon/db.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import { appendMessageToFs } from "#core/stores/messages.js";
 import { effectiveConfig } from "./project-config.js";
 import { readAgents } from "#core/apc/parser.js";
+import { apcDir, apcProjectFile, apcAgentsDir, apcCommandsDir } from "#core/apc/paths.js";
 import { getOrCreateApxId } from "#core/apc/scaffold.js";
 import {
   ensureProjectStorage,
@@ -30,12 +31,12 @@ export class ProjectManager {
   register(projectPath) {
     const abs = path.resolve(projectPath);
     if (this.byPath.has(abs)) return this.byPath.get(abs);
-    const projectJson = path.join(abs, ".apc", "project.json");
+    const projectJson = apcProjectFile(abs);
     if (!fs.existsSync(projectJson)) {
       throw new Error(`not an APC project: ${abs}`);
     }
     // Ensure directories exist for projects initialized before they were added.
-    fs.mkdirSync(path.join(abs, ".apc", "commands"), { recursive: true });
+    fs.mkdirSync(apcCommandsDir(abs), { recursive: true });
 
     // Resolve stable APX storage ID (read from .apc/project.json).
     const apxId = getOrCreateApxId(abs);
@@ -72,9 +73,8 @@ export class ProjectManager {
     if (this.byId.has(0)) return this.byId.get(0);
     // Create a minimal APC-compatible structure inside the storage root so that
     // readAgents() and other parser functions work without a separate project dir.
-    const apcDir = path.join(DEFAULT_PROJECT_STORE, ".apc");
-    fs.mkdirSync(path.join(apcDir, "agents"), { recursive: true });
-    const projectJson = path.join(apcDir, "project.json");
+    fs.mkdirSync(apcAgentsDir(DEFAULT_PROJECT_STORE), { recursive: true });
+    const projectJson = apcProjectFile(DEFAULT_PROJECT_STORE);
     if (!fs.existsSync(projectJson)) {
       fs.writeFileSync(
         projectJson,
@@ -113,7 +113,7 @@ export class ProjectManager {
       let kind = e.id === 0 ? "default" : "other";
       try {
         const meta = JSON.parse(
-          fs.readFileSync(path.join(e.path, ".apc", "project.json"), "utf8")
+          fs.readFileSync(apcProjectFile(e.path), "utf8")
         );
         if (meta.name) name = meta.name;
         if (typeof meta.kind === "string" && meta.kind.trim()) {