@agentprojectcontext/apx 1.58.0 → 1.60.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentprojectcontext/apx",
-  "version": "1.58.0",
+  "version": "1.60.0",
   "description": "APX — unified CLI + daemon for the Agent Project Context (APC) standard.",
   "publishConfig": {
     "access": "public"

package/src/core/agent/skills/index.js

@@ -3,6 +3,15 @@ export { condenseSkillDescription, buildSkillsHintBlock } from "./catalog.js";
 export { tryResolveSkillCommand } from "./trigger.js";
 export { suggestSkillForPrompt, clearSkillVectorCache } from "./rag.js";
 export { listSkills, loadSkill, SKILL_LOCATIONS } from "./loader.js";
+export {
+  isPrivateSkill,
+  isSkillEnabled,
+  filterEnabledSkills,
+  annotateSkills,
+  setSkillEnabled,
+  resolveScopeKey,
+  DEFAULT_SCOPE,
+} from "./policy.js";
 export {
   inspectPromptForSkills,
   isInspectorEnabled,

package/src/core/agent/skills/inspector.js

@@ -25,6 +25,7 @@
 
 import { embedOne, cosineSim } from "#core/memory/embeddings.js";
 import { listSkills, loadSkill } from "./loader.js";
+import { filterEnabledSkills, isSkillEnabled } from "./policy.js";
 import { readIndex, backgroundRefreshIfStale } from "./index-store.js";
 
 // Defaults — exported so the CLI/web can render them.
@@ -187,7 +188,8 @@ export async function inspectPromptForSkills({ prompt, projectPath, globalConfig
     };
   }
 
-  const scored = scoreAgainstIndex(probe.vector, items);
+  const scored = scoreAgainstIndex(probe.vector, items).filter((s) =>
+    isSkillEnabled(s, { config: globalConfig, projectPath }));
   return await pickAndRender({ scored, projectPath, probe, cfg });
 }
 
@@ -196,7 +198,10 @@ export async function inspectPromptForSkills({ prompt, projectPath, globalConfig
 // ---------------------------------------------------------------------------
 
 async function inspectFromLive({ text, projectPath, cfg, globalConfig, embedOpts }) {
-  const skills = listSkills({ projectPath });
+  const skills = filterEnabledSkills(listSkills({ projectPath }), {
+    config: globalConfig,
+    projectPath,
+  });
   if (!skills.length) {
     return { contextNote: "", trace: { enabled: true, reason: "no_skills" } };
   }

package/src/core/agent/skills/policy.js

@@ -0,0 +1,128 @@
+// Skills enable/disable policy — scope-aware gating shared by every consumer.
+//
+// A skill can be turned off per scope. A "scope" is either the super-agent /
+// no-project baseline ("default") or a specific project (keyed by its absolute
+// path). Config lives at:
+//
+//   config.skills.policy["default"]        = { "<slug>": true|false, ... }
+//   config.skills.policy["<projectPath>"]  = { "<slug>": true|false, ... }
+//
+// A boolean under a scope is an explicit override; an absent slug inherits.
+// Empty/missing policy = every skill enabled (the pre-feature behavior), so this
+// is fully backward compatible.
+//
+// PRIVATE skills (source "builtin") are APX's own shipped skills. They are
+// always active and can never be disabled or deleted — the UI shows them locked.
+//
+// Effective enabled(skill, projectPath):
+//   1. builtin source                → true (private, locked)
+//   2. project scope explicit value  → that value
+//   3. "default" scope explicit value→ that value
+//   4. otherwise                     → true
+
+export const DEFAULT_SCOPE = "default";
+
+// Sources whose skills ship with apx and are always active.
+const PRIVATE_SOURCES = new Set(["builtin"]);
+
+/** True for APX's own built-in skills — always active, never disableable. */
+export function isPrivateSkill(skill) {
+  return PRIVATE_SOURCES.has(skill?.source);
+}
+
+/** Normalize a project path (or nothing) into a policy scope key. */
+export function resolveScopeKey(projectPath) {
+  const p = typeof projectPath === "string" ? projectPath.trim() : "";
+  return p || DEFAULT_SCOPE;
+}
+
+function policyMap(config) {
+  const p = config?.skills?.policy;
+  return p && typeof p === "object" ? p : {};
+}
+
+function scopeOverride(config, scopeKey, slug) {
+  const scope = policyMap(config)[scopeKey];
+  if (!scope || typeof scope !== "object") return undefined;
+  const v = scope[slug];
+  return typeof v === "boolean" ? v : undefined;
+}
+
+/**
+ * Resolve whether a skill is enabled for the given scope.
+ * @param {{slug:string, source?:string}} skill
+ * @param {{config?:object, projectPath?:string}} ctx
+ * @returns {boolean}
+ */
+export function isSkillEnabled(skill, { config, projectPath } = {}) {
+  if (isPrivateSkill(skill)) return true;
+  const slug = skill?.slug;
+  if (!slug) return true;
+
+  const scopeKey = resolveScopeKey(projectPath);
+  if (scopeKey !== DEFAULT_SCOPE) {
+    const own = scopeOverride(config, scopeKey, slug);
+    if (own !== undefined) return own;
+  }
+  const base = scopeOverride(config, DEFAULT_SCOPE, slug);
+  if (base !== undefined) return base;
+  return true;
+}
+
+/** Keep only the skills enabled for the given scope. */
+export function filterEnabledSkills(skills, ctx = {}) {
+  if (!Array.isArray(skills)) return [];
+  return skills.filter((s) => isSkillEnabled(s, ctx));
+}
+
+/**
+ * Annotate skills for a UI client: adds `enabled`, `private`, and `overridden`
+ * (whether *this* scope holds an explicit override, ignoring inheritance).
+ */
+export function annotateSkills(skills, { config, projectPath } = {}) {
+  if (!Array.isArray(skills)) return [];
+  const scopeKey = resolveScopeKey(projectPath);
+  return skills.map((s) => {
+    const priv = isPrivateSkill(s);
+    const own = priv ? undefined : scopeOverride(config, scopeKey, s.slug);
+    return {
+      ...s,
+      private: priv,
+      enabled: isSkillEnabled(s, { config, projectPath }),
+      overridden: own !== undefined,
+    };
+  });
+}
+
+/**
+ * Set (or clear) a skill's enabled override for a scope. Mutates and returns the
+ * config object. `enabled === null|undefined` clears the override (back to
+ * inherit). Private/builtin skills cannot be overridden.
+ *
+ * @param {object} config          the global config (mutated in place)
+ * @param {object} args
+ * @param {string} args.slug
+ * @param {boolean|null} args.enabled
+ * @param {string=} args.scope     scope key ("default" or a project path)
+ * @param {string=} args.projectPath alternative to scope; normalized to a key
+ */
+export function setSkillEnabled(config, { slug, enabled, scope, projectPath } = {}) {
+  if (!slug) throw new Error("setSkillEnabled: slug required");
+  const scopeKey = scope ? resolveScopeKey(scope) : resolveScopeKey(projectPath);
+
+  config.skills = config.skills || {};
+  config.skills.policy = config.skills.policy || {};
+  const map = config.skills.policy;
+
+  if (enabled === null || enabled === undefined) {
+    if (map[scopeKey]) {
+      delete map[scopeKey][slug];
+      if (Object.keys(map[scopeKey]).length === 0) delete map[scopeKey];
+    }
+    return config;
+  }
+
+  map[scopeKey] = map[scopeKey] || {};
+  map[scopeKey][slug] = !!enabled;
+  return config;
+}

package/src/core/agent/super-agent.js

@@ -1,6 +1,7 @@
 // Super-agent: daemon-level action agent for Telegram, TUI, desktop, routines.
 import { createToolSession, buildLazyToolsBlock, makeToolHandlers } from "#core/agent/tools/registry.js";
 import { listSkills } from "#core/agent/skills/loader.js";
+import { filterEnabledSkills } from "#core/agent/skills/policy.js";
 import {
   runAgent,
   buildSuperAgentSystem,
@@ -97,10 +98,16 @@ export async function runSuperAgent({
   // noTools callers (summarize/ask) get no session — text only.
   const toolSession = noTools ? null : createToolSession(channel, { allowedTools });
 
+  // Scope the catalog hint to the skills enabled for this project (or the
+  // super-agent baseline when no project). Built-in/private skills always pass.
+  const projectPath = channelMeta?.projectPath;
+  const scopedListSkills = (opts = {}) =>
+    filterEnabledSkills(listSkills(opts), { config: globalConfig, projectPath });
+
   const system = buildSuperAgentSystem({
     globalConfig,
     projects,
-    listSkills,
+    listSkills: scopedListSkills,
     contextNote,
     channel,
     channelMeta,

package/src/core/agent/tools/handlers/_asana.js

@@ -0,0 +1,34 @@
+// Shared helpers for the Asana agent tools (asana-*.js). Kept in an underscore
+// file — like _git.js — so it holds no tool `name:` of its own. Each tool file
+// stays a thin adapter: resolve the project's effective Asana integration (its
+// own record wins over the default project's — see resolveIntegration), then
+// call the pure REST client in core/integrations/plugins/asana.js.
+import { resolveProject } from "../helpers.js";
+import { resolveIntegration } from "#core/integrations/index.js";
+
+// Resolve the active Asana token + config for a project, or throw a message the
+// model can act on (tell the user to connect Asana in the web panel).
+export function resolveAsana(projects, project) {
+  const p = resolveProject(projects, project);
+  const resolved = resolveIntegration({ projectStorage: p.storagePath, slug: "asana" });
+  if (!resolved) {
+    throw new Error(
+      "Asana is not connected for this project. Ask the user to connect it in the web panel → Integrations → Plugins → Asana.",
+    );
+  }
+  const config = resolved.record.config || {};
+  const token = config.personal_access_token;
+  if (!token) throw new Error("Asana integration has no token configured");
+  return { token, config, scope: resolved.scope };
+}
+
+export function requireWorkspace(config) {
+  const gid = config.workspace_gid;
+  if (!gid) throw new Error("No Asana workspace selected. Configure it in the web panel first.");
+  return gid;
+}
+
+// The optional `project` arg every Asana tool accepts (defaults to current).
+export const PROJECT_ARG = {
+  project: { type: "string", description: "APX project id/name (optional; defaults to current)" },
+};

package/src/core/agent/tools/handlers/asana-create-task.js

@@ -0,0 +1,38 @@
+import * as asana from "#core/integrations/plugins/asana.js";
+import { resolveAsana, requireWorkspace, PROJECT_ARG } from "./_asana.js";
+
+export default {
+  name: "asana_create_task",
+  category: "integrations",
+  schema: {
+    type: "function",
+    function: {
+      name: "asana_create_task",
+      description: "Create an Asana task in the connected workspace.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Task title" },
+          notes: { type: "string", description: "Task description/notes" },
+          project_gid: { type: "string", description: "Optional Asana project gid to add the task to" },
+          assignee: { type: "string", description: "Optional assignee (user gid or 'me')" },
+          due_on: { type: "string", description: "Optional due date (YYYY-MM-DD)" },
+          ...PROJECT_ARG,
+        },
+        required: ["name"],
+      },
+    },
+  },
+  makeHandler: ({ projects }) => async ({ project, name, notes, project_gid, assignee, due_on } = {}) => {
+    const { token, config } = resolveAsana(projects, project);
+    const task = await asana.createTask(token, {
+      workspaceGid: requireWorkspace(config),
+      name,
+      notes,
+      projectGid: project_gid,
+      assignee,
+      dueOn: due_on,
+    });
+    return { task };
+  },
+};

package/src/core/agent/tools/handlers/asana-list-projects.js

@@ -0,0 +1,19 @@
+import * as asana from "#core/integrations/plugins/asana.js";
+import { resolveAsana, requireWorkspace, PROJECT_ARG } from "./_asana.js";
+
+export default {
+  name: "asana_list_projects",
+  category: "integrations",
+  schema: {
+    type: "function",
+    function: {
+      name: "asana_list_projects",
+      description: "List Asana projects in the connected workspace.",
+      parameters: { type: "object", properties: { ...PROJECT_ARG } },
+    },
+  },
+  makeHandler: ({ projects }) => async ({ project } = {}) => {
+    const { token, config } = resolveAsana(projects, project);
+    return { projects: await asana.listProjects(token, requireWorkspace(config)) };
+  },
+};

package/src/core/agent/tools/handlers/asana-list-tasks.js

@@ -0,0 +1,27 @@
+import * as asana from "#core/integrations/plugins/asana.js";
+import { resolveAsana, PROJECT_ARG } from "./_asana.js";
+
+export default {
+  name: "asana_list_tasks",
+  category: "integrations",
+  schema: {
+    type: "function",
+    function: {
+      name: "asana_list_tasks",
+      description: "List tasks in an Asana project.",
+      parameters: {
+        type: "object",
+        properties: {
+          project_gid: { type: "string", description: "Asana project gid (from asana_list_projects)" },
+          completed: { type: "boolean", description: "Include completed tasks (default false)" },
+          ...PROJECT_ARG,
+        },
+        required: ["project_gid"],
+      },
+    },
+  },
+  makeHandler: ({ projects }) => async ({ project, project_gid, completed = false } = {}) => {
+    const { token } = resolveAsana(projects, project);
+    return { tasks: await asana.listTasks(token, project_gid, completed) };
+  },
+};

package/src/core/agent/tools/handlers/asana-update-task.js

@@ -0,0 +1,32 @@
+import * as asana from "#core/integrations/plugins/asana.js";
+import { resolveAsana, PROJECT_ARG } from "./_asana.js";
+
+export default {
+  name: "asana_update_task",
+  category: "integrations",
+  schema: {
+    type: "function",
+    function: {
+      name: "asana_update_task",
+      description: "Update an Asana task's fields (rename, complete, reschedule, reassign).",
+      parameters: {
+        type: "object",
+        properties: {
+          task_gid: { type: "string", description: "Asana task gid" },
+          name: { type: "string" },
+          notes: { type: "string" },
+          completed: { type: "boolean" },
+          due_on: { type: "string", description: "YYYY-MM-DD" },
+          assignee: { type: "string" },
+          ...PROJECT_ARG,
+        },
+        required: ["task_gid"],
+      },
+    },
+  },
+  makeHandler: ({ projects }) => async ({ project, task_gid, name, notes, completed, due_on, assignee } = {}) => {
+    const { token } = resolveAsana(projects, project);
+    const task = await asana.updateTask(token, task_gid, { name, notes, completed, dueOn: due_on, assignee });
+    return { task };
+  },
+};

package/src/core/agent/tools/handlers/list-skills.js

@@ -1,5 +1,5 @@
 import { listSkills, SKILL_LOCATIONS } from "#core/agent/skills/loader.js";
-import { condenseSkillDescription } from "#core/agent/skills/index.js";
+import { condenseSkillDescription, filterEnabledSkills } from "#core/agent/skills/index.js";
 
 export default {
   name: "list_skills",
@@ -20,8 +20,11 @@ export default {
       },
     },
   },
-  makeHandler: () => ({ project_path } = {}) => {
-    const skills = listSkills({ projectPath: project_path });
+  makeHandler: (ctx = {}) => ({ project_path } = {}) => {
+    const skills = filterEnabledSkills(
+      listSkills({ projectPath: project_path }),
+      { config: ctx.globalConfig, projectPath: project_path },
+    );
     return {
       ok: true,
       count: skills.length,

package/src/core/agent/tools/handlers/load-skill.js

@@ -1,4 +1,5 @@
 import { loadSkill } from "#core/agent/skills/loader.js";
+import { isSkillEnabled } from "#core/agent/skills/policy.js";
 
 export default {
   name: "load_skill",
@@ -24,8 +25,14 @@ export default {
       },
     },
   },
-  makeHandler: () => ({ slug, project_path } = {}) => {
+  makeHandler: (ctx = {}) => ({ slug, project_path } = {}) => {
     if (!slug) throw new Error("load_skill: slug required");
-    return loadSkill(slug, { projectPath: project_path });
+    const skill = loadSkill(slug, { projectPath: project_path });
+    if (!isSkillEnabled(skill, { config: ctx.globalConfig, projectPath: project_path })) {
+      throw new Error(
+        `skill "${slug}" is disabled for this scope. Enable it in Settings → Skills, or pick another.`,
+      );
+    }
+    return skill;
   },
 };

package/src/core/agent/tools/names.js

@@ -50,6 +50,12 @@ export const TOOLS = Object.freeze({
   CALL_MCP:            "call_mcp",
   CALL_RUNTIME:        "call_runtime",
 
+  // Integrations — Asana plugin (see core/integrations/plugins/asana.js)
+  ASANA_LIST_PROJECTS: "asana_list_projects",
+  ASANA_LIST_TASKS:    "asana_list_tasks",
+  ASANA_CREATE_TASK:   "asana_create_task",
+  ASANA_UPDATE_TASK:   "asana_update_task",
+
   // Side-effects
   SEND_TELEGRAM:       "send_telegram",
   SET_IDENTITY:        "set_identity",
@@ -94,6 +100,10 @@ export const NATIVE_TOOL_NAMES = new Set([
   TOOLS.CALL_AGENT,
   TOOLS.CALL_MCP,
   TOOLS.CALL_RUNTIME,
+  TOOLS.ASANA_LIST_PROJECTS,
+  TOOLS.ASANA_LIST_TASKS,
+  TOOLS.ASANA_CREATE_TASK,
+  TOOLS.ASANA_UPDATE_TASK,
   TOOLS.SEND_TELEGRAM,
   TOOLS.SET_IDENTITY,
   TOOLS.SET_PERMISSION_MODE,

package/src/core/agent/tools/registry.js

@@ -33,6 +33,10 @@ import gitStatus from "./handlers/git-status.js";
 import gitDiff from "./handlers/git-diff.js";
 import gitLog from "./handlers/git-log.js";
 import gitShow from "./handlers/git-show.js";
+import asanaListProjects from "./handlers/asana-list-projects.js";
+import asanaListTasks from "./handlers/asana-list-tasks.js";
+import asanaCreateTask from "./handlers/asana-create-task.js";
+import asanaUpdateTask from "./handlers/asana-update-task.js";
 import { createPermissionGuard } from "./helpers.js";
 import { buildBridgedTools, DEFAULT_CATEGORIES } from "./registry-bridge.js";
 import { TOOLS, CODE_CHANNEL_TOOLS } from "./names.js";
@@ -74,6 +78,13 @@ const NATIVE_TOOLS = [
   gitDiff,
   gitLog,
   gitShow,
+  // Integration plugin tools (Asana). Each carries its own `category`, so it
+  // lands in the "integrations" group of the discover_tools catalog and stays
+  // lazy on chat channels until activated.
+  asanaListProjects,
+  asanaListTasks,
+  asanaCreateTask,
+  asanaUpdateTask,
 ];
 
 // Registry-backed bridges. Categories can be overridden per-process via env

package/src/core/integrations/catalog.js

@@ -0,0 +1,66 @@
+// Plugin catalog — the source of truth for which integration plugins exist and
+// which are wired end-to-end. The daemon API + web "Plugins" tab read this.
+//
+// A plugin is "implemented" when it has a service module in ./plugins/ that
+// satisfies the lifecycle contract (configure/validate/status/deactivate). The
+// rest are declared here with `coming_soon: true` so the Integrations page shows
+// the full roster (matching PandaProject) while remaining honest about what is
+// actually connectable. Adding a new plugin = drop a module in ./plugins/ and
+// register it in PLUGIN_SERVICES — no API or route changes (open/closed).
+import { asanaPlugin } from "./plugins/asana.js";
+
+// slug -> live plugin service (must implement the lifecycle contract).
+export const PLUGIN_SERVICES = Object.freeze({
+  asana: asanaPlugin,
+});
+
+// Static descriptors for the catalog UI. Implemented plugins derive their
+// metadata from the service module; coming-soon ones are declared inline.
+// `coming_soon` entries in PandaProject depend on domain/channel infrastructure
+// (GitHub outputs↔repos, a WhatsApp-Web bridge, Telegram-voice whisper) that
+// APX models differently — they are placeholders until ported natively.
+const COMING_SOON = [
+  {
+    slug: "github",
+    name: "GitHub",
+    type: "source_control",
+    description: "Vinculá repos, issues y PRs para que los agentes trabajen sobre tu código",
+    auth: "token",
+    coming_soon: true,
+  },
+  {
+    slug: "whatsapp",
+    name: "WhatsApp",
+    type: "channel",
+    description: "Conectá WhatsApp Web al orquestador — responde mensajes automáticamente",
+    auth: "qr",
+    coming_soon: true,
+  },
+  {
+    slug: "local-transcription",
+    name: "Transcripción Local",
+    type: "transcription",
+    description: "Transcripción de audio con faster-whisper local — sin depender de una API externa",
+    auth: "none",
+    coming_soon: true,
+  },
+];
+
+// The full catalog: implemented plugins first, then coming-soon.
+export function listCatalog() {
+  const implemented = Object.values(PLUGIN_SERVICES).map((p) => ({
+    slug: p.slug,
+    name: p.name,
+    type: p.type,
+    description: p.description,
+    auth: p.auth,
+    tools: p.tools || [],
+    coming_soon: false,
+  }));
+  return [...implemented, ...COMING_SOON];
+}
+
+// Resolve a live plugin service by slug (or null when not implemented).
+export function getPluginService(slug) {
+  return PLUGIN_SERVICES[slug] || null;
+}

package/src/core/integrations/index.js

@@ -0,0 +1,10 @@
+// Public surface of the integrations core module. Daemon + agent tools import
+// from here.
+export {
+  integrationsPath,
+  defaultIntegrationsStorage,
+  readIntegrations,
+  writeIntegrations,
+} from "./sources.js";
+export { IntegrationStore, resolveIntegration, redactRecord } from "./store.js";
+export { listCatalog, getPluginService, PLUGIN_SERVICES } from "./catalog.js";