nexarch 0.4.9 → 0.5.1

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.1";
 const AGENT_ENTITY_TYPE = "agent";
 const TECH_COMPONENT_ENTITY_TYPE = "technology_component";
 function parseFlag(args, flag) {

package/dist/commands/init-project.js

@@ -1,9 +1,11 @@
 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";
 import { requireCredentials } from "../lib/credentials.js";
 import { callMcpTool } from "../lib/mcp.js";
+import { CURATED_AGENT_ICON_NAMES } from "../lib/application-icons.js";
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 function parseFlag(args, flag) {
     return args.includes(flag);
@@ -24,6 +26,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 +742,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 +759,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 +788,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 +818,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 +851,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 +874,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 +966,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
@@ -768,6 +988,7 @@ export async function initProject(args) {
         const ecosystemLabel = detectedEcosystems.length > 0
             ? detectedEcosystems.join(", ")
             : "unknown";
+        const curatedIconList = CURATED_AGENT_ICON_NAMES.join(", ");
         const manifestHint = detectedEcosystems.includes("nodejs")
             ? "package.json"
             : detectedEcosystems.includes("python")
@@ -800,6 +1021,11 @@ ${subPackages.map((sp) => `    • ${sp.name}  (${sp.relativePath})`).join("\n")
     Type definitions or utility package with no runtime
       → --entity-type technology_component --subtype tech_library
 
+  ICON ASSIGNMENT (applications only):
+    • Pick one icon from this curated set for each application/sub-app.
+    • If confidence is low, skip --icon rather than guessing.
+    • Allowed icons: ${curatedIconList}
+
   For each sub-package, run update-entity to register it:
 
   npx nexarch update-entity \\
@@ -807,7 +1033,8 @@ ${subPackages.map((sp) => `    • ${sp.name}  (${sp.relativePath})`).join("\n")
     --entity-type "<chosen entity type>" \\
     --subtype "<chosen subtype>" \\
     --name "<human readable name>" \\
-    --description "<what this package does and its role in the project>"
+    --description "<what this package does and its role in the project>" \\
+    --icon "<curated icon>"   # applications only
 
   Then register it as a resolvable alias so future scans don't re-surface it as a candidate:
 
@@ -922,13 +1149,18 @@ STEP 2 — Enrich the project entity. Run this command with the description you'
 
   npx nexarch update-entity \\
     --key "${projectExternalKey}" \\
-    --entity-type "${entityTypeOverride}"${entityTypeOverride === "application" ? " \\\n    --subtype \"app_custom_built\"" : ""} \\
+    --entity-type "${entityTypeOverride}"${entityTypeOverride === "application" ? " \\\n    --subtype \"app_custom_built\"\n    --icon \"<curated icon>\"" : ""} \\
     --name "<proper product name from README>" \\
     --description "<2–4 sentence summary of what it does and why>"
 ${subPkgSection}${gapCheckSection}`;
     }
     const enrichmentTask = {
         instructions: buildEnrichmentInstructions(),
+        iconHints: {
+            provider: "lucide",
+            curated: CURATED_AGENT_ICON_NAMES,
+            note: "Use curated list for agent-selected enrichment icons; omit icon when low confidence.",
+        },
         projectEntity: {
             externalKey: projectExternalKey,
             entityType: entityTypeOverride,

package/dist/commands/update-entity.js

@@ -1,6 +1,7 @@
 import process from "process";
 import { requireCredentials } from "../lib/credentials.js";
 import { callMcpTool } from "../lib/mcp.js";
+import { CURATED_AGENT_ICON_SET } from "../lib/application-icons.js";
 function parseFlag(args, flag) {
     return args.includes(flag);
 }
@@ -24,6 +25,7 @@ export async function updateEntity(args) {
     const description = parseOptionValue(args, "--description");
     const entityTypeCode = parseOptionValue(args, "--entity-type") ?? "application";
     const entitySubtypeCode = parseOptionValue(args, "--subtype");
+    const iconName = parseOptionValue(args, "--icon");
     if (!externalKey) {
         console.error("error: --key <externalKey> is required");
         process.exit(1);
@@ -50,6 +52,10 @@ export async function updateEntity(args) {
     const policyContext = policyBundleHash
         ? { policyBundleHash, alignmentSummary: { score: 1, violations: [], waivers: [] } }
         : undefined;
+    if (iconName && !CURATED_AGENT_ICON_SET.has(iconName)) {
+        console.error(`error: --icon must be one of the curated agent icons (got '${iconName}')`);
+        process.exit(1);
+    }
     const entity = {
         externalKey,
         entityTypeCode,
@@ -61,6 +67,14 @@ export async function updateEntity(args) {
         entity.description = description;
     if (entitySubtypeCode)
         entity.entitySubtypeCode = entitySubtypeCode;
+    if (iconName) {
+        entity.attributes = {
+            application_icon: {
+                provider: "lucide",
+                name: iconName,
+            },
+        };
+    }
     const raw = await callMcpTool("nexarch_upsert_entities", { entities: [entity], agentContext, policyContext }, mcpOpts);
     const result = parseToolText(raw);
     if (asJson) {

package/dist/index.js

@@ -87,6 +87,7 @@ Usage:
                                --description <text>
                                --entity-type <code>  (default: application)
                                --subtype <code>
+                               --icon <lucide-name>  (curated set; for agent enrichment)
                                --json
   nexarch add-relationship
                       Add a relationship between two existing graph entities.

package/dist/lib/application-icons.js

@@ -0,0 +1,49 @@
+export const CURATED_AGENT_ICON_NAMES = [
+    "rocket",
+    "globe",
+    "monitor",
+    "smartphone",
+    "server",
+    "database",
+    "cloud",
+    "network",
+    "shield",
+    "lock",
+    "cpu",
+    "code",
+    "terminal",
+    "bug",
+    "flask-conical",
+    "bot",
+    "brain",
+    "sparkles",
+    "activity",
+    "gauge",
+    "clock-3",
+    "calendar",
+    "book-open",
+    "file-code",
+    "folder",
+    "search",
+    "filter",
+    "list-checks",
+    "kanban-square",
+    "layers",
+    "workflow",
+    "git-branch",
+    "package",
+    "wrench",
+    "settings",
+    "building-2",
+    "factory",
+    "store",
+    "map",
+    "users",
+    "briefcase",
+    "bar-chart-3",
+    "trending-up",
+    "target",
+    "leaf",
+    "heart-pulse",
+];
+export const CURATED_AGENT_ICON_SET = new Set(CURATED_AGENT_ICON_NAMES);

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.1" },
     }, options);
 }
 export async function mcpListTools(options = {}) {

package/package.json

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