npm - nexarch - Versions diffs - 0.1.0 → 0.1.1 - Mend

nexarch 0.1.0 → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/dist/commands/login.js +171 -0
package/dist/commands/logout.js +12 -0
package/dist/commands/mcp-config.js +32 -0
package/dist/commands/mcp-proxy.js +75 -0
package/dist/commands/setup.js +32 -0
package/dist/commands/status.js +39 -0
package/dist/index.js +45 -0
package/dist/lib/clients.js +88 -0
package/dist/lib/credentials.js +44 -0
package/dist/lib/mcp.js +89 -0
package/package.json +2 -1

package/dist/commands/login.js ADDED Viewed

@@ -0,0 +1,171 @@
+import { createServer } from "http";
+import { createServer as createNetServer } from "net";
+import { randomBytes } from "crypto";
+import { execFile } from "child_process";
+import https from "https";
+import { saveCredentials } from "../lib/credentials.js";
+const NEXARCH_URL = "https://nexarch.ai";
+const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+const VERIFY_TIMEOUT_MS = 15 * 1000;
+function generateState() {
+    return randomBytes(16).toString("hex");
+}
+function findFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = createNetServer();
+        server.listen(0, "127.0.0.1", () => {
+            const addr = server.address();
+            const port = typeof addr === "object" && addr ? addr.port : null;
+            server.close(() => {
+                if (port)
+                    resolve(port);
+                else
+                    reject(new Error("Could not find a free port"));
+            });
+        });
+        server.on("error", reject);
+    });
+}
+function openBrowser(url) {
+    // Use execFile to avoid shell injection — URL is passed as a separate argument.
+    const [cmd, args] = process.platform === "darwin"
+        ? ["open", [url]]
+        : process.platform === "win32"
+            ? ["cmd", ["/c", "start", "", url]]
+            : ["xdg-open", [url]];
+    execFile(cmd, args, (err) => {
+        if (err) {
+            // Non-fatal — the URL is already printed so the user can open it manually.
+        }
+    });
+}
+function waitForCallback(port, expectedState) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            fn();
+        };
+        // Declare server before timeout so the timeout handler can safely close it.
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+            if (url.pathname !== "/callback") {
+                res.writeHead(404);
+                res.end();
+                return;
+            }
+            clearTimeout(timeout);
+            const state = url.searchParams.get("state");
+            const token = url.searchParams.get("token");
+            const error = url.searchParams.get("error");
+            const html = (message) => `<!DOCTYPE html><html><head><meta charset="utf-8"><title>Nexarch CLI</title>
+        <style>body{font-family:system-ui,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;margin:0;background:#f8fafc}
+        .card{background:#fff;border:1px solid #e2e8f0;border-radius:12px;padding:2rem;max-width:400px;text-align:center}
+        h1{font-size:1.25rem;margin:0 0 .5rem;color:#0f172a}p{color:#64748b;font-size:.9rem;margin:.5rem 0}</style></head>
+        <body><div class="card"><h1>Nexarch CLI</h1><p>${message}</p></div></body></html>`;
+            if (state !== expectedState) {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end(html("Invalid state parameter. Please run <code>nexarch login</code> again."));
+                server.close();
+                settle(() => reject(new Error("State mismatch — possible CSRF. Run `nexarch login` to try again.")));
+                return;
+            }
+            if (error) {
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end(html("Authorization cancelled. You can close this tab."));
+                server.close();
+                settle(() => reject(new Error("Authorization was cancelled.")));
+                return;
+            }
+            if (!token) {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end(html("Missing token. Please run <code>nexarch login</code> again."));
+                server.close();
+                settle(() => reject(new Error("No token received from authorization server.")));
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(html("Authorization successful! You can close this tab and return to your terminal."));
+            server.close();
+            settle(() => resolve({ token }));
+        });
+        const timeout = setTimeout(() => {
+            server.close();
+            settle(() => reject(new Error("Authorization timed out after 5 minutes. Run `nexarch login` to try again.")));
+        }, LOGIN_TIMEOUT_MS);
+        server.listen(port, "127.0.0.1");
+        server.on("error", (err) => {
+            clearTimeout(timeout);
+            settle(() => reject(err));
+        });
+    });
+}
+function fetchCompanyId(token) {
+    const body = JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: { name: "nexarch_get_governance_summary", arguments: {} },
+    });
+    return new Promise((resolve, reject) => {
+        const url = new URL("/mcp", "https://mcp.nexarch.ai");
+        const req = https.request({
+            hostname: url.hostname,
+            port: url.port || 443,
+            path: url.pathname,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+                "Content-Length": Buffer.byteLength(body),
+            },
+            timeout: VERIFY_TIMEOUT_MS,
+        }, (res) => {
+            const chunks = [];
+            res.on("data", (c) => chunks.push(c));
+            res.on("end", () => {
+                try {
+                    const raw = Buffer.concat(chunks).toString("utf-8");
+                    const json = JSON.parse(raw);
+                    if (json.error)
+                        return reject(new Error(json.error.message));
+                    const text = json.result?.content?.[0]?.text ?? "{}";
+                    const data = JSON.parse(text);
+                    const companyId = data.companyId;
+                    if (!companyId)
+                        return reject(new Error("Could not retrieve workspace ID from Nexarch."));
+                    resolve(companyId);
+                }
+                catch {
+                    reject(new Error("Unexpected response while verifying credentials."));
+                }
+            });
+        });
+        req.on("timeout", () => {
+            req.destroy(new Error("Timed out verifying credentials. Check your connection and try again."));
+        });
+        req.on("error", reject);
+        req.write(body);
+        req.end();
+    });
+}
+export async function login(_args) {
+    const state = generateState();
+    const port = await findFreePort();
+    const authUrl = `${NEXARCH_URL}/auth/cli?port=${port}&state=${state}`;
+    console.log("Opening Nexarch in your browser…");
+    console.log(`\n  ${authUrl}\n`);
+    console.log("If the browser did not open, copy the URL above and paste it in manually.\n");
+    openBrowser(authUrl);
+    const { token } = await waitForCallback(port, state);
+    process.stdout.write("Verifying credentials… ");
+    const companyId = await fetchCompanyId(token);
+    console.log("done\n");
+    const expiresAt = new Date();
+    expiresAt.setDate(expiresAt.getDate() + 90);
+    saveCredentials({ token, email: "", company: "", companyId, expiresAt: expiresAt.toISOString() });
+    console.log("✓ Logged in successfully");
+    console.log("\nRun `nexarch status` to verify your connection.");
+}

package/dist/commands/logout.js ADDED Viewed

@@ -0,0 +1,12 @@
+import { loadCredentials, removeCredentials } from "../lib/credentials.js";
+export async function logout(_args) {
+    const creds = loadCredentials();
+    if (!creds) {
+        console.log("Not logged in.");
+        return;
+    }
+    removeCredentials();
+    console.log("✓ Logged out. Credentials removed from ~/.nexarch/credentials.json");
+    console.log("\nNote: the token still exists in your Nexarch workspace until revoked.");
+    console.log("To revoke it, visit Workspace → Agents → Manage tokens.");
+}

package/dist/commands/mcp-config.js ADDED Viewed

@@ -0,0 +1,32 @@
+import { nexarchServerBlock } from "../lib/clients.js";
+export async function mcpConfig(args) {
+    const clientFlag = args.find((a) => !a.startsWith("-")) ?? "claude-desktop";
+    const serverBlock = nexarchServerBlock();
+    console.log(`\nMCP server config for ${clientFlag}:\n`);
+    switch (clientFlag) {
+        case "claude-desktop": {
+            const config = { mcpServers: { nexarch: serverBlock } };
+            console.log("Add the following to your claude_desktop_config.json:\n");
+            console.log(JSON.stringify(config, null, 2));
+            console.log(`
+Locations:
+  macOS:   ~/Library/Application Support/Claude/claude_desktop_config.json
+  Windows: %APPDATA%\\Claude\\claude_desktop_config.json
+      `);
+            break;
+        }
+        case "cursor":
+        case "windsurf": {
+            const config = { mcpServers: { nexarch: serverBlock } };
+            console.log(`Add the following to your ${clientFlag === "cursor" ? ".cursor/mcp.json" : ".windsurf/mcp.json"}:\n`);
+            console.log(JSON.stringify(config, null, 2));
+            break;
+        }
+        default: {
+            const config = { mcpServers: { nexarch: serverBlock } };
+            console.log(JSON.stringify(config, null, 2));
+            break;
+        }
+    }
+    console.log("\nOr run `nexarch setup` to have the CLI write the config automatically.");
+}

package/dist/commands/mcp-proxy.js ADDED Viewed

@@ -0,0 +1,75 @@
+import * as readline from "readline";
+import { requireCredentials } from "../lib/credentials.js";
+import { forwardToGateway } from "../lib/mcp.js";
+/**
+ * stdio MCP proxy — bridges MCP clients (Claude Desktop, Cursor, etc.) that
+ * use stdio transport to the Nexarch HTTP MCP gateway.
+ *
+ * The MCP protocol over stdio is newline-delimited JSON-RPC 2.0.
+ * Each line from stdin is a complete JSON-RPC message.
+ * Responses are written to stdout as single-line JSON.
+ */
+export async function mcpProxy(_args) {
+    const creds = requireCredentials();
+    const rl = readline.createInterface({
+        input: process.stdin,
+        terminal: false,
+    });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let message = {};
+        try {
+            message = JSON.parse(trimmed);
+        }
+        catch {
+            // Malformed input — write a parse error and continue
+            const errorResponse = JSON.stringify({
+                jsonrpc: "2.0",
+                id: null,
+                error: { code: -32700, message: "Parse error" },
+            });
+            process.stdout.write(errorResponse + "\n");
+            continue;
+        }
+        // Notifications (no id) — forward but don't write a response to stdout.
+        const isNotification = message.id === undefined || message.id === null;
+        try {
+            const { status, body } = await forwardToGateway(creds.token, creds.companyId, trimmed);
+            if (isNotification) {
+                // Notifications expect no response per JSON-RPC spec.
+                continue;
+            }
+            if (status === 200 && body) {
+                // Write response as a single line.
+                process.stdout.write(body.replace(/\n/g, " ") + "\n");
+            }
+            else if (status === 401) {
+                const errorResponse = JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: message.id ?? null,
+                    error: { code: -32001, message: "Unauthorized — run `nexarch login` to re-authenticate." },
+                });
+                process.stdout.write(errorResponse + "\n");
+            }
+            else {
+                const errorResponse = JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: message.id ?? null,
+                    error: { code: -32000, message: `Gateway error (HTTP ${status})` },
+                });
+                process.stdout.write(errorResponse + "\n");
+            }
+        }
+        catch (err) {
+            const message2 = err instanceof Error ? err.message : "Internal error";
+            const errorResponse = JSON.stringify({
+                jsonrpc: "2.0",
+                id: message.id ?? null,
+                error: { code: -32000, message: message2 },
+            });
+            process.stdout.write(errorResponse + "\n");
+        }
+    }
+}

package/dist/commands/setup.js ADDED Viewed

@@ -0,0 +1,32 @@
+import { requireCredentials } from "../lib/credentials.js";
+import { detectClients, writeClientConfig, nexarchServerBlock } from "../lib/clients.js";
+export async function setup(_args) {
+    requireCredentials(); // ensure logged in before configuring anything
+    console.log("Detecting installed MCP clients…\n");
+    const clients = detectClients();
+    if (clients.length === 0) {
+        console.log("No supported MCP clients detected.");
+        console.log("\nSupported clients: Claude Desktop, Cursor, Windsurf");
+        console.log("\nTo configure manually, run:");
+        console.log("  nexarch mcp-config --client claude-desktop");
+        return;
+    }
+    const serverBlock = nexarchServerBlock();
+    for (const client of clients) {
+        process.stdout.write(`  ${client.name.padEnd(20)} ${client.configPath}\n`);
+        process.stdout.write(`  ${"".padEnd(20)} `);
+        try {
+            writeClientConfig(client, serverBlock);
+            console.log("✓ configured");
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.log(`✗ failed — ${message}`);
+        }
+    }
+    console.log("\nDone. Restart your MCP client for the changes to take effect.");
+    console.log("\nThe nexarch tools will be available to your AI coding assistant:");
+    console.log("  nexarch_list_architecture_snapshots");
+    console.log("  nexarch_get_snapshot_facts");
+    console.log("  nexarch_get_governance_summary");
+}

package/dist/commands/status.js ADDED Viewed

@@ -0,0 +1,39 @@
+import { requireCredentials } from "../lib/credentials.js";
+import { callMcpTool } from "../lib/mcp.js";
+export async function status(_args) {
+    const creds = requireCredentials();
+    const expiresAt = new Date(creds.expiresAt);
+    const daysLeft = Math.ceil((expiresAt.getTime() - Date.now()) / (1000 * 60 * 60 * 24));
+    process.stdout.write("Connecting to mcp.nexarch.ai… ");
+    let governance;
+    try {
+        const result = await callMcpTool("nexarch_get_governance_summary", {
+            companyId: creds.companyId || undefined,
+        });
+        governance = JSON.parse(result.content[0]?.text ?? "{}");
+    }
+    catch (err) {
+        console.error("failed\n");
+        throw err;
+    }
+    console.log("connected\n");
+    if (creds.email) {
+        console.log(`  Signed in as:   ${creds.email}`);
+    }
+    if (creds.company) {
+        console.log(`  Workspace:      ${creds.company}`);
+    }
+    console.log(`\n  Architecture facts:  ${governance.canonicalFactCount}`);
+    console.log(`  Pending review:      ${governance.reviewQueue.pending_entities} entities, ${governance.reviewQueue.pending_relationships} relationships`);
+    if (governance.latestSnapshot) {
+        const snapshotDate = new Date(governance.latestSnapshot.created_at).toLocaleDateString();
+        console.log(`  Latest snapshot:     ${snapshotDate} (${governance.latestSnapshot.status})`);
+    }
+    else {
+        console.log(`  Latest snapshot:     none published yet`);
+    }
+    console.log(`\n  Token expires:  ${expiresAt.toLocaleDateString()} (${daysLeft} days)`);
+    if (daysLeft <= 14) {
+        console.log(`\n  ⚠  Your token expires soon. Run \`nexarch login\` to renew.`);
+    }
+}

package/dist/index.js ADDED Viewed

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { login } from "./commands/login.js";
+import { logout } from "./commands/logout.js";
+import { status } from "./commands/status.js";
+import { setup } from "./commands/setup.js";
+import { mcpConfig } from "./commands/mcp-config.js";
+import { mcpProxy } from "./commands/mcp-proxy.js";
+const [, , command, ...args] = process.argv;
+const commands = {
+    login,
+    logout,
+    status,
+    setup,
+    "mcp-config": mcpConfig,
+    "mcp-proxy": mcpProxy,
+};
+async function main() {
+    const handler = commands[command ?? ""];
+    if (!handler) {
+        console.log(`
+nexarch — Connect AI coding tools to your architecture workspace
+Usage:
+  nexarch login         Authenticate in the browser and store credentials
+  nexarch logout        Remove stored credentials
+  nexarch status        Check connection and show architecture summary
+  nexarch setup         Auto-configure your MCP client (Claude Desktop, Cursor, etc.)
+  nexarch mcp-config    Print MCP server config block for manual setup
+  nexarch mcp-proxy     Run as stdio MCP proxy (used by MCP clients)
+    `);
+        process.exit(command ? 1 : 0);
+    }
+    try {
+        await handler(args);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`error: ${message}`);
+        process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error(`error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+});

package/dist/lib/clients.js ADDED Viewed

@@ -0,0 +1,88 @@
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+function appData() {
+    return process.env.APPDATA ?? null;
+}
+function claudeDesktopPaths() {
+    switch (process.platform) {
+        case "darwin":
+            return [join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json")];
+        case "win32": {
+            const ad = appData();
+            return ad ? [join(ad, "Claude", "claude_desktop_config.json")] : [];
+        }
+        default:
+            return [join(homedir(), ".config", "Claude", "claude_desktop_config.json")];
+    }
+}
+function cursorPaths() {
+    switch (process.platform) {
+        case "darwin":
+            return [join(homedir(), ".cursor", "mcp.json")];
+        case "win32": {
+            const ad = appData();
+            return ad ? [join(ad, "Cursor", "User", "mcp.json")] : [];
+        }
+        default:
+            return [join(homedir(), ".cursor", "mcp.json")];
+    }
+}
+function windsurfPaths() {
+    switch (process.platform) {
+        case "darwin":
+            return [join(homedir(), ".windsurf", "mcp.json")];
+        case "win32": {
+            const ad = appData();
+            return ad ? [join(ad, "Windsurf", "User", "mcp.json")] : [];
+        }
+        default:
+            return [join(homedir(), ".windsurf", "mcp.json")];
+    }
+}
+function mergeClaudeStyle(existing, serverBlock) {
+    let config = {};
+    try {
+        config = JSON.parse(existing);
+    }
+    catch {
+        // start fresh if file is empty or invalid
+    }
+    const servers = config.mcpServers ?? {};
+    servers["nexarch"] = serverBlock;
+    config.mcpServers = servers;
+    return JSON.stringify(config, null, 2);
+}
+function mergeFlatStyle(existing, serverBlock) {
+    let config = {};
+    try {
+        config = JSON.parse(existing);
+    }
+    catch {
+        config = { mcpServers: {} };
+    }
+    const servers = config.mcpServers ?? {};
+    servers["nexarch"] = serverBlock;
+    config.mcpServers = servers;
+    return JSON.stringify(config, null, 2);
+}
+export function detectClients() {
+    const candidates = [
+        ...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 })),
+    ];
+    return candidates.filter((c) => existsSync(join(c.configPath, "..")));
+}
+export function writeClientConfig(client, serverBlock) {
+    const dir = join(client.configPath, "..");
+    mkdirSync(dir, { recursive: true });
+    const existing = existsSync(client.configPath) ? readFileSync(client.configPath, "utf-8") : "";
+    writeFileSync(client.configPath, client.merge(existing, serverBlock), "utf-8");
+}
+export function nexarchServerBlock() {
+    return {
+        command: "npx",
+        args: ["-y", "nexarch@latest", "mcp-proxy"],
+    };
+}

package/dist/lib/credentials.js ADDED Viewed

@@ -0,0 +1,44 @@
+import { homedir } from "os";
+import { join } from "path";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, rmSync } from "fs";
+function credentialsPath() {
+    return join(homedir(), ".nexarch", "credentials.json");
+}
+export function loadCredentials() {
+    const path = credentialsPath();
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const creds = JSON.parse(raw);
+        if (!creds.token)
+            return null;
+        return creds;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveCredentials(creds) {
+    const dir = join(homedir(), ".nexarch");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(credentialsPath(), JSON.stringify(creds, null, 2), {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+}
+export function removeCredentials() {
+    const path = credentialsPath();
+    if (existsSync(path))
+        rmSync(path);
+}
+export function requireCredentials() {
+    const creds = loadCredentials();
+    if (!creds) {
+        throw new Error("Not logged in. Run `nexarch login` to authenticate.");
+    }
+    if (new Date(creds.expiresAt) < new Date()) {
+        throw new Error("Your session has expired. Run `nexarch login` to re-authenticate.");
+    }
+    return creds;
+}

package/dist/lib/mcp.js ADDED Viewed

@@ -0,0 +1,89 @@
+import https from "https";
+import { requireCredentials } from "./credentials.js";
+const MCP_GATEWAY_URL = "https://mcp.nexarch.ai";
+const REQUEST_TIMEOUT_MS = 30 * 1000;
+export async function callMcpTool(toolName, toolArgs = {}) {
+    const creds = requireCredentials();
+    const body = JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: { name: toolName, arguments: toolArgs },
+    });
+    return new Promise((resolve, reject) => {
+        const url = new URL("/mcp", MCP_GATEWAY_URL);
+        const req = https.request({
+            hostname: url.hostname,
+            port: url.port || 443,
+            path: url.pathname,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${creds.token}`,
+                "x-company-id": creds.companyId,
+                "Content-Length": Buffer.byteLength(body),
+            },
+            timeout: REQUEST_TIMEOUT_MS,
+        }, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                try {
+                    const raw = Buffer.concat(chunks).toString("utf-8");
+                    const json = JSON.parse(raw);
+                    if (json.error) {
+                        reject(new Error(json.error.message));
+                    }
+                    else if (json.result) {
+                        resolve(json.result);
+                    }
+                    else {
+                        reject(new Error("Unexpected response from MCP gateway"));
+                    }
+                }
+                catch {
+                    reject(new Error("Failed to parse MCP gateway response"));
+                }
+            });
+        });
+        req.on("timeout", () => {
+            req.destroy(new Error("Request timed out. Check your connection and try again."));
+        });
+        req.on("error", reject);
+        req.write(body);
+        req.end();
+    });
+}
+export async function forwardToGateway(token, companyId, body) {
+    return new Promise((resolve, reject) => {
+        const url = new URL("/mcp", MCP_GATEWAY_URL);
+        const req = https.request({
+            hostname: url.hostname,
+            port: url.port || 443,
+            path: url.pathname,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${token}`,
+                "x-company-id": companyId,
+                "Content-Length": Buffer.byteLength(body),
+            },
+            timeout: REQUEST_TIMEOUT_MS,
+        }, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                resolve({
+                    status: res.statusCode ?? 200,
+                    body: Buffer.concat(chunks).toString("utf-8"),
+                });
+            });
+        });
+        req.on("timeout", () => {
+            req.destroy(new Error("Request timed out."));
+        });
+        req.on("error", reject);
+        req.write(body);
+        req.end();
+    });
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "nexarch",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Connect AI coding tools to your Nexarch architecture workspace",
   "keywords": [
     "nexarch",
@@ -23,6 +23,7 @@
   ],
   "scripts": {
     "build": "tsc",
+    "prepublishOnly": "tsc",
     "dev": "tsx src/index.ts",
     "typecheck": "tsc --noEmit"
   },