gitnexus 1.6.3-rc.9 → 1.6.3

package/dist/mcp/resources.js

@@ -65,36 +65,113 @@ export function getResourceTemplates() {
             description: 'Step-by-step execution trace',
             mimeType: 'text/yaml',
         },
+        {
+            uriTemplate: 'gitnexus://group/{name}/contracts',
+            name: 'Group Contract Registry',
+            description: 'Cross-repo contract registry for a repository group. Optional query: type, repo, unmatchedOnly (true|false).',
+            mimeType: 'text/yaml',
+        },
+        {
+            uriTemplate: 'gitnexus://group/{name}/status',
+            name: 'Group Index Status',
+            description: 'Per-repo index and contract-registry staleness for a repository group',
+            mimeType: 'text/yaml',
+        },
     ];
 }
+function parseUnmatchedOnlyParam(raw) {
+    if (raw === null)
+        return undefined;
+    const v = raw.trim().toLowerCase();
+    if (v === 'true' || v === '1')
+        return true;
+    if (v === 'false' || v === '0')
+        return false;
+    return undefined;
+}
 /**
- * Parse a resource URI to extract the repo name and resource type.
+ * Parse a GitNexus resource URI (repos, setup, per-repo, or per-group templates).
+ * Used by `readResource` and tests (round-trip / dispatch coverage).
  */
-function parseUri(uri) {
+export function parseResourceUri(uri) {
     if (uri === 'gitnexus://repos')
-        return { resourceType: 'repos' };
+        return { kind: 'repos' };
     if (uri === 'gitnexus://setup')
-        return { resourceType: 'setup' };
-    // Repo-scoped: gitnexus://repo/{name}/context
-    const repoMatch = uri.match(/^gitnexus:\/\/repo\/([^/]+)\/(.+)$/);
-    if (repoMatch) {
-        const repoName = decodeURIComponent(repoMatch[1]);
-        const rest = repoMatch[2];
+        return { kind: 'setup' };
+    let u;
+    try {
+        u = new URL(uri);
+    }
+    catch {
+        throw new Error(`Unknown resource URI: ${uri}`);
+    }
+    if (u.protocol !== 'gitnexus:') {
+        throw new Error(`Unknown resource URI: ${uri}`);
+    }
+    if (u.hostname === 'group') {
+        const segments = u.pathname
+            .replace(/^\/+|\/+$/g, '')
+            .split('/')
+            .filter(Boolean);
+        if (segments.length < 2) {
+            throw new Error(`Invalid group resource URI (expected gitnexus://group/{name}/contracts or .../status): ${uri}`);
+        }
+        const tail = segments[segments.length - 1];
+        if (tail !== 'contracts' && tail !== 'status') {
+            throw new Error(`Unknown group resource path in URI: ${uri}`);
+        }
+        const groupName = segments
+            .slice(0, -1)
+            .map((s) => decodeURIComponent(s))
+            .join('/');
+        if (!groupName) {
+            throw new Error(`Invalid group resource URI (empty group name): ${uri}`);
+        }
+        if (tail === 'status') {
+            return { kind: 'group', groupName, resourceType: 'status' };
+        }
+        const contractsFilter = {};
+        const type = u.searchParams.get('type');
+        if (type && type.trim())
+            contractsFilter.type = type.trim();
+        const repo = u.searchParams.get('repo');
+        if (repo && repo.trim())
+            contractsFilter.repo = repo.trim();
+        if (u.searchParams.has('unmatchedOnly')) {
+            const coerced = parseUnmatchedOnlyParam(u.searchParams.get('unmatchedOnly'));
+            if (coerced !== undefined)
+                contractsFilter.unmatchedOnly = coerced;
+        }
+        return { kind: 'group', groupName, resourceType: 'contracts', contractsFilter };
+    }
+    if (u.hostname === 'repo') {
+        const segments = u.pathname
+            .replace(/^\/+|\/+$/g, '')
+            .split('/')
+            .filter(Boolean);
+        if (segments.length < 2) {
+            throw new Error(`Unknown resource URI: ${uri}`);
+        }
+        const repoName = decodeURIComponent(segments[0]);
+        const restEncoded = segments.slice(1);
+        const rest = restEncoded.map((s) => decodeURIComponent(s)).join('/');
         if (rest.startsWith('cluster/')) {
             return {
+                kind: 'repo',
                 repoName,
                 resourceType: 'cluster',
-                param: decodeURIComponent(rest.replace('cluster/', '')),
+                param: rest.replace(/^cluster\//, ''),
             };
         }
         if (rest.startsWith('process/')) {
             return {
+                kind: 'repo',
                 repoName,
                 resourceType: 'process',
-                param: decodeURIComponent(rest.replace('process/', '')),
+                param: rest.replace(/^process\//, ''),
             };
         }
-        return { repoName, resourceType: rest };
+        return { kind: 'repo', repoName, resourceType: rest };
     }
     throw new Error(`Unknown resource URI: ${uri}`);
 }
@@ -102,15 +179,19 @@ function parseUri(uri) {
  * Read a resource and return its content
  */
 export async function readResource(uri, backend) {
-    const parsed = parseUri(uri);
-    // Global repos list — no repo context needed
-    if (parsed.resourceType === 'repos') {
+    const parsed = parseResourceUri(uri);
+    if (parsed.kind === 'repos') {
         return getReposResource(backend);
     }
-    // Setup resource — returns AGENTS.md content for all repos
-    if (parsed.resourceType === 'setup') {
+    if (parsed.kind === 'setup') {
         return getSetupResource(backend);
     }
+    if (parsed.kind === 'group') {
+        if (parsed.resourceType === 'contracts') {
+            return backend.readGroupContractsResource(parsed.groupName, parsed.contractsFilter);
+        }
+        return backend.readGroupStatusResource(parsed.groupName);
+    }
     const repoName = parsed.repoName;
     switch (parsed.resourceType) {
         case 'context':
@@ -202,6 +283,8 @@ async function getContextResource(backend, repoName) {
     lines.push(`  - gitnexus://repo/${context.projectName}/processes: All execution flows`);
     lines.push(`  - gitnexus://repo/${context.projectName}/cluster/{name}: Module details`);
     lines.push(`  - gitnexus://repo/${context.projectName}/process/{name}: Process trace`);
+    lines.push('  - gitnexus://group/{name}/contracts: Group contract registry (optional ?type=&repo=&unmatchedOnly=)');
+    lines.push('  - gitnexus://group/{name}/status: Group index / contract staleness');
     return lines.join('\n');
 }
 /**

package/dist/mcp/tools.d.ts

@@ -12,11 +12,14 @@ export interface ToolDefinition {
         properties: Record<string, {
             type: string;
             description?: string;
-            default?: any;
+            default?: unknown;
             items?: {
                 type: string;
             };
             enum?: string[];
+            minimum?: number;
+            maximum?: number;
+            minLength?: number;
         }>;
         required: string[];
     };

package/dist/mcp/tools.js

@@ -35,7 +35,11 @@ Returns results grouped by process (execution flow):
 - process_symbols: all symbols in those flows with file locations and module (functional area)
 - definitions: standalone types/interfaces not in any process
 
-Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank Fusion.`,
+Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank Fusion.
+
+GROUP MODE: set "repo" to "@<groupName>" to search all member repos in that group (merged via RRF), or "@<groupName>/<groupRepoPath>" to run against a single member (same path keys as in group.yaml). If you use "@<groupName>" only, the member repo defaults to the lexicographically first key in group.yaml "repos". Prefer resources for contracts/status (see migration from legacy group_* tools).
+
+SERVICE: optional monorepo path prefix (POSIX-style, case-sensitive segments). When "repo" starts with "@", only processes whose symbols fall under that prefix are included. For a normal indexed repo name (no leading @), this field is currently ignored by the server.`,
         inputSchema: {
             type: 'object',
             properties: {
@@ -48,11 +52,19 @@ Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank
                     type: 'string',
                     description: 'What you want to find (e.g., "existing auth validation logic"). Helps ranking.',
                 },
-                limit: { type: 'number', description: 'Max processes to return (default: 5)', default: 5 },
+                limit: {
+                    type: 'number',
+                    description: 'Max processes to return (default: 5)',
+                    default: 5,
+                    minimum: 1,
+                    maximum: 100,
+                },
                 max_symbols: {
                     type: 'number',
                     description: 'Max symbols per process (default: 10)',
                     default: 10,
+                    minimum: 1,
+                    maximum: 200,
                 },
                 include_content: {
                     type: 'boolean',
@@ -61,7 +73,12 @@ Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank
                 },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                    description: 'Indexed repository name or path, or group mode "@<groupName>" / "@<groupName>/<memberPath>" (member path keys from group.yaml). Omit when only one indexed repo exists.',
+                },
+                service: {
+                    type: 'string',
+                    minLength: 1,
+                    description: 'Optional monorepo service root (relative path, "/" separators). In group mode (@repo), prefix-matches symbol file paths; ignored for a normal repo name. Empty string is rejected server-side.',
                 },
             },
             required: ['query'],
@@ -135,7 +152,11 @@ AFTER THIS: Use impact() if planning changes, or READ gitnexus://repo/{name}/pro
 
 Handles disambiguation: if multiple symbols share the same name, returns ranked candidates (each with a relevance score) for you to pick from. Use uid for zero-ambiguity lookup, or narrow the search with file_path and/or kind hints.
 
-NOTE: ACCESSES edges (field read/write tracking) are included in context results with reason 'read' or 'write'. CALLS edges resolve through field access chains and method-call chains (e.g., user.address.getCity().save() produces CALLS edges at each step).`,
+NOTE: ACCESSES edges (field read/write tracking) are included in context results with reason 'read' or 'write'. CALLS edges resolve through field access chains and method-call chains (e.g., user.address.getCity().save() produces CALLS edges at each step).
+
+GROUP MODE: set "repo" to "@<groupName>" to run context in each member repo (aggregated list), or "@<groupName>/<groupRepoPath>" for one member. If you use "@<groupName>" only, the member defaults to the lexicographically first key in group.yaml "repos".
+
+SERVICE: optional monorepo path prefix (case-sensitive path segments). When "repo" starts with "@", prefix-matches resolved symbol file paths; when a hit is outside the prefix, that member returns an empty payload for the symbol. Ignored for a normal indexed repo name.`,
         inputSchema: {
             type: 'object',
             properties: {
@@ -156,7 +177,12 @@ NOTE: ACCESSES edges (field read/write tracking) are included in context results
                 },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                    description: 'Indexed repository name or path, or group mode "@<groupName>" / "@<groupName>/<memberPath>". Omit if only one repo is indexed.',
+                },
+                service: {
+                    type: 'string',
+                    minLength: 1,
+                    description: 'Optional monorepo service root (relative path). Applies in group mode (@repo) only; ignored for a normal repo name. Empty string is rejected server-side.',
                 },
             },
             required: [],
@@ -251,7 +277,11 @@ TIP: Default traversal uses CALLS/IMPORTS/EXTENDS/IMPLEMENTS. For class members,
 Handles disambiguation: when multiple symbols share the target name, returns ranked candidates (each with a relevance score) instead of silently picking one. Use target_uid for zero-ambiguity lookup, or narrow with file_path and/or kind hints.
 
 EdgeType: CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, METHOD_OVERRIDES, METHOD_IMPLEMENTS, ACCESSES
-Confidence: 1.0 = certain, <0.8 = fuzzy match`,
+Confidence: 1.0 = certain, <0.8 = fuzzy match
+
+GROUP MODE: set "repo" to "@<groupName>" for cross-repo impact anchored at the default member (lexicographically first key in group.yaml "repos"), or "@<groupName>/<groupRepoPath>" to choose the member (same path keys as in group.yaml). Phase-1 walk runs in that member; cross-boundary fan-out uses the group bridge.
+
+SERVICE: optional monorepo path prefix (case-sensitive path segments). When "repo" starts with "@", scopes the local impact walk and cross-repo symbol paths to files under that prefix; ignored for a normal indexed repo name.`,
         inputSchema: {
             type: 'object',
             properties: {
@@ -274,8 +304,17 @@ Confidence: 1.0 = certain, <0.8 = fuzzy match`,
                 },
                 maxDepth: {
                     type: 'number',
-                    description: 'Max relationship depth (default: 3)',
+                    description: 'Max relationship depth (default: 3, server clamps to 1–32)',
                     default: 3,
+                    minimum: 1,
+                    maximum: 32,
+                },
+                crossDepth: {
+                    type: 'number',
+                    description: 'Cross-repository hop depth via contract bridge (default: 1; values above server maximum are clamped)',
+                    default: 1,
+                    minimum: 1,
+                    maximum: 32,
                 },
                 relationTypes: {
                     type: 'array',
@@ -283,10 +322,37 @@ Confidence: 1.0 = certain, <0.8 = fuzzy match`,
                     description: 'Filter: CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, METHOD_OVERRIDES, METHOD_IMPLEMENTS, ACCESSES (default: usage-based, ACCESSES excluded by default)',
                 },
                 includeTests: { type: 'boolean', description: 'Include test files (default: false)' },
-                minConfidence: { type: 'number', description: 'Minimum confidence 0-1 (default: 0.7)' },
+                minConfidence: {
+                    type: 'number',
+                    description: 'Minimum edge confidence 0–1 (default: 0 when omitted; server clamps to 0–1)',
+                    default: 0,
+                    minimum: 0,
+                    maximum: 1,
+                },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                    description: 'Indexed repository name or path, or group mode "@<groupName>" / "@<groupName>/<memberPath>". Omit if only one repo is indexed.',
+                },
+                service: {
+                    type: 'string',
+                    minLength: 1,
+                    description: 'Optional monorepo service root (relative path). Applies when "repo" is group mode (@…); ignored for a normal repo name. Empty string is rejected server-side.',
+                },
+                subgroup: {
+                    type: 'string',
+                    description: 'Optional group subgroup prefix (member repo paths) limiting which repos participate in cross fan-out.',
+                },
+                timeoutMs: {
+                    type: 'number',
+                    description: 'Wall-clock budget in milliseconds for the Phase-1 local impact leg (default 30000)',
+                    minimum: 1,
+                    maximum: 3600000,
+                },
+                timeout: {
+                    type: 'number',
+                    description: 'Alias of timeoutMs (milliseconds) when timeoutMs is omitted',
+                    minimum: 1,
+                    maximum: 3600000,
                 },
             },
             required: ['target', 'direction'],
@@ -404,49 +470,4 @@ WHEN TO USE: After changing group.yaml or re-indexing member repos.`,
             required: ['name'],
         },
     },
-    {
-        name: 'group_contracts',
-        description: `Inspect contracts and cross-links from the group's contracts.json.
-
-WHEN TO USE: Debug cross-repo links after group_sync.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Group name' },
-                type: { type: 'string', description: 'Filter by contract type (http, topic, …)' },
-                repo: { type: 'string', description: 'Filter by group repo path (e.g. app/backend)' },
-                unmatchedOnly: { type: 'boolean', description: 'Only contracts with no cross-link' },
-            },
-            required: ['name'],
-        },
-    },
-    {
-        name: 'group_query',
-        description: `Run the query tool across all repos in a group and merge process results via reciprocal rank fusion.
-
-WHEN TO USE: Semantic / hybrid search across a whole product group.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Group name' },
-                query: { type: 'string', description: 'Search query' },
-                subgroup: { type: 'string', description: 'Limit to repo paths under this prefix' },
-                limit: { type: 'number', description: 'Max merged results (default 5)' },
-            },
-            required: ['name', 'query'],
-        },
-    },
-    {
-        name: 'group_status',
-        description: `Report index staleness (commit vs HEAD) and Contract Registry staleness (indexedAt) for each repo in a group.
-
-WHEN TO USE: Before group_sync or when agents should refresh indexes.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Group name' },
-            },
-            required: ['name'],
-        },
-    },
 ];

package/dist/server/api.js

@@ -1002,7 +1002,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
     // POST /api/analyze — start a new analysis job
     app.post('/api/analyze', async (req, res) => {
         try {
-            const { url: repoUrl, path: repoLocalPath, force, embeddings } = req.body;
+            const { url: repoUrl, path: repoLocalPath, force, embeddings, dropEmbeddings } = req.body;
             // Input type validation
             if (repoUrl !== undefined && typeof repoUrl !== 'string') {
                 res.status(400).json({ error: '"url" must be a string' });
@@ -1176,7 +1176,11 @@ export const createServer = async (port, host = '127.0.0.1') => {
                         child.send({
                             type: 'start',
                             repoPath: targetPath,
-                            options: { force: !!force, embeddings: !!embeddings },
+                            options: {
+                                force: !!force,
+                                embeddings: !!embeddings,
+                                dropEmbeddings: !!dropEmbeddings,
+                            },
                         });
                     };
                     forkWorker();

package/dist/storage/git.d.ts

@@ -1,5 +1,29 @@
 export declare const isGitRepo: (repoPath: string) => boolean;
 export declare const getCurrentCommit: (repoPath: string) => string;
+/**
+ * Get a stable canonical identifier for the repo's `origin` remote, if any.
+ *
+ * Used to fingerprint two on-disk clones as the same logical repository
+ * (issue #XXX — silent graph drift across sibling clones). `path` alone
+ * is unreliable: worktrees, "clean clone for indexing" hygiene, and
+ * multi-agent workspaces routinely have the same repo at multiple
+ * absolute paths. The remote URL is the only on-disk signal that
+ * survives those conventions.
+ *
+ * Normalisation strategy:
+ *   - Strip a trailing `.git` so `https://x/y` and `https://x/y.git` collapse.
+ *   - Strip a trailing `/` for the same reason.
+ *   - `git@github.com:foo/bar` and `https://github.com/foo/bar` are
+ *     intentionally NOT collapsed — they are different remotes from
+ *     git's perspective and we don't want to assert equivalence.
+ *   - Lower-case the host portion so `GitHub.com` and `github.com`
+ *     don't desync; preserves case in path because some hosts
+ *     (Bitbucket Server) treat repo paths case-sensitively.
+ *
+ * Returns `undefined` when there is no origin remote, the directory
+ * isn't a git repo, or git itself isn't available.
+ */
+export declare const getRemoteUrl: (repoPath: string) => string | undefined;
 /**
  * Find the git repository root from any path inside the repo
  */
@@ -16,6 +40,31 @@ export declare const getGitRoot: (fromPath: string) => string | null;
  * @returns `true` when `.git` is present, `false` otherwise.
  */
 export declare const hasGitDir: (dirPath: string) => boolean;
+/**
+ * Read `remote.origin.url` from a git repository, or `null` if not a
+ * git repo, has no `origin` remote, or git is unavailable.
+ *
+ * Used by the registry-name inference path (#979) to recover a
+ * meaningful repo name when `path.basename(repoPath)` is generic
+ * (e.g. monorepo subprojects, git worktrees, Gas-Town-style
+ * `<rig>/refinery/rig/` layouts).
+ */
+export declare const getRemoteOriginUrl: (repoPath: string) => string | null;
+/**
+ * Parse a repository name out of a git remote URL. Handles the common
+ * SSH (`git@host:owner/repo.git`), HTTPS (`https://host/owner/repo.git`),
+ * `git://`, `ssh://`, and `file://` shapes. Returns `null` for empty /
+ * unparseable input.
+ *
+ * The heuristic: strip a trailing `.git` and trailing slashes, then
+ * take the segment after the last `/` or `:`.
+ */
+export declare const parseRepoNameFromUrl: (url: string | null | undefined) => string | null;
+/**
+ * Convenience wrapper: derive a registry-friendly name from the repo's
+ * `origin` remote, or `null` when it cannot be inferred.
+ */
+export declare const getInferredRepoName: (repoPath: string) => string | null;
 export interface DiffHunk {
     startLine: number;
     endLine: number;

package/dist/storage/git.js

@@ -19,6 +19,65 @@ export const getCurrentCommit = (repoPath) => {
         return '';
     }
 };
+/**
+ * Get a stable canonical identifier for the repo's `origin` remote, if any.
+ *
+ * Used to fingerprint two on-disk clones as the same logical repository
+ * (issue #XXX — silent graph drift across sibling clones). `path` alone
+ * is unreliable: worktrees, "clean clone for indexing" hygiene, and
+ * multi-agent workspaces routinely have the same repo at multiple
+ * absolute paths. The remote URL is the only on-disk signal that
+ * survives those conventions.
+ *
+ * Normalisation strategy:
+ *   - Strip a trailing `.git` so `https://x/y` and `https://x/y.git` collapse.
+ *   - Strip a trailing `/` for the same reason.
+ *   - `git@github.com:foo/bar` and `https://github.com/foo/bar` are
+ *     intentionally NOT collapsed — they are different remotes from
+ *     git's perspective and we don't want to assert equivalence.
+ *   - Lower-case the host portion so `GitHub.com` and `github.com`
+ *     don't desync; preserves case in path because some hosts
+ *     (Bitbucket Server) treat repo paths case-sensitively.
+ *
+ * Returns `undefined` when there is no origin remote, the directory
+ * isn't a git repo, or git itself isn't available.
+ */
+export const getRemoteUrl = (repoPath) => {
+    let raw;
+    try {
+        raw = execSync('git config --get remote.origin.url', {
+            cwd: repoPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        })
+            .toString()
+            .trim();
+    }
+    catch {
+        return undefined;
+    }
+    if (!raw)
+        return undefined;
+    let normalised = raw.replace(/\/$/, '').replace(/\.git$/, '');
+    // Lower-case the host segment of `scheme://[user@]host[:port]/...`
+    // and the host segment of `git@host:owner/repo` SCP form.
+    // SSH user-segment regex deliberately accepts the common
+    // `git@`/`<alnum>-_@` cases. Less common usernames (e.g. with
+    // dots) fall through to the URL-form branch — they will simply
+    // not get host-case normalisation, which is acceptable: the raw
+    // `git config` output is still a valid fingerprint, just slightly
+    // less collapsible across host casings.
+    const sshMatch = normalised.match(/^(git@|[a-zA-Z0-9_-]+@)([^:/]+)(:.+)$/);
+    if (sshMatch) {
+        normalised = `${sshMatch[1]}${sshMatch[2].toLowerCase()}${sshMatch[3]}`;
+    }
+    else {
+        const urlMatch = normalised.match(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)([^/]+)(\/.*)?$/);
+        if (urlMatch) {
+            normalised = `${urlMatch[1]}${urlMatch[2].toLowerCase()}${urlMatch[3] ?? ''}`;
+        }
+    }
+    return normalised;
+};
 /**
  * Find the git repository root from any path inside the repo
  */
@@ -52,6 +111,58 @@ export const hasGitDir = (dirPath) => {
         return false;
     }
 };
+/**
+ * Read `remote.origin.url` from a git repository, or `null` if not a
+ * git repo, has no `origin` remote, or git is unavailable.
+ *
+ * Used by the registry-name inference path (#979) to recover a
+ * meaningful repo name when `path.basename(repoPath)` is generic
+ * (e.g. monorepo subprojects, git worktrees, Gas-Town-style
+ * `<rig>/refinery/rig/` layouts).
+ */
+export const getRemoteOriginUrl = (repoPath) => {
+    try {
+        const url = execSync('git config --get remote.origin.url', {
+            cwd: repoPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        })
+            .toString()
+            .trim();
+        return url || null;
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Parse a repository name out of a git remote URL. Handles the common
+ * SSH (`git@host:owner/repo.git`), HTTPS (`https://host/owner/repo.git`),
+ * `git://`, `ssh://`, and `file://` shapes. Returns `null` for empty /
+ * unparseable input.
+ *
+ * The heuristic: strip a trailing `.git` and trailing slashes, then
+ * take the segment after the last `/` or `:`.
+ */
+export const parseRepoNameFromUrl = (url) => {
+    if (!url)
+        return null;
+    const trimmed = url.trim();
+    if (!trimmed)
+        return null;
+    // Strip `.git` suffix (case-insensitive) and any trailing slashes.
+    const withoutSuffix = trimmed.replace(/\.git\/*$/i, '').replace(/\/+$/, '');
+    // Last path segment, splitting on either `/` or `:` (covers SSH form).
+    const m = withoutSuffix.match(/[/:]([^/:]+)$/);
+    const candidate = m ? m[1] : withoutSuffix;
+    return candidate || null;
+};
+/**
+ * Convenience wrapper: derive a registry-friendly name from the repo's
+ * `origin` remote, or `null` when it cannot be inferred.
+ */
+export const getInferredRepoName = (repoPath) => {
+    return parseRepoNameFromUrl(getRemoteOriginUrl(repoPath));
+};
 /**
  * Parse unified diff output (with -U0) into per-file hunk ranges.
  * Extracts the new-file line ranges from @@ hunk headers.