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

package/dist/commands/quest-state.js

@@ -0,0 +1,271 @@
+import fs from "node:fs";
+import path from "node:path";
+import { DEFAULT_AGENT_WORKSPACE_DIR } from "../agents/workspace.js";
+import { loadConfig } from "../config/config.js";
+import { resolveUserPath } from "../utils.js";
+const QUEST_CATALOG = [
+    {
+        id: "identity-setup",
+        title: "Identity setup",
+        description: "Create the agent + user identity files.",
+        path: "core",
+        weight: 10,
+        quickWin: true,
+    },
+    {
+        id: "filesystem-wow",
+        title: "Filesystem organization",
+        description: "Use home/ projects + memory for a quick win.",
+        path: "core",
+        weight: 5,
+        quickWin: true,
+    },
+    {
+        id: "credential-manager",
+        title: "Credential manager",
+        description: "Store your first credentials for secure access.",
+        path: "core",
+        weight: 15,
+    },
+    {
+        id: "cloud-backup",
+        title: "Cloud backup",
+        description: "Set up Nexus Cloud sync + rollback.",
+        path: "core",
+        weight: 10,
+    },
+    {
+        id: "connect-email",
+        title: "Connect email",
+        description: "Unlock email read/send capabilities.",
+        path: "breadth",
+        weight: 10,
+    },
+    {
+        id: "connect-messages",
+        title: "Connect messages",
+        description: "Unlock messaging read/send capabilities.",
+        path: "breadth",
+        weight: 10,
+    },
+    {
+        id: "connect-calendar",
+        title: "Connect calendar",
+        description: "Unlock calendar access.",
+        path: "breadth",
+        weight: 5,
+    },
+    {
+        id: "enable-llm",
+        title: "Enable LLM",
+        description: "Configure an LLM provider.",
+        path: "breadth",
+        weight: 5,
+    },
+    {
+        id: "enable-scheduling",
+        title: "Enable scheduling",
+        description: "Turn on scheduling automation.",
+        path: "power",
+        weight: 10,
+    },
+    {
+        id: "enable-agent-comms",
+        title: "Enable agent comms",
+        description: "Let your agent reach you outside the IDE.",
+        path: "power",
+        weight: 15,
+    },
+    {
+        id: "first-automation",
+        title: "First automation",
+        description: "Set up a reactive trigger.",
+        path: "power",
+        weight: 5,
+    },
+    {
+        id: "completionist",
+        title: "Completionist",
+        description: "Unlock everything in the catalog.",
+        path: "secret",
+        weight: 5,
+    },
+    {
+        id: "polyglot",
+        title: "Polyglot",
+        description: "Connect 3+ distinct messaging platforms.",
+        path: "secret",
+        weight: 5,
+    },
+    {
+        id: "social-butterfly",
+        title: "Social butterfly",
+        description: "Connect multiple social networks.",
+        path: "secret",
+        weight: 5,
+    },
+    {
+        id: "home-automation",
+        title: "Home automation",
+        description: "Activate smart home capabilities.",
+        path: "secret",
+        weight: 5,
+    },
+    {
+        id: "full-stack",
+        title: "Full stack",
+        description: "Enable web + automation + dev tooling.",
+        path: "secret",
+        weight: 5,
+    },
+];
+const QUEST_ORDER = QUEST_CATALOG.map((quest) => quest.id);
+const QUEST_PROGRESS_VERSION = 1;
+const PROGRESS_NOTE = "Progress is computed dynamically; no persistent progress.json.";
+function getCapabilityStatusMap(capabilities) {
+    return new Map(capabilities.map((cap) => [cap.id, cap.status]));
+}
+function isCapabilityReady(status) {
+    return status === "active" || status === "ready";
+}
+async function dirHasEntries(dir) {
+    try {
+        const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+        return entries.some((entry) => entry.name && !entry.name.startsWith("."));
+    }
+    catch {
+        return false;
+    }
+}
+function resolveWorkspaceDir() {
+    const config = loadConfig();
+    return resolveUserPath(config.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR);
+}
+function computeQuestAutoCompletion(params) {
+    const { identityConfigured, capabilities, credentials, workspaceDir } = params;
+    const capabilityMap = getCapabilityStatusMap(capabilities);
+    const hasCredentials = Object.keys(credentials.services ?? {}).length > 0;
+    const anyReady = (ids) => ids.some((id) => isCapabilityReady(capabilityMap.get(id)));
+    return (async () => {
+        const hasProjects = await dirHasEntries(path.join(workspaceDir, "projects"));
+        const hasMemory = await dirHasEntries(path.join(workspaceDir, "memory"));
+        const readySocial = anyReady(["social-x", "social-instagram", "social-linkedin"]) ||
+            anyReady(["social", "social-news"]);
+        const readyMessaging = anyReady(["messaging-read", "messaging-send"]);
+        const readyChat = anyReady(["chat-send", "chat-read"]);
+        const readySmartHome = anyReady([
+            "smart-lights",
+            "smart-audio",
+            "smart-sleep",
+            "bluetooth",
+            "camera-control",
+        ]);
+        const readyDev = anyReady(["version-control", "terminal-sessions"]);
+        const readyWeb = anyReady(["web-search", "url-fetch"]);
+        const readyAutomation = anyReady(["reactive-triggers"]);
+        return {
+            "identity-setup": identityConfigured,
+            "filesystem-wow": hasProjects || hasMemory,
+            "credential-manager": hasCredentials,
+            "cloud-backup": anyReady(["cloud-sync", "rollback"]),
+            "connect-email": anyReady(["email-read", "email-send"]),
+            "connect-messages": readyMessaging,
+            "connect-calendar": anyReady(["calendar"]),
+            "enable-llm": anyReady(["anthropic", "openai", "gemini"]),
+            "enable-scheduling": anyReady(["scheduling"]),
+            "enable-agent-comms": readyChat || readyMessaging,
+            "first-automation": readyAutomation,
+            completionist: capabilities.every((cap) => cap.status === "active"),
+            polyglot: readyMessaging && readyChat,
+            "social-butterfly": readySocial,
+            "home-automation": readySmartHome,
+            "full-stack": readyWeb && readyAutomation && readyDev,
+        };
+    })();
+}
+function computePower(quests) {
+    const baseQuests = quests.filter((quest) => quest.path !== "secret");
+    const bonusQuests = quests.filter((quest) => quest.path === "secret" && quest.status === "completed");
+    const baseTotal = baseQuests.reduce((sum, quest) => sum + quest.weight, 0);
+    const baseScore = baseQuests.reduce((sum, quest) => sum + (quest.status === "completed" ? quest.weight : 0), 0);
+    const bonus = bonusQuests.reduce((sum, quest) => sum + quest.weight, 0);
+    const percent = baseTotal > 0 ? Math.round((baseScore / baseTotal) * 100) : 0;
+    const nextQuest = baseQuests.find((quest) => quest.status !== "completed");
+    return {
+        score: baseScore + bonus,
+        baseTotal,
+        percent: Math.min(100, Math.max(0, percent)),
+        bonus,
+        nextQuest: nextQuest
+            ? { id: nextQuest.id, title: nextQuest.title, weight: nextQuest.weight }
+            : undefined,
+    };
+}
+function buildProgressSnapshot(quests, updatedAt) {
+    const entries = {};
+    for (const quest of quests) {
+        entries[quest.id] = {
+            status: quest.status,
+            completedAt: quest.status === "completed" ? updatedAt : undefined,
+            updatedAt,
+        };
+    }
+    return {
+        version: QUEST_PROGRESS_VERSION,
+        updatedAt,
+        quests: entries,
+    };
+}
+function sortQuests(a, b) {
+    const aIdx = QUEST_ORDER.indexOf(a.id);
+    const bIdx = QUEST_ORDER.indexOf(b.id);
+    if (aIdx !== -1 && bIdx !== -1)
+        return aIdx - bIdx;
+    if (aIdx !== -1)
+        return -1;
+    if (bIdx !== -1)
+        return 1;
+    return a.title.localeCompare(b.title);
+}
+export async function resolveQuestState(params) {
+    const workspaceDir = params.workspaceDir ?? resolveWorkspaceDir();
+    const autoCompletion = await computeQuestAutoCompletion({
+        identityConfigured: params.identityConfigured,
+        capabilities: params.capabilities,
+        credentials: params.credentials,
+        workspaceDir,
+    });
+    const now = new Date().toISOString();
+    const quests = QUEST_CATALOG.filter((quest) => params.includeSecrets || quest.path !== "secret").map((quest) => {
+        const autoCompleted = Boolean(autoCompletion[quest.id]);
+        const status = autoCompleted ? "completed" : "not_started";
+        return {
+            ...quest,
+            status,
+            autoCompleted,
+        };
+    });
+    quests.sort(sortQuests);
+    const power = computePower(quests);
+    const progress = buildProgressSnapshot(quests, now);
+    progress.note = PROGRESS_NOTE;
+    return { quests, progress, power };
+}
+export async function startQuest(questId) {
+    const now = new Date().toISOString();
+    return {
+        version: QUEST_PROGRESS_VERSION,
+        updatedAt: now,
+        quests: {
+            [questId]: {
+                status: "in_progress",
+                startedAt: now,
+                updatedAt: now,
+            },
+        },
+        note: PROGRESS_NOTE,
+    };
+}
+export function getQuestCatalog() {
+    return [...QUEST_CATALOG];
+}

package/dist/commands/quest.js

@@ -1,27 +1,67 @@
-import { defaultRuntime } from "../runtime.js";
+import { resolveIdentitySnapshot } from "../agents/identity-state.js";
 import { detectCapabilities } from "../capabilities/detector.js";
+import { defaultRuntime } from "../runtime.js";
+import { listCredentials } from "./credential.js";
+import { getQuestCatalog, resolveQuestState, startQuest, } from "./quest-state.js";
 export async function questCommand(opts, runtime = defaultRuntime) {
+    if (opts?.start) {
+        const catalog = getQuestCatalog();
+        if (!catalog.some((quest) => quest.id === opts.start)) {
+            runtime.error(`Unknown quest: ${opts.start}`);
+            runtime.exit(1);
+            return;
+        }
+        await startQuest(opts.start);
+        if (!opts.json) {
+            runtime.log(`Marked quest as in-progress: ${opts.start}`);
+            runtime.log("Note: quest progress is computed dynamically (no progress.json).");
+        }
+    }
     const snapshot = detectCapabilities();
-    const suggestions = snapshot.capabilities
-        .filter((cap) => ["needs_setup", "needs_install", "ready"].includes(cap.status))
-        .slice(0, 5)
-        .map((cap) => ({
-        id: cap.id,
-        status: cap.status,
-        providers: cap.providers.map((p) => p.id),
-    }));
+    const credentials = await listCredentials();
+    const identityResolution = resolveIdentitySnapshot();
+    const identityConfigured = identityResolution.ok
+        ? identityResolution.snapshot.hasIdentity
+        : false;
+    const questState = await resolveQuestState({
+        identityConfigured,
+        capabilities: snapshot.capabilities,
+        credentials,
+        includeSecrets: Boolean(opts?.secrets),
+    });
+    let quests = questState.quests;
+    if (opts?.powerPath) {
+        quests = quests.filter((quest) => quest.path === "power");
+    }
+    if (opts?.quickWins) {
+        quests = quests.filter((quest) => quest.quickWin);
+    }
+    if (!opts?.list && !opts?.progress) {
+        quests = quests.filter((quest) => quest.status !== "completed").slice(0, 5);
+    }
     if (opts?.json) {
         runtime.log(JSON.stringify({
-            suggestions,
+            power: questState.power,
+            quests,
+            progress: questState.progress,
         }, null, 2));
         return;
     }
-    if (suggestions.length === 0) {
+    if (opts?.progress) {
+        const completed = quests.filter((quest) => quest.status === "completed").length;
+        runtime.log(`Quest progress: ${completed}/${quests.length} complete (${questState.power.percent}%)`);
+        if (questState.power.nextQuest) {
+            runtime.log(`Next unlock: ${questState.power.nextQuest.title} (+${questState.power.nextQuest.weight}%)`);
+        }
+        return;
+    }
+    if (quests.length === 0) {
         runtime.log("No quests found. You're fully configured.");
         return;
     }
     runtime.log("Quests");
-    for (const [idx, item] of suggestions.entries()) {
-        runtime.log(`  ${idx + 1}. ${item.id} (${item.status})`);
+    for (const [idx, item] of quests.entries()) {
+        const pathLabel = item.path === "secret" ? "secret" : item.path;
+        runtime.log(`  ${idx + 1}. ${item.id} (${pathLabel}, ${item.status})`);
     }
 }

package/dist/commands/reset.js

@@ -7,7 +7,7 @@ import { defaultRuntime } from "../runtime.js";
  * Requires --confirm flag to actually delete.
  */
 export async function resetCommand(opts = {}, runtime = defaultRuntime) {
-    const { local = false, state = false, all = false, confirm = false, workspace } = opts;
+    const { local = false, state = false, all = false, confirm = false, workspace, } = opts;
     // Validate: at least one target must be specified
     if (!local && !state && !all) {
         throw new Error("Must specify at least one target: --local, --state, or --all");

package/dist/commands/sessions-ingest.js

@@ -56,7 +56,10 @@ function lexicalToPlainText(raw) {
             }
         };
         walk(root);
-        return out.join("").replace(/\n{3,}/g, "\n\n").trim();
+        return out
+            .join("")
+            .replace(/\n{3,}/g, "\n\n")
+            .trim();
     }
     catch {
         return raw;
@@ -119,9 +122,7 @@ async function findCursorWorkspaceStorageDir(params) {
                 return { hash, dir, stateDbPath };
             }
         }
-        catch {
-            continue;
-        }
+        catch { }
     }
     return null;
 }

package/dist/commands/setup.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import JSON5 from "json5";
-import { DEFAULT_AGENT_WORKSPACE_DIR, ensureAgentWorkspace } from "../agents/workspace.js";
+import { DEFAULT_AGENT_WORKSPACE_DIR, ensureAgentWorkspace, } from "../agents/workspace.js";
 import { CONFIG_PATH_NEXUS } from "../config/config.js";
 import { applyModelDefaults } from "../config/defaults.js";
 import { resolveSessionTranscriptsDir } from "../config/sessions.js";
@@ -21,7 +21,9 @@ async function readConfigFileRaw() {
 }
 async function writeConfigFile(cfg) {
     await fs.mkdir(path.dirname(CONFIG_PATH_NEXUS), { recursive: true });
-    const json = JSON.stringify(applyModelDefaults(cfg), null, 2).trimEnd().concat("\n");
+    const json = JSON.stringify(applyModelDefaults(cfg), null, 2)
+        .trimEnd()
+        .concat("\n");
     await fs.writeFile(CONFIG_PATH_NEXUS, json, "utf-8");
 }
 export async function setupCommand(opts, runtime = defaultRuntime) {

package/dist/commands/skills-manifest.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import fsp from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { resolveStateDir } from "../config/paths.js";
+import { MANAGED_SKILLS_DIR } from "../utils.js";
 /**
  * Parse skill frontmatter to extract name and description
  */
@@ -178,7 +178,7 @@ export async function generateSkillManifest(skillsDir, userSkillsDir) {
  * Get the path to the skills manifest file
  */
 export function getSkillManifestPath() {
-    return path.join(resolveStateDir(), "nexus", "skills", "manifest.json");
+    return path.join(MANAGED_SKILLS_DIR, "manifest.json");
 }
 /**
  * Write the skill manifest to disk