nexarch 0.4.9 → 0.5.0

package/dist/commands/init-agent.js

@@ -5,7 +5,7 @@ import process from "process";
 import { requireCredentials } from "../lib/credentials.js";
 import { fetchAgentRegistryOrThrow } from "../lib/agent-registry.js";
 import { callMcpTool, mcpInitialize, mcpListTools } from "../lib/mcp.js";
-const CLI_VERSION = "0.4.9";
+const CLI_VERSION = "0.5.0";
 const AGENT_ENTITY_TYPE = "agent";
 const TECH_COMPONENT_ENTITY_TYPE = "technology_component";
 function parseFlag(args, flag) {

package/dist/commands/init-project.js

@@ -1,4 +1,5 @@
 import process from "process";
+import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { basename, join, relative, resolve as resolvePath } from "node:path";
 import { homedir } from "node:os";
@@ -24,6 +25,175 @@ function parseToolText(result) {
 function slugify(name) {
     return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
+function safeExec(command, args, cwd) {
+    try {
+        const out = execFileSync(command, args, { cwd, stdio: ["ignore", "pipe", "ignore"], encoding: "utf8" });
+        const trimmed = out.trim();
+        return trimmed || null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeRepoUrl(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    // user@host:path(.git) → https://host/path
+    const scpLike = trimmed.match(/^(?:[a-z0-9._-]+)@([^:]+):(.+)$/i);
+    if (scpLike) {
+        const host = scpLike[1].toLowerCase();
+        const path = scpLike[2].replace(/\.git$/i, "").replace(/^\/+/, "");
+        return `https://${host}/${path}`;
+    }
+    // ssh://user@host/path(.git) → https://host/path
+    const sshLike = trimmed.match(/^ssh:\/\/(?:[a-z0-9._-]+@)?([^/]+)\/(.+)$/i);
+    if (sshLike) {
+        const host = sshLike[1].toLowerCase();
+        const path = sshLike[2].replace(/\.git$/i, "").replace(/^\/+/, "");
+        return `https://${host}/${path}`;
+    }
+    try {
+        const u = new URL(trimmed);
+        if (u.protocol === "http:" || u.protocol === "https:") {
+            u.hash = "";
+            u.search = "";
+            u.pathname = u.pathname.replace(/\.git$/i, "");
+            return u.toString().replace(/\/$/, "");
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+function inferProvider(ref) {
+    const value = ref.toLowerCase();
+    if (value.includes("github.com"))
+        return "github";
+    if (value.includes("gitlab.com"))
+        return "gitlab";
+    if (value.includes("bitbucket.org"))
+        return "bitbucket";
+    if (value.includes("dev.azure.com") || value.includes("visualstudio.com"))
+        return "azure-repos";
+    if (value.includes("codecommit"))
+        return "codecommit";
+    if (value.includes("git.sr.ht") || value.includes("sourcehut"))
+        return "sourcehut";
+    if (value.includes("forgejo"))
+        return "forgejo";
+    if (value.includes("gitea"))
+        return "gitea";
+    return "unknown";
+}
+function providerCanonicalRepoRef(provider) {
+    switch (provider) {
+        case "github": return "global:repo:github";
+        case "gitlab": return "global:repo:gitlab";
+        case "bitbucket": return "global:repo:bitbucket";
+        case "azure-repos": return "global:repo:azure-repos";
+        case "codecommit": return "global:repo:codecommit";
+        case "gitea": return "global:repo:gitea";
+        case "forgejo": return "global:repo:forgejo";
+        case "sourcehut": return "global:repo:sourcehut";
+        default: return null;
+    }
+}
+function readPackageRepositoryField(dir) {
+    const pkgPath = join(dir, "package.json");
+    if (!existsSync(pkgPath))
+        return null;
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (typeof pkg.repository === "string")
+            return pkg.repository;
+        if (pkg.repository && typeof pkg.repository === "object" && "url" in pkg.repository && typeof pkg.repository.url === "string") {
+            return pkg.repository.url;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+function readHgDefaultPath(dir) {
+    const hgrcPath = join(dir, ".hg", "hgrc");
+    if (!existsSync(hgrcPath))
+        return null;
+    try {
+        const content = readFileSync(hgrcPath, "utf8");
+        const section = content.match(/\[paths\]([\s\S]*?)(\n\[[^\]]+\]|$)/i)?.[1] ?? "";
+        const line = section
+            .split("\n")
+            .map((l) => l.trim())
+            .find((l) => /^default\s*=\s*/i.test(l));
+        if (!line)
+            return null;
+        return line.replace(/^default\s*=\s*/i, "").trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function readSvnRepositoryUrl(dir) {
+    // Best effort using svn CLI if available.
+    const fromCli = safeExec("svn", ["info", "--show-item", "repos-root-url"], dir);
+    if (fromCli)
+        return fromCli;
+    // Very rough fallback for legacy .svn/entries format.
+    const entriesPath = join(dir, ".svn", "entries");
+    if (!existsSync(entriesPath))
+        return null;
+    try {
+        const content = readFileSync(entriesPath, "utf8");
+        const firstUrl = content.match(/https?:\/\/[^\s]+/i)?.[0] ?? null;
+        return firstUrl;
+    }
+    catch {
+        return null;
+    }
+}
+function detectSourceRepository(dir) {
+    let rawRef = null;
+    let vcsType = "unknown";
+    // Prefer git when present.
+    if (existsSync(join(dir, ".git"))) {
+        rawRef = safeExec("git", ["remote", "get-url", "origin"], dir)
+            ?? safeExec("git", ["config", "--get", "remote.origin.url"], dir);
+        if (rawRef)
+            vcsType = "git";
+    }
+    // Mercurial fallback.
+    if (!rawRef && existsSync(join(dir, ".hg"))) {
+        rawRef = safeExec("hg", ["paths", "default"], dir) ?? readHgDefaultPath(dir);
+        if (rawRef)
+            vcsType = "hg";
+    }
+    // Subversion fallback.
+    if (!rawRef && existsSync(join(dir, ".svn"))) {
+        rawRef = readSvnRepositoryUrl(dir);
+        if (rawRef)
+            vcsType = "svn";
+    }
+    // package.json repository fallback (metadata only).
+    if (!rawRef) {
+        rawRef = readPackageRepositoryField(dir);
+        if (rawRef)
+            vcsType = "unknown";
+    }
+    if (!rawRef)
+        return null;
+    const url = normalizeRepoUrl(rawRef);
+    const provider = inferProvider(url ?? rawRef);
+    return {
+        rawRef,
+        url,
+        vcsType,
+        provider,
+        canonicalRepoRef: providerCanonicalRepoRef(provider),
+    };
+}
 // ─── 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)$|(_URL|_SECRET|_TOKEN|_KEY|_PASSWORD|_CREDENTIAL|_DSN|_URI)$/;
@@ -571,6 +741,7 @@ export async function initProject(args) {
     if (!asJson)
         console.log(`Scanning ${dir}…`);
     const { projectName, packageJsonCount, detectedNames, rootDepNames, subPackages, detectedEcosystems } = scanProject(dir);
+    const detectedRepo = detectSourceRepository(dir);
     const displayName = nameOverride ?? projectName;
     const projectSlug = slugify(displayName);
     const projectExternalKey = `${entityTypeOverride}:${projectSlug}`;
@@ -587,6 +758,9 @@ export async function initProject(args) {
         console.log(`  Project : ${displayName} (${entityTypeOverride})`);
         console.log(`  Packages: ${packageJsonCount} package.json file(s)`);
         console.log(`  Detected: ${detectedNames.length} raw names`);
+        if (detectedRepo) {
+            console.log(`  Repo    : ${detectedRepo.url ?? detectedRepo.rawRef} (${detectedRepo.provider}/${detectedRepo.vcsType})`);
+        }
     }
     if (detectedNames.length === 0) {
         if (!asJson)
@@ -613,7 +787,20 @@ export async function initProject(args) {
     if (dryRun) {
         const output = {
             dryRun: true,
-            project: { name: displayName, externalKey: projectExternalKey, entityType: entityTypeOverride },
+            project: {
+                name: displayName,
+                externalKey: projectExternalKey,
+                entityType: entityTypeOverride,
+                sourceRepository: detectedRepo
+                    ? {
+                        ref: detectedRepo.rawRef,
+                        url: detectedRepo.url,
+                        vcsType: detectedRepo.vcsType,
+                        provider: detectedRepo.provider,
+                        componentRef: detectedRepo.canonicalRepoRef,
+                    }
+                    : null,
+            },
             resolved: resolvedItems.map((r) => ({
                 input: r.input,
                 canonicalName: r.canonicalName,
@@ -630,9 +817,11 @@ export async function initProject(args) {
     const policies = parseToolText(policiesRaw);
     const policyBundleHash = policies.policyBundleHash ?? null;
     const nowIso = new Date().toISOString();
-    const repoRef = repoRefOverride ?? dir;
+    const repoRef = repoRefOverride ?? detectedRepo?.rawRef ?? dir;
     const repoPath = repoPathOverride ?? dir;
-    const repoUrl = repoUrlOverride ?? null;
+    const repoUrl = repoUrlOverride ?? detectedRepo?.url ?? null;
+    const sourceVcsType = detectedRepo?.vcsType ?? "unknown";
+    const sourceProvider = detectedRepo?.provider ?? "unknown";
     const agentContext = {
         agentId: "nexarch-cli:init-project",
         agentRunId: `init-project-${Date.now()}`,
@@ -661,8 +850,12 @@ export async function initProject(args) {
             source_dir: dir,
             scanned_at: nowIso,
             package_json_count: packageJsonCount,
-            ...(repoUrl ? { repository_url: repoUrl } : {}),
+            ...(repoUrl ? { repository_url: repoUrl, source_repository_url: repoUrl } : {}),
             repository_ref: repoRef,
+            source_repository_ref: repoRef,
+            source_vcs_type: sourceVcsType,
+            source_provider: sourceProvider,
+            ...(detectedRepo?.canonicalRepoRef ? { source_repository_component_ref: detectedRepo.canonicalRepoRef } : {}),
         },
     });
     // Resolved reference entities (deduplicated by canonical external ref)
@@ -680,6 +873,28 @@ export async function initProject(args) {
             confidence: 0.95,
         });
     }
+    // Ensure source repository component is represented when we can infer one.
+    if (detectedRepo?.canonicalRepoRef && !seenRefs.has(detectedRepo.canonicalRepoRef)) {
+        seenRefs.add(detectedRepo.canonicalRepoRef);
+        entities.push({
+            externalKey: detectedRepo.canonicalRepoRef,
+            entityTypeCode: "technology_component",
+            entitySubtypeCode: "tech_infrastructure",
+            name: detectedRepo.provider === "unknown" ? "Source Repository" : `Source Repository (${detectedRepo.provider})`,
+            confidence: 0.9,
+            ...(repoUrl
+                ? {
+                    attributes: {
+                        repository_url: repoUrl,
+                        source_repository_url: repoUrl,
+                        source_repository_ref: repoRef,
+                        source_vcs_type: sourceVcsType,
+                        source_provider: sourceProvider,
+                    },
+                }
+                : {}),
+        });
+    }
     // Auto-create stub entities for each sub-package
     const seenSubKeys = new Set();
     for (const sp of subPackages) {
@@ -750,6 +965,10 @@ export async function initProject(args) {
             addRel("accountable_for", orgExternalKey, sp.externalKey, 1);
         }
     }
+    // Project depends_on its source repository component when resolved/inferred.
+    if (detectedRepo?.canonicalRepoRef) {
+        addRel("depends_on", projectExternalKey, detectedRepo.canonicalRepoRef, 0.95);
+    }
     if (!asJson)
         console.log(`\nWriting to graph…`);
     // Upsert entities

package/dist/lib/mcp.js

@@ -68,7 +68,7 @@ export async function mcpInitialize(options = {}) {
     return callMcpRpc("initialize", {
         protocolVersion: "2024-11-05",
         capabilities: {},
-        clientInfo: { name: "nexarch-cli", version: "0.4.9" },
+        clientInfo: { name: "nexarch-cli", version: "0.5.0" },
     }, options);
 }
 export async function mcpListTools(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexarch",
-  "version": "0.4.9",
+  "version": "0.5.0",
   "description": "Your architecture workspace for AI delivery.",
   "keywords": [
     "nexarch",