@intent-systems/nexus 2026.1.5-5 → 2026.1.5-8

package/dist/cli/skills-cli.js

@@ -1,12 +1,12 @@
 import path from "node:path";
 import chalk from "chalk";
-import { getSkillInfo, runSkill, verifySkill } from "../agents/skill-runner.js";
+import { getSkillInfo, verifySkill } from "../agents/skill-runner.js";
 import { getAggregateStats, getSkillStats, hasSkillUsage, recordSkillUsage, } from "../agents/skill-usage.js";
 import { getSkillMetadata, loadWorkspaceSkillEntries } from "../agents/skills.js";
 import { buildWorkspaceSkillStatus } from "../agents/skills-status.js";
 import { DEFAULT_AGENT_WORKSPACE_DIR } from "../agents/workspace.js";
 import { loadConfig } from "../config/config.js";
-import { MANAGED_SKILLS_DIR, NEXUS_ROOT, resolveUserPath } from "../utils.js";
+import { NEXUS_ROOT, SKILLS_STATE_DIR, resolveUserPath } from "../utils.js";
 const STATUS_ICON = {
     active: "✅",
     ready: "⭐",
@@ -47,6 +47,7 @@ export function registerSkillsCommand(program) {
         .description("List all available skills")
         .option("--json", "Output as JSON")
         .option("--type <type>", "Filter by type (guide|tool|connector)")
+        .option("--status <status>", "Filter by status (active|ready|needs-setup|needs-install|unavailable)")
         .option("--active", "Only show active skills")
         .option("--ready", "Only show ready skills")
         .option("--needs-setup", "Only show skills needing setup")
@@ -56,13 +57,14 @@ export function registerSkillsCommand(program) {
         .action(async (opts) => {
         const config = loadConfig();
         const workspaceDir = resolveUserPath(config.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR);
+        const managedSkillsDir = path.join(NEXUS_ROOT, "skills", "managed");
         const entries = loadWorkspaceSkillEntries(workspaceDir, {
             config,
-            managedSkillsDir: MANAGED_SKILLS_DIR,
+            managedSkillsDir,
         });
         const status = buildWorkspaceSkillStatus(workspaceDir, {
             config,
-            managedSkillsDir: MANAGED_SKILLS_DIR,
+            managedSkillsDir,
             entries,
         });
         const statusMap = new Map(status.skills.map((item) => [item.name.toLowerCase(), item]));
@@ -84,6 +86,25 @@ export function registerSkillsCommand(program) {
             ? String(opts.type).toLowerCase()
             : undefined;
         const statusFilters = new Set();
+        if (opts.status) {
+            const raw = String(opts.status)
+                .split(",")
+                .map((entry) => entry.trim().toLowerCase())
+                .filter(Boolean);
+            for (const entry of raw) {
+                const normalized = entry.replace(/_/g, "-");
+                if (normalized === "needs-setup")
+                    statusFilters.add("needs_setup");
+                else if (normalized === "needs-install")
+                    statusFilters.add("needs_install");
+                else if (normalized === "active")
+                    statusFilters.add("active");
+                else if (normalized === "ready")
+                    statusFilters.add("ready");
+                else if (normalized === "unavailable")
+                    statusFilters.add("unavailable");
+            }
+        }
         if (opts.active)
             statusFilters.add("active");
         if (opts.ready)
@@ -125,8 +146,11 @@ export function registerSkillsCommand(program) {
             const icon = STATUS_ICON[item.status] ?? "•";
             console.log(`  ${icon} ${item.name}${desc}`);
         }
-        console.log(`\nSkills directory: ${MANAGED_SKILLS_DIR}`);
-        console.log(`User skills: ${path.join(NEXUS_ROOT, "home", "skills")}\n`);
+        const skillsRoot = path.join(NEXUS_ROOT, "skills");
+        console.log(`\nSkills directory: ${skillsRoot}`);
+        console.log(`Skill types: ${path.join(skillsRoot, "tools")}, ${path.join(skillsRoot, "connectors")}, ${path.join(skillsRoot, "guides")}`);
+        console.log(`Skill state: ${SKILLS_STATE_DIR}`);
+        console.log(`User skills: ${path.join(workspaceDir, "skills")}\n`);
     });
     skill
         .command("info <name>")
@@ -190,18 +214,6 @@ export function registerSkillsCommand(program) {
         console.log(info.prompt.trimEnd());
         recordSkillUsage(name, { ts: Date.now(), event: "use", ok: true });
     });
-    skill
-        .command("run <name>")
-        .description("Run a skill command with arguments")
-        .allowUnknownOption()
-        .action(async (name, _opts, command) => {
-        const args = command.args.slice(1);
-        const result = await runSkill(name, args);
-        if (!result.ok) {
-            console.error(result.error);
-            process.exit(1);
-        }
-    });
     skill
         .command("verify <name>")
         .description("Verify skill setup and dependencies")

package/dist/cli/skills-hub-cli.js

@@ -12,7 +12,7 @@ import { generateSkillManifest, writeSkillManifest, } from "../commands/skills-m
 import { loadConfig } from "../config/config.js";
 import { listCredentialEntries, resolveCredentialValue, } from "../credentials/store.js";
 import { runCommandWithTimeout } from "../process/exec.js";
-import { MANAGED_SKILLS_DIR, resolveUserPath } from "../utils.js";
+import { NEXUS_ROOT, resolveUserPath } from "../utils.js";
 function getHubBaseUrl() {
     return (process.env.NEXUS_HUB_URL ||
         process.env.NEXUS_WEBSITE_URL ||
@@ -284,9 +284,8 @@ function dirNameToSlug(dirName) {
 async function ensureDir(dir) {
     await fs.mkdir(dir, { recursive: true });
 }
-async function loadManagedSkillSlugs(managedSkillsDir) {
+async function loadManagedSkillSlugs(managedDir) {
     const slugs = new Set();
-    const managedDir = path.join(managedSkillsDir, "managed");
     let entries = [];
     try {
         entries = await fs.readdir(managedDir, { withFileTypes: true });
@@ -600,7 +599,8 @@ async function installHubSkill(params) {
     }
     await extractArchive(artifactPath, destDir);
     await normalizeSkillRoot(destDir);
-    const manifest = await generateSkillManifest(MANAGED_SKILLS_DIR, params.userSkillsDir);
+    const skillsRootDir = path.dirname(params.managedDir);
+    const manifest = await generateSkillManifest(skillsRootDir, params.userSkillsDir);
     await writeSkillManifest(manifest);
     return { installed: true, destDir };
 }
@@ -628,7 +628,8 @@ export function registerSkillsHubCommand(program) {
                 : 10;
         const cfg = loadConfig();
         const workspaceDir = resolveUserPath(cfg.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR);
-        const managedSkillsDir = MANAGED_SKILLS_DIR;
+        const skillsRoot = path.join(NEXUS_ROOT, "skills");
+        const managedSkillsDir = path.join(skillsRoot, "managed");
         const status = buildWorkspaceSkillStatus(workspaceDir, {
             config: cfg,
             managedSkillsDir,
@@ -1049,8 +1050,9 @@ export function registerSkillsHubCommand(program) {
             const cfg = loadConfig();
             const workspaceDir = resolveUserPath(cfg.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR);
             const userSkillsDir = path.join(workspaceDir, "skills");
-            const managedSkillsDir = MANAGED_SKILLS_DIR;
-            const managedDir = path.join(managedSkillsDir, "managed");
+            const skillsRoot = path.join(NEXUS_ROOT, "skills");
+            const managedSkillsDir = path.join(skillsRoot, "managed");
+            const managedDir = managedSkillsDir;
             const metadataEntries = loadWorkspaceSkillEntries(workspaceDir, {
                 config: cfg,
                 managedSkillsDir,

package/dist/commands/bootstrap-preset.js

@@ -107,15 +107,15 @@ export async function applyBootstrapPreset(params) {
     const { workspaceDir, runtime } = params;
     const stateDir = resolveStateDir();
     const agentId = process.env.NEXUS_AGENT_ID?.trim() || "default";
-    const agentIdentityDir = path.join(stateDir, "agents", agentId, "identity");
-    const userIdentityDir = path.join(stateDir, "user", "identity");
+    const agentIdentityDir = path.join(stateDir, "agents", agentId);
+    const userIdentityDir = path.join(stateDir, "user");
     const bootstrapPath = resolveBootstrapPath(undefined, stateDir);
     if (!(await fileExists(bootstrapPath)))
         return;
     await fs.mkdir(agentIdentityDir, { recursive: true });
     await fs.mkdir(userIdentityDir, { recursive: true });
     const identityPath = path.join(agentIdentityDir, "IDENTITY.md");
-    const userPath = path.join(userIdentityDir, "PROFILE.md");
+    const userPath = path.join(userIdentityDir, "IDENTITY.md");
     const soulPath = path.join(agentIdentityDir, "SOUL.md");
     const agentsPath = path.join(NEXUS_ROOT, "AGENTS.md");
     const preset = resolvePreset(params.preset);
@@ -173,17 +173,27 @@ export async function applyBootstrapPreset(params) {
         userName = "Test User";
     if (!preferredAddress)
         preferredAddress = firstName(userName) || "friend";
-    const identityMd = `# IDENTITY.md - Agent Identity
+    const identityMd = `---
+name: ${agentName}
+emoji: ${preset.emoji}
+creature: ${preset.creature}
+vibe: ${preset.vibe}
+---
+# IDENTITY.md - Agent Identity
 
 - Name: ${agentName}
 - Creature: ${preset.creature}
 - Vibe: ${preset.vibe}
 - Emoji: ${preset.emoji}
 `;
-    const userMd = `# PROFILE.md - User Profile
+    const userMd = `---
+name: ${userName}
+call: ${preferredAddress}
+---
+# IDENTITY.md - User Identity
 
 - Name: ${userName}
-- Preferred address: ${preferredAddress}
+- What to call them: ${preferredAddress}
 - Pronouns (optional):
 - Timezone (optional):
 - Notes:

package/dist/commands/config.js

@@ -0,0 +1,85 @@
+import { loadConfig, readConfigFileSnapshot, writeConfigFile } from "../config/config.js";
+import { defaultRuntime } from "../runtime.js";
+function getByPath(obj, key) {
+    const parts = key.split(".").filter(Boolean);
+    let current = obj;
+    for (const part of parts) {
+        if (!current || typeof current !== "object")
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function setByPath(obj, key, value) {
+    const parts = key.split(".").filter(Boolean);
+    let current = obj;
+    for (let i = 0; i < parts.length; i += 1) {
+        const part = parts[i];
+        if (i === parts.length - 1) {
+            current[part] = value;
+            break;
+        }
+        const next = current[part];
+        if (!next || typeof next !== "object") {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    return obj;
+}
+function parseValue(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return "";
+    if (trimmed === "true")
+        return true;
+    if (trimmed === "false")
+        return false;
+    if (!Number.isNaN(Number(trimmed)))
+        return Number(trimmed);
+    if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+        (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return trimmed;
+        }
+    }
+    return trimmed;
+}
+export async function configListCommand(opts, runtime = defaultRuntime) {
+    const snapshot = await readConfigFileSnapshot();
+    const payload = snapshot.valid ? snapshot.parsed : {};
+    if (opts?.json) {
+        runtime.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    runtime.log(JSON.stringify(payload, null, 2));
+}
+export async function configGetCommand(opts, runtime = defaultRuntime) {
+    const config = loadConfig();
+    const value = getByPath(config, opts.key);
+    if (opts.json) {
+        runtime.log(JSON.stringify({ key: opts.key, value }, null, 2));
+        return;
+    }
+    if (typeof value === "string") {
+        runtime.log(value);
+        return;
+    }
+    runtime.log(JSON.stringify(value ?? null, null, 2));
+}
+export async function configSetCommand(opts, runtime = defaultRuntime) {
+    const snapshot = await readConfigFileSnapshot();
+    const base = snapshot.valid && snapshot.parsed && typeof snapshot.parsed === "object"
+        ? snapshot.parsed
+        : {};
+    const next = setByPath({ ...base }, opts.key, parseValue(opts.value));
+    await writeConfigFile(next);
+    if (opts.json) {
+        runtime.log(JSON.stringify({ key: opts.key, value: getByPath(next, opts.key) }, null, 2));
+        return;
+    }
+    runtime.log(`Updated ${opts.key}`);
+}

package/dist/commands/cursor-hooks.js

@@ -0,0 +1,240 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { resolveUserPath } from "../utils.js";
+const DEFAULT_SCRIPT_NAME = "nexus-session-start.js";
+const HOOK_SCRIPT = `#!/usr/bin/env node
+const { execFile } = require("child_process");
+const fs = require("fs");
+const fsp = require("fs/promises");
+const os = require("os");
+const path = require("path");
+
+const MAX_IDENTITY_CHARS = 120000;
+const MAX_MEMORY_CHARS = 120000;
+const MAX_DAILY_CHARS = 40000;
+const MAX_BOOTSTRAP_CHARS = 80000;
+
+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));
+  });
+}
+
+function safeJsonParse(raw) {
+  if (!raw || !raw.trim()) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function formatDate(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return \`\${year}-\${month}-\${day}\`;
+}
+
+function resolveWorkspaceRoot(payload) {
+  const roots = payload?.workspace_roots;
+  if (Array.isArray(roots) && roots.length > 0 && roots[0]) {
+    return roots[0];
+  }
+  if (process.env.NEXUS_ROOT?.trim()) return process.env.NEXUS_ROOT.trim();
+  const home = os.homedir();
+  if (home) return path.join(home, "nexus");
+  return process.cwd();
+}
+
+function resolveStateDir(workspaceRoot) {
+  if (process.env.NEXUS_STATE_DIR?.trim()) {
+    return process.env.NEXUS_STATE_DIR.trim();
+  }
+  return path.join(workspaceRoot, "state");
+}
+
+function execFileAsync(command, args, options) {
+  return new Promise((resolve) => {
+    execFile(command, args, options, (error, stdout, stderr) => {
+      resolve({ error, stdout, stderr });
+    });
+  });
+}
+
+async function runStatus(env, cwd) {
+  const result = await execFileAsync("nexus", ["status", "--json"], {
+    env,
+    cwd,
+  });
+  const parsed = safeJsonParse(result.stdout);
+  if (parsed) return parsed;
+  if (result.error && result.error.stdout) {
+    const fallback = safeJsonParse(result.error.stdout.toString());
+    if (fallback) return fallback;
+  }
+  return null;
+}
+
+async function readFileSnippet(filePath, limit) {
+  if (!filePath) return null;
+  try {
+    const content = await fsp.readFile(filePath, "utf8");
+    if (!content.trim()) return null;
+    if (content.length <= limit) return content.trim();
+    const slice = content.slice(-limit).trimStart();
+    return \`\${slice}\\n\\n[truncated]\`;
+  } catch {
+    return null;
+  }
+}
+
+function addSection(sections, title, body) {
+  if (!body) return;
+  sections.push(\`## \${title}\\n\${body}\`);
+}
+
+async function main() {
+  const input = await readStdin();
+  const payload = safeJsonParse(input) || {};
+  const workspaceRoot = resolveWorkspaceRoot(payload);
+  const stateDir = resolveStateDir(workspaceRoot);
+  const env = {
+    ...process.env,
+    NEXUS_ROOT: workspaceRoot,
+    NEXUS_STATE_DIR: stateDir,
+  };
+  const status = await runStatus(env, workspaceRoot);
+  const identity = status?.identity || null;
+  const agentId = identity?.agentId || process.env.NEXUS_AGENT_ID || "default";
+  const agentIdentityPath =
+    identity?.agentIdentityPath ||
+    path.join(stateDir, "agents", agentId, "IDENTITY.md");
+  const agentSoulPath =
+    identity?.agentSoulPath || path.join(stateDir, "agents", agentId, "SOUL.md");
+  const agentMemoryPath =
+    identity?.agentMemoryPath ||
+    path.join(stateDir, "agents", agentId, "MEMORY.md");
+  const userIdentityPath =
+    identity?.userIdentityPath || path.join(stateDir, "user", "IDENTITY.md");
+  const userProfilePath = path.join(stateDir, "user", "PROFILE.md");
+  const resolvedUserPath = fs.existsSync(userIdentityPath)
+    ? userIdentityPath
+    : fs.existsSync(userProfilePath)
+      ? userProfilePath
+      : userIdentityPath;
+
+  const sections = ["# Nexus Session Bootstrap"];
+  if (identity) {
+    const summary = [
+      \`Agent: \${identity.agentName || "(unknown)"} (\${identity.agentId})\`,
+      \`User: \${identity.userName || "(unknown)"}\`,
+      \`Agent ID: \${identity.agentId}\`,
+    ];
+    addSection(sections, "Status", summary.join("\\n"));
+  }
+
+  const bootstrapPath =
+    status?.identity?.bootstrapPath ||
+    path.join(stateDir, "agents", "BOOTSTRAP.md");
+  const hasIdentity =
+    typeof identity?.hasIdentity === "boolean"
+      ? identity.hasIdentity
+      : fs.existsSync(agentIdentityPath) && fs.existsSync(resolvedUserPath);
+  let bootstrapPrompt = status?.bootstrap?.prompt || null;
+  if (!bootstrapPrompt && !hasIdentity) {
+    bootstrapPrompt = await readFileSnippet(
+      bootstrapPath,
+      MAX_BOOTSTRAP_CHARS,
+    );
+  }
+  if (bootstrapPrompt) {
+    addSection(sections, "Bootstrap Prompt", bootstrapPrompt.trim());
+  }
+
+  const agentIdentity = await readFileSnippet(
+    agentIdentityPath,
+    MAX_IDENTITY_CHARS,
+  );
+  const agentSoul = await readFileSnippet(agentSoulPath, MAX_IDENTITY_CHARS);
+  const agentMemory = await readFileSnippet(agentMemoryPath, MAX_MEMORY_CHARS);
+  const userIdentity = await readFileSnippet(
+    resolvedUserPath,
+    MAX_IDENTITY_CHARS,
+  );
+
+  addSection(sections, "Agent Identity", agentIdentity);
+  addSection(sections, "Agent Soul", agentSoul);
+  addSection(sections, "Agent Memory", agentMemory);
+  addSection(sections, "User Identity", userIdentity);
+
+  const memoryDir = path.join(workspaceRoot, "home", "memory");
+  const today = formatDate(new Date());
+  const yesterday = formatDate(new Date(Date.now() - 86400000));
+  const todayLog = await readFileSnippet(
+    path.join(memoryDir, \`\${today}.md\`),
+    MAX_DAILY_CHARS,
+  );
+  const yesterdayLog = await readFileSnippet(
+    path.join(memoryDir, \`\${yesterday}.md\`),
+    MAX_DAILY_CHARS,
+  );
+
+  addSection(sections, \`Daily Memory (\${today})\`, todayLog);
+  addSection(sections, \`Daily Memory (\${yesterday})\`, yesterdayLog);
+
+  const additional = sections.join("\\n\\n").trim();
+  const output = { continue: true, additional_context: additional };
+  const envOut = {};
+  if (!process.env.NEXUS_ROOT?.trim() && workspaceRoot) {
+    envOut.NEXUS_ROOT = workspaceRoot;
+  }
+  if (!process.env.NEXUS_STATE_DIR?.trim() && stateDir) {
+    envOut.NEXUS_STATE_DIR = stateDir;
+  }
+  if (Object.keys(envOut).length > 0) {
+    output.env = envOut;
+  }
+  process.stdout.write(JSON.stringify(output) + "\\n");
+}
+
+main().catch(() => {
+  process.stdout.write(JSON.stringify({ continue: true }) + "\\n");
+});
+`;
+async function writeFileIfMissing(filePath, content) {
+    try {
+        await fsp.writeFile(filePath, content, { encoding: "utf-8", flag: "wx" });
+        return true;
+    }
+    catch (err) {
+        const anyErr = err;
+        if (anyErr.code === "EEXIST")
+            return false;
+        throw err;
+    }
+}
+export async function writeCursorHooks(options = {}) {
+    const workspaceDir = resolveUserPath(options.workspaceDir ?? process.cwd());
+    const hooksPath = options.hooksPath ?? path.join(workspaceDir, ".cursor", "hooks.json");
+    const scriptPath = options.scriptPath ??
+        path.join(workspaceDir, ".cursor", "hooks", DEFAULT_SCRIPT_NAME);
+    await fsp.mkdir(path.dirname(hooksPath), { recursive: true });
+    await fsp.mkdir(path.dirname(scriptPath), { recursive: true });
+    const hooksConfig = JSON.stringify({
+        version: 1,
+        hooks: {
+            sessionStart: [
+                { command: `node .cursor/hooks/${DEFAULT_SCRIPT_NAME}` },
+            ],
+        },
+    }, null, 2);
+    const hooksCreated = await writeFileIfMissing(hooksPath, `${hooksConfig}\n`);
+    const scriptCreated = await writeFileIfMissing(scriptPath, HOOK_SCRIPT);
+    return { hooksPath, scriptPath, hooksCreated, scriptCreated };
+}