nexarch 0.1.33 → 0.2.0

package/dist/commands/init-agent.js

@@ -4,7 +4,7 @@ import { join } from "path";
 import process from "process";
 import { requireCredentials } from "../lib/credentials.js";
 import { callMcpTool, mcpInitialize, mcpListTools } from "../lib/mcp.js";
-const CLI_VERSION = "0.1.33";
+const CLI_VERSION = "0.2.0";
 const AGENT_ENTITY_TYPE = "agent";
 const TECH_COMPONENT_ENTITY_TYPE = "technology_component";
 function parseFlag(args, flag) {
@@ -96,18 +96,18 @@ function writeAgentBootstrap(params) {
         `npx nexarch agent identify`,
         `--agent-id "${params.agentId}"`,
         `--provider "<anthropic|openai|google|other>"`,
-        `--model "<model-id e.g. claude-sonnet-4-6>"`,
-        `--client "<claude-code|cursor|copilot|other>"`,
+        `--model "<model-id e.g. gpt-4o|claude-sonnet-4-6|gemini-2-flash>"`,
+        `--client "<claude-code|cursor|copilot|continue|codex-cli|other>"`,
         `--framework "<openclaw|n8n|m365-agent-framework|other>"`,
         `--session-id "<your current session id if known, otherwise omit>"`,
-        `--tool-version "<run claude --version to get this, e.g. 1.2.3>"`,
+        `--tool-version "<version of the client tool, e.g. 1.2.3>"`,
         `--capabilities "<comma,separated,capabilities>"`,
         `--json`,
     ].join(" \\\n  ");
     const content = `# Nexarch Agent Bootstrap
 
 This file was written by \`nexarch init-agent\` on ${new Date().toISOString()}.
-It contains instructions for a Claude Code agent to complete its Nexarch registration.
+It contains instructions for an AI agent to complete its Nexarch registration.
 
 ## What has already been registered
 
@@ -130,12 +130,12 @@ ${identifyCmd}
 \`\`\`
 
 Fill in:
-- **provider** — your AI provider (e.g. \`anthropic\`)
-- **model** — the exact model ID you are running as (e.g. \`claude-sonnet-4-6\`)
-- **client** — the tool you are running inside (e.g. \`claude-code\`)
+- **provider** — your AI provider (e.g. \`anthropic\`, \`openai\`, \`google\`)
+- **model** — the exact model ID you are running as (e.g. \`gpt-4o\`, \`claude-sonnet-4-6\`, \`gemini-2-flash\`)
+- **client** — the MCP client tool you are running inside (e.g. \`claude-code\`, \`cursor\`, \`continue\`, \`codex-cli\`)
 - **framework** — the agent framework in use (e.g. \`openclaw\`)
 - **session-id** — your current session ID if available
-- **tool-version** — the version of the client tool you are running inside; run \`claude --version\` (or equivalent) to get it and use the version number only (e.g. \`1.2.3\`)
+- **tool-version** — the version of the client tool (run the tool's version command and use the version number only, e.g. \`1.2.3\`)
 - **capabilities** — comma-separated list of your capabilities (e.g. \`code,files,bash,web\`)
 
 Omit any flag whose value you genuinely do not know rather than guessing.
@@ -149,14 +149,18 @@ const CLAUDE_MD_SECTION_MARKER = "## Nexarch Agent Registration";
 const CLAUDE_MD_SECTION = `
 ## Nexarch Agent Registration
 
-When a human has run \`nexarch login\` and \`nexarch init-agent\`, they will tell you to run \`npx nexarch agent prompt\`. Do so, read the output, and follow the instructions — it contains a pre-filled \`npx nexarch agent identify\` command for you to complete with your own provider, model, client, and capability values, then execute. Confirm \`"ok": true\` in the JSON output.
+When a human has run \`nexarch login\` and \`nexarch init-agent\`, they may ask you to run \`npx nexarch agent prompt\`. Do so, read the output, and follow the instructions — it contains a pre-filled \`npx nexarch agent identify\` command for you to complete with your own provider, model, client, and capability values, then execute. Confirm \`"ok": true\` in the JSON output.
+
+This applies to any AI coding assistant with MCP tool access (Claude Code, Cursor, Windsurf, Continue.dev, Codex CLI, etc.).
 `;
 function injectAgentConfigs() {
     const candidateNames = [
         "CLAUDE.md", "claude.md", "Claude.md", // Claude Code
-        "AGENTS.md", "agents.md", // OpenAI Codex CLI
+        "AGENTS.md", "agents.md", // OpenAI Codex CLI / generic
         ".github/copilot-instructions.md", // GitHub Copilot
         ".cursorrules", // Cursor (legacy)
+        ".continue/rules.md", // Continue.dev
+        ".windsurfrules", // Windsurf
     ];
     const results = [];
     for (const name of candidateNames) {
@@ -690,7 +694,7 @@ export async function initAgent(args) {
                 console.log(`📝 Nexarch registration instructions added to: ${r.path}`);
             }
         }
-        console.log("\n   Tell Claude: \"run npx nexarch agent prompt and follow the instructions\"");
+        console.log("\n   Tell your agent: \"run npx nexarch agent prompt and follow the instructions\"");
     }
     else {
         console.log("⚠ Handshake/registration completed with issues.");

package/dist/commands/init-project.js

@@ -25,7 +25,7 @@ function slugify(name) {
 }
 // ─── Project scanning ─────────────────────────────────────────────────────────
 // Noise patterns for env var keys that are internal config, not external service references
-const ENV_KEY_NOISE = /^(NODE_ENV|PORT|HOST|DEBUG|LOG_LEVEL|TZ|LANG|PATH|HOME|USER|SHELL|TERM)$|(_LOG_LEVEL|_MAX_|_MIN_|_DEFAULT_|_TIMEOUT|_DELAY|_JOBS|_INTERVAL|_LIMIT|_RETRIES|_CONCURREN|_WORKERS)$|^NEXT_PUBLIC_(APP|ADMIN|API|SITE|BASE|WEB)_URL$|(_URL|_SECRET|_TOKEN|_KEY|_PASSWORD|_CREDENTIAL|_DSN|_URI)$/;
+const ENV_KEY_NOISE = /^(NODE_ENV|PORT|HOST|DEBUG|LOG_LEVEL|TZ|LANG|PATH|HOME|USER|SHELL|TERM)$|(_LOG_LEVEL|_MAX_|_MIN_|_DEFAULT_|_TIMEOUT|_DELAY|_JOBS|_INTERVAL|_LIMIT|_RETRIES|_CONCURREN|_WORKERS)$|(_URL|_SECRET|_TOKEN|_KEY|_PASSWORD|_CREDENTIAL|_DSN|_URI)$/;
 function parseEnvKeys(content) {
     return content
         .split("\n")
@@ -93,7 +93,22 @@ function detectFromFilesystem(dir) {
         detected.push("pulumi");
     return detected;
 }
-const SKIP_DIRS = new Set(["node_modules", "dist", ".next", ".turbo", "build", "coverage", ".git"]);
+const SKIP_DIRS = new Set([
+    // JavaScript / Node
+    "node_modules", "dist", ".next", ".turbo", "coverage",
+    // Python
+    "__pycache__", ".venv", "venv", "env", ".env", "site-packages", ".mypy_cache", ".ruff_cache",
+    // Go
+    "vendor",
+    // Rust
+    "target",
+    // Java / Kotlin
+    ".gradle", ".mvn",
+    // Ruby
+    ".bundle",
+    // Generic
+    "build", ".git", ".cache", "tmp",
+]);
 function collectPackageDeps(pkgPath) {
     try {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
@@ -229,40 +244,267 @@ function findPackageJsonPaths(rootDir) {
     }
     return paths;
 }
+// ─── Ecosystem scanners ───────────────────────────────────────────────────────
+// Strip Python version specifiers: "requests>=2.28,<3" → "requests", "flask[async]" → "flask"
+function normalisePyDep(raw) {
+    const trimmed = raw.trim().replace(/\s*#.*$/, "").trim();
+    if (!trimmed || trimmed.startsWith("-") || trimmed.startsWith("."))
+        return null;
+    // Strip extras [...]  then version specifiers
+    return trimmed.split(/[>=<!~\[;\s]/)[0].trim().toLowerCase() || null;
+}
+function scanPythonRequirements(filePath) {
+    try {
+        return readFileSync(filePath, "utf8")
+            .split("\n")
+            .map(normalisePyDep)
+            .filter((n) => n !== null && n.length > 1);
+    }
+    catch {
+        return [];
+    }
+}
+function scanPyprojectToml(filePath) {
+    try {
+        const content = readFileSync(filePath, "utf8");
+        const names = [];
+        // PEP 621: [project] dependencies = ["requests>=2.28", ...]
+        const pep621 = content.match(/\[project\][\s\S]*?^dependencies\s*=\s*\[([\s\S]*?)\]/m);
+        if (pep621) {
+            for (const m of pep621[1].matchAll(/"([^"]+)"|'([^']+)'/g)) {
+                const name = normalisePyDep(m[1] ?? m[2] ?? "");
+                if (name)
+                    names.push(name);
+            }
+        }
+        // Poetry: [tool.poetry.dependencies] key = value
+        const poetryMatch = content.match(/\[tool\.poetry\.dependencies\]([\s\S]*?)(?=^\[|\Z)/m);
+        if (poetryMatch) {
+            for (const line of poetryMatch[1].split("\n")) {
+                const key = line.match(/^([a-zA-Z][a-zA-Z0-9_-]*)\s*=/)?.[1];
+                if (key && key.toLowerCase() !== "python")
+                    names.push(key.toLowerCase());
+            }
+        }
+        return names;
+    }
+    catch {
+        return [];
+    }
+}
+function scanPipfile(filePath) {
+    try {
+        const content = readFileSync(filePath, "utf8");
+        const names = [];
+        let inPackages = false;
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed === "[packages]") {
+                inPackages = true;
+                continue;
+            }
+            if (trimmed.startsWith("[")) {
+                inPackages = false;
+                continue;
+            }
+            if (inPackages) {
+                const key = trimmed.match(/^([a-zA-Z][a-zA-Z0-9_-]*)\s*=/)?.[1];
+                if (key)
+                    names.push(key.toLowerCase());
+            }
+        }
+        return names;
+    }
+    catch {
+        return [];
+    }
+}
+function scanGoMod(filePath) {
+    try {
+        const names = [];
+        let inRequire = false;
+        for (const line of readFileSync(filePath, "utf8").split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed === "require (") {
+                inRequire = true;
+                continue;
+            }
+            if (inRequire && trimmed === ")") {
+                inRequire = false;
+                continue;
+            }
+            // Single-line: require github.com/foo/bar v1.2.3
+            const single = trimmed.match(/^require\s+(\S+)\s+v/);
+            if (single) {
+                names.push(single[1]);
+                continue;
+            }
+            // Inside require block: \t github.com/foo/bar v1.2.3
+            if (inRequire) {
+                const m = trimmed.match(/^(\S+)\s+v/);
+                if (m && !trimmed.endsWith("// indirect"))
+                    names.push(m[1]);
+            }
+        }
+        return names;
+    }
+    catch {
+        return [];
+    }
+}
+function scanGemfile(filePath) {
+    try {
+        const names = [];
+        for (const line of readFileSync(filePath, "utf8").split("\n")) {
+            const m = line.trim().match(/^gem\s+['"]([^'"]+)['"]/);
+            if (m)
+                names.push(m[1]);
+        }
+        return names;
+    }
+    catch {
+        return [];
+    }
+}
+function scanCargoToml(filePath) {
+    try {
+        const content = readFileSync(filePath, "utf8");
+        const names = [];
+        let inDeps = false;
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (/^\[(dependencies|workspace\.dependencies)\]/.test(trimmed)) {
+                inDeps = true;
+                continue;
+            }
+            if (/^\[dev-dependencies\]/.test(trimmed)) {
+                inDeps = false;
+                continue;
+            }
+            if (trimmed.startsWith("[")) {
+                inDeps = false;
+                continue;
+            }
+            if (inDeps) {
+                const key = trimmed.match(/^([a-zA-Z][a-zA-Z0-9_-]*)\s*=/)?.[1];
+                if (key)
+                    names.push(key.toLowerCase());
+            }
+        }
+        return names;
+    }
+    catch {
+        return [];
+    }
+}
+// Detect which language ecosystems are present; return names detected from each manifest
+function scanEcosystems(dir) {
+    const names = [];
+    const ecosystems = [];
+    // Python
+    if (existsSync(join(dir, "pyproject.toml"))) {
+        ecosystems.push("python");
+        names.push(...scanPyprojectToml(join(dir, "pyproject.toml")));
+    }
+    if (existsSync(join(dir, "requirements.txt"))) {
+        if (!ecosystems.includes("python"))
+            ecosystems.push("python");
+        names.push(...scanPythonRequirements(join(dir, "requirements.txt")));
+    }
+    if (existsSync(join(dir, "requirements-dev.txt"))) {
+        names.push(...scanPythonRequirements(join(dir, "requirements-dev.txt")));
+    }
+    if (existsSync(join(dir, "Pipfile"))) {
+        if (!ecosystems.includes("python"))
+            ecosystems.push("python");
+        names.push(...scanPipfile(join(dir, "Pipfile")));
+    }
+    // Go
+    if (existsSync(join(dir, "go.mod"))) {
+        ecosystems.push("go");
+        names.push(...scanGoMod(join(dir, "go.mod")));
+    }
+    // Ruby
+    if (existsSync(join(dir, "Gemfile"))) {
+        ecosystems.push("ruby");
+        names.push(...scanGemfile(join(dir, "Gemfile")));
+    }
+    // Rust
+    if (existsSync(join(dir, "Cargo.toml"))) {
+        ecosystems.push("rust");
+        names.push(...scanCargoToml(join(dir, "Cargo.toml")));
+    }
+    return { names, ecosystems };
+}
 function scanProject(dir) {
     const names = new Set();
     let projectName = basename(dir);
     const subPackages = [];
     let rootDepNames = new Set();
+    const detectedEcosystems = [];
+    // ── npm / Node.js ──────────────────────────────────────────────────────────
     const pkgPaths = findPackageJsonPaths(dir);
     const rootPkgPath = join(dir, "package.json");
-    for (const pkgPath of pkgPaths) {
-        const pkg = readRootPackage(pkgPath);
-        const deps = collectPackageDeps(pkgPath);
-        if (pkgPath === rootPkgPath) {
-            if (pkg.name)
-                projectName = pkg.name;
-            rootDepNames = new Set(deps);
+    if (pkgPaths.length > 0) {
+        detectedEcosystems.push("nodejs");
+        for (const pkgPath of pkgPaths) {
+            const pkg = readRootPackage(pkgPath);
+            const deps = collectPackageDeps(pkgPath);
+            if (pkgPath === rootPkgPath) {
+                if (pkg.name)
+                    projectName = pkg.name;
+                rootDepNames = new Set(deps);
+            }
+            else {
+                const relativePath = pkgPath.replace(dir + "/", "").replace("/package.json", "");
+                const packageName = pkg.name ?? relativePath;
+                const { entityType, subtype } = classifySubPackage(pkgPath, relativePath);
+                subPackages.push({
+                    name: packageName,
+                    relativePath,
+                    packageJsonPath: pkgPath,
+                    depNames: deps,
+                    entityType,
+                    subtype,
+                    externalKey: "",
+                });
+            }
+            for (const dep of deps)
+                names.add(dep);
         }
-        else {
-            // Record as a sub-package for enrichment task
-            const relativePath = pkgPath.replace(dir + "/", "").replace("/package.json", "");
-            const packageName = pkg.name ?? relativePath;
-            const { entityType, subtype } = classifySubPackage(pkgPath, relativePath);
-            subPackages.push({
-                name: packageName,
-                relativePath,
-                packageJsonPath: pkgPath,
-                depNames: deps,
-                entityType,
-                subtype,
-                externalKey: "", // computed after scan once projectSlug is known
-            });
+    }
+    // ── Other ecosystems (Python, Go, Ruby, Rust) ──────────────────────────────
+    const { names: ecosystemNames, ecosystems } = scanEcosystems(dir);
+    for (const n of ecosystemNames)
+        names.add(n);
+    for (const e of ecosystems) {
+        if (!detectedEcosystems.includes(e))
+            detectedEcosystems.push(e);
+        // Root deps for non-npm ecosystems — treat all detected names as root-level
+        for (const n of ecosystemNames)
+            rootDepNames.add(n);
+    }
+    // Try to infer project name from Python pyproject.toml if no package.json name
+    if (!detectedEcosystems.includes("nodejs") && existsSync(join(dir, "pyproject.toml"))) {
+        try {
+            const content = readFileSync(join(dir, "pyproject.toml"), "utf8");
+            const nameMatch = content.match(/^\s*name\s*=\s*["']([^"']+)["']/m);
+            if (nameMatch)
+                projectName = nameMatch[1];
+        }
+        catch { }
+    }
+    // Try go.mod module name
+    if (!detectedEcosystems.includes("nodejs") && existsSync(join(dir, "go.mod"))) {
+        try {
+            const content = readFileSync(join(dir, "go.mod"), "utf8");
+            const moduleMatch = content.match(/^module\s+(\S+)/m);
+            if (moduleMatch)
+                projectName = moduleMatch[1].split("/").pop() ?? projectName;
         }
-        for (const dep of deps)
-            names.add(dep);
+        catch { }
     }
-    // .env files at root
+    // ── .env files ─────────────────────────────────────────────────────────────
     for (const envFile of [".env", ".env.example", ".env.local", ".env.runtime"]) {
         const envPath = join(dir, envFile);
         if (existsSync(envPath)) {
@@ -273,12 +515,19 @@ function scanProject(dir) {
             catch { }
         }
     }
-    // Git remote, CI/CD, deployment config
+    // ── Git remote, CI/CD, deployment config ───────────────────────────────────
     for (const name of detectFromGitConfig(dir))
         names.add(name);
     for (const name of detectFromFilesystem(dir))
         names.add(name);
-    return { projectName, packageJsonCount: pkgPaths.length, detectedNames: Array.from(names), rootDepNames, subPackages };
+    return {
+        projectName,
+        packageJsonCount: pkgPaths.length,
+        detectedNames: Array.from(names),
+        rootDepNames,
+        subPackages,
+        detectedEcosystems,
+    };
 }
 // ─── Relationship type selection ──────────────────────────────────────────────
 function pickRelationshipType(toEntityTypeCode, _fromEntityTypeCode = "application") {
@@ -309,7 +558,7 @@ export async function initProject(args) {
     const mcpOpts = { companyId: creds.companyId };
     if (!asJson)
         console.log(`Scanning ${dir}…`);
-    const { projectName, packageJsonCount, detectedNames, rootDepNames, subPackages } = scanProject(dir);
+    const { projectName, packageJsonCount, detectedNames, rootDepNames, subPackages, detectedEcosystems } = scanProject(dir);
     const displayName = nameOverride ?? projectName;
     const projectSlug = slugify(displayName);
     const projectExternalKey = `${entityTypeOverride}:${projectSlug}`;
@@ -484,6 +733,20 @@ export async function initProject(args) {
     const readmeHints = ["README.md", "README.mdx", "docs/README.md", "docs/index.md"]
         .filter((f) => existsSync(join(dir, f)));
     function buildEnrichmentInstructions() {
+        const ecosystemLabel = detectedEcosystems.length > 0
+            ? detectedEcosystems.join(", ")
+            : "unknown";
+        const manifestHint = detectedEcosystems.includes("nodejs")
+            ? "package.json"
+            : detectedEcosystems.includes("python")
+                ? "pyproject.toml / requirements.txt"
+                : detectedEcosystems.includes("go")
+                    ? "go.mod"
+                    : detectedEcosystems.includes("ruby")
+                        ? "Gemfile"
+                        : detectedEcosystems.includes("rust")
+                            ? "Cargo.toml"
+                            : "dependency manifest";
         const subPkgSection = subPackages.length === 0 ? "" : `
 STEP 3 — Classify and register each sub-package as its own entity.
   The scanner found ${subPackages.length} workspace package(s):
@@ -565,7 +828,7 @@ ${subPackages.map((sp) => {
         const gapCheckSection = `
 ${finalStep} — Identify architecturally significant components not auto-detected.
 
-  The mechanical scan only finds npm packages, env var names, and a few config files.
+  The mechanical scan only finds declared dependencies, env var names, and a few config files.
   It systematically misses hosting platforms, managed infrastructure, SaaS integrations,
   and external APIs that are only mentioned in README or deployment config.
 
@@ -613,6 +876,8 @@ You now need to enrich it with meaningful content.
 
 PROJECT ENTITY  : ${projectExternalKey}
 PROJECT DIR     : ${dir}
+ECOSYSTEM(S)    : ${ecosystemLabel}
+MANIFEST        : ${manifestHint}
 ${readmeHints.length > 0 ? `README FILES    : ${readmeHints.join(", ")}` : "README FILES    : (none found — check docs/)"}
 
 STEP 1 — Read the project README / docs and build your understanding of:
@@ -655,7 +920,7 @@ ${subPkgSection}${gapCheckSection}`;
     };
     const output = {
         ok: Number(entitiesResult.summary?.failed ?? 0) === 0,
-        project: { name: displayName, externalKey: projectExternalKey, entityType: entityTypeOverride },
+        project: { name: displayName, externalKey: projectExternalKey, entityType: entityTypeOverride, detectedEcosystems },
         entities: entitiesResult.summary ?? {},
         relationships: relsResult?.summary ?? { requested: 0, succeeded: 0, failed: 0 },
         resolved: resolvedItems.length,

package/dist/commands/mcp-config.js

@@ -1,3 +1,4 @@
+import { loadCredentials } from "../lib/credentials.js";
 import { nexarchServerBlock } from "../lib/clients.js";
 export async function mcpConfig(args) {
     const clientFlag = args.find((a) => !a.startsWith("-")) ?? "claude-desktop";
@@ -22,6 +23,47 @@ Locations:
             console.log(JSON.stringify(config, null, 2));
             break;
         }
+        case "continue":
+        case "continue-dev": {
+            // Continue.dev uses an array-style mcpServers with a "name" field per entry
+            const config = { mcpServers: [{ name: "nexarch", ...serverBlock }] };
+            console.log("Add (or merge) the following into your ~/.continue/config.json:\n");
+            console.log(JSON.stringify(config, null, 2));
+            console.log(`
+Locations:
+  macOS/Linux: ~/.continue/config.json
+  Windows:     %USERPROFILE%\\.continue\\config.json
+      `);
+            break;
+        }
+        case "http":
+        case "direct": {
+            // Direct HTTP connection — for MCP clients that support Streamable HTTP transport.
+            // The gateway accepts JSON-RPC 2.0 POST requests at the /mcp endpoint.
+            // Auth is via Bearer token (your nexarch token from ~/.nexarch/credentials.json).
+            const creds = loadCredentials();
+            const tokenHint = creds ? creds.token : "<your-nexarch-token>";
+            console.log("Direct HTTP MCP connection (Streamable HTTP / SSE transport):\n");
+            console.log(`  Endpoint : https://mcp.nexarch.ai/mcp`);
+            console.log(`  Auth     : Authorization: Bearer ${tokenHint}`);
+            console.log(`  Protocol : MCP JSON-RPC 2.0 over HTTP POST`);
+            console.log(`
+Use this when your MCP client supports connecting to a remote HTTP MCP server directly
+(no stdio proxy required). Examples: custom agent frameworks, LangChain MCP integration,
+or any client that speaks the MCP Streamable HTTP or SSE transport.
+
+Example curl to verify connectivity:
+
+  curl -s -X POST https://mcp.nexarch.ai/mcp \\
+    -H "Authorization: Bearer ${tokenHint}" \\
+    -H "Content-Type: application/json" \\
+    -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | jq .
+
+If your client requires an MCP server URL instead of command/args, use:
+  https://mcp.nexarch.ai/mcp
+      `);
+            break;
+        }
         default: {
             const config = { mcpServers: { nexarch: serverBlock } };
             console.log(JSON.stringify(config, null, 2));

package/dist/commands/setup.js

@@ -6,9 +6,13 @@ export async function setup(_args) {
     const clients = detectClients();
     if (clients.length === 0) {
         console.log("No supported MCP clients detected.");
-        console.log("\nSupported clients: Claude Desktop, Cursor, Windsurf");
+        console.log("\nSupported clients: Claude Desktop, Cursor, Windsurf, Continue.dev");
         console.log("\nTo configure manually, run:");
         console.log("  nexarch mcp-config --client claude-desktop");
+        console.log("  nexarch mcp-config --client cursor");
+        console.log("  nexarch mcp-config --client continue");
+        console.log("\nFor clients that support direct HTTP MCP connections:");
+        console.log("  nexarch mcp-config --client http");
         return;
     }
     const serverBlock = nexarchServerBlock();

package/dist/lib/clients.js

@@ -40,6 +40,10 @@ function windsurfPaths() {
             return [join(homedir(), ".windsurf", "mcp.json")];
     }
 }
+function continueDevPaths() {
+    // Continue.dev stores config at ~/.continue/config.json on all platforms
+    return [join(homedir(), ".continue", "config.json")];
+}
 function mergeClaudeStyle(existing, serverBlock) {
     let config = {};
     try {
@@ -53,6 +57,28 @@ function mergeClaudeStyle(existing, serverBlock) {
     config.mcpServers = servers;
     return JSON.stringify(config, null, 2);
 }
+// Continue.dev uses an array under mcpServers (each entry has a "name" field).
+// We upsert by name so re-running setup is idempotent.
+function mergeContinueStyle(existing, serverBlock) {
+    let config = {};
+    try {
+        config = JSON.parse(existing);
+    }
+    catch {
+        config = {};
+    }
+    const entry = { name: "nexarch", ...serverBlock };
+    const servers = config.mcpServers ?? [];
+    const idx = servers.findIndex((s) => s["name"] === "nexarch");
+    if (idx >= 0) {
+        servers[idx] = entry;
+    }
+    else {
+        servers.push(entry);
+    }
+    config.mcpServers = servers;
+    return JSON.stringify(config, null, 2);
+}
 function mergeFlatStyle(existing, serverBlock) {
     let config = {};
     try {
@@ -71,6 +97,7 @@ export function detectClients() {
         ...claudeDesktopPaths().map((p) => ({ name: "Claude Desktop", configPath: p, merge: mergeClaudeStyle })),
         ...cursorPaths().map((p) => ({ name: "Cursor", configPath: p, merge: mergeFlatStyle })),
         ...windsurfPaths().map((p) => ({ name: "Windsurf", configPath: p, merge: mergeFlatStyle })),
+        ...continueDevPaths().map((p) => ({ name: "Continue.dev", configPath: p, merge: mergeContinueStyle })),
     ];
     return candidates.filter((c) => existsSync(join(c.configPath, "..")));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexarch",
-  "version": "0.1.33",
+  "version": "0.2.0",
   "description": "Connect AI coding tools to your Nexarch architecture workspace",
   "keywords": [
     "nexarch",