@codragraph/cli 2.1.5 → 2.2.0-rc.6

package/dist/mcp/resources.js

@@ -96,6 +96,24 @@ export function getResourceTemplates() {
             description: "Phase 4: the indexed repo's current branch + head commit, plus the snapshot it points at. Pairs with graphstore_log/diff/blame.",
             mimeType: 'text/yaml',
         },
+        {
+            uriTemplate: 'codragraph://repo/{name}/graphpack/status',
+            name: 'Team Graphpack Status',
+            description: 'Team graphpack provenance: canonical main graph, PR overlay, local graph, chunk health, and compatibility.',
+            mimeType: 'text/yaml',
+        },
+        {
+            uriTemplate: 'codragraph://repo/{name}/graphpack/lock',
+            name: 'Team Graphpack Lock',
+            description: 'Committed .codragraph/index.lock.json content for shared team graph bootstrapping.',
+            mimeType: 'application/json',
+        },
+        {
+            uriTemplate: 'codragraph://repo/{name}/semantic-relationships',
+            name: 'Semantic Relationships',
+            description: 'Developer-intent relationship families with confidence, evidence, provenance, and extractor version.',
+            mimeType: 'text/yaml',
+        },
         {
             uriTemplate: 'codragraph://repo/{name}/recipes',
             name: 'Harness Recipes',
@@ -267,6 +285,12 @@ export async function readResource(uri, backend) {
             return getGraphstoreBranchesResource(backend, repoName);
         case 'graphstore/head':
             return getGraphstoreHeadResource(backend, repoName);
+        case 'graphpack/status':
+            return getGraphpackStatusResource(backend, repoName);
+        case 'graphpack/lock':
+            return getGraphpackLockResource(backend, repoName);
+        case 'semantic-relationships':
+            return getSemanticRelationshipsResource(backend, repoName);
         case 'recipes':
             return getRecipesResource(backend, repoName);
         default:
@@ -340,6 +364,8 @@ async function getContextResource(backend, repoName) {
     lines.push('  - impact: Blast radius analysis (what breaks if you change a symbol)');
     lines.push('  - detect_changes: Git-diff impact analysis (what do your changes affect)');
     lines.push('  - rename: Multi-file coordinated rename with confidence tags');
+    lines.push('  - graphpack_status: Team graph provenance and artifact health');
+    lines.push('  - semantic_relationships: Developer-intent semantic edge families');
     lines.push('  - cypher: Raw graph queries');
     lines.push('  - list_repos: Discover all indexed repositories');
     lines.push('');
@@ -350,6 +376,8 @@ async function getContextResource(backend, repoName) {
     lines.push(`  - codragraph://repo/${context.projectName}/clusters: All functional areas`);
     lines.push(`  - codragraph://repo/${context.projectName}/feature-clusters: Human-facing feature areas`);
     lines.push(`  - codragraph://repo/${context.projectName}/processes: All execution flows`);
+    lines.push(`  - codragraph://repo/${context.projectName}/graphpack/status: Team graphpack status`);
+    lines.push(`  - codragraph://repo/${context.projectName}/semantic-relationships: Developer-intent relationships`);
     lines.push(`  - codragraph://repo/${context.projectName}/cluster/{name}: Module details`);
     lines.push(`  - codragraph://repo/${context.projectName}/feature/{name}: Feature context pack`);
     lines.push(`  - codragraph://repo/${context.projectName}/process/{name}: Process trace`);
@@ -759,6 +787,100 @@ async function getGraphstoreBranchesResource(backend, repoName) {
     }
     return lines.join('\n');
 }
+async function getGraphpackStatusResource(backend, repoName) {
+    const repo = await backend.resolveRepo(repoName);
+    const { getGraphpackStatus } = await import('../core/graphpack/index.js');
+    try {
+        const status = await getGraphpackStatus({
+            repoPath: repo.repoPath,
+            storagePath: repo.storagePath,
+        });
+        const lines = [
+            `repo: "${repo.name}"`,
+            `source: "${status.source}"`,
+            `lockPresent: ${status.lockPresent}`,
+            `compatible: ${status.compatibility.ok}`,
+            `localGraphstore: ${status.local.graphstorePresent}`,
+            `verifiedChunks: ${status.chunks.verified}`,
+            `expectedChunks: ${status.chunks.expected}`,
+        ];
+        if (status.lock?.graphpack.id)
+            lines.push(`graphpack: "${status.lock.graphpack.id}"`);
+        if (status.lock?.graphpack.graphstoreSnapshot) {
+            lines.push(`snapshot: "${status.lock.graphpack.graphstoreSnapshot}"`);
+        }
+        if (status.local.headCommit)
+            lines.push(`localHead: "${status.local.headCommit}"`);
+        if (status.compatibility.reasons.length > 0) {
+            lines.push('reasons:');
+            for (const reason of status.compatibility.reasons)
+                lines.push(`  - ${JSON.stringify(reason)}`);
+        }
+        if (status.chunks.missing.length > 0) {
+            lines.push('missingChunks:');
+            for (const chunk of status.chunks.missing)
+                lines.push(`  - "${chunk}"`);
+        }
+        if (status.chunks.mismatched.length > 0) {
+            lines.push('mismatchedChunks:');
+            for (const chunk of status.chunks.mismatched)
+                lines.push(`  - "${chunk}"`);
+        }
+        return lines.join('\n');
+    }
+    catch (err) {
+        return `error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+async function getGraphpackLockResource(backend, repoName) {
+    const repo = await backend.resolveRepo(repoName);
+    const { defaultLockPath, readGraphpackLock } = await import('../core/graphpack/index.js');
+    const lock = await readGraphpackLock(defaultLockPath(repo.repoPath));
+    if (!lock) {
+        return JSON.stringify({ error: 'No .codragraph/index.lock.json found', repo: repo.name });
+    }
+    return JSON.stringify(lock, null, 2);
+}
+async function getSemanticRelationshipsResource(backend, repoName) {
+    const repo = await backend.resolveRepo(repoName);
+    const { analyzeSemanticRelationships } = await import('../core/semantic/relationships.js');
+    try {
+        const report = await analyzeSemanticRelationships({
+            storagePath: repo.storagePath,
+            limit: 200,
+            write: false,
+        });
+        const lines = [
+            `repo: "${repo.name}"`,
+            `snapshot: "${report.snapshotId ?? 'unknown'}"`,
+            `extractor: "${report.extractorVersion}"`,
+            `relationships: ${report.relationships.length}`,
+            'summary:',
+        ];
+        for (const [family, count] of Object.entries(report.summary)) {
+            lines.push(`  ${family}: ${count}`);
+        }
+        lines.push('edges:');
+        for (const rel of report.relationships.slice(0, 50)) {
+            lines.push(`  - family: "${rel.family}"`);
+            lines.push(`    source: ${JSON.stringify(rel.sourceName ?? rel.sourceId)}`);
+            lines.push(`    target: ${JSON.stringify(rel.targetName ?? rel.targetId)}`);
+            lines.push(`    confidence: ${rel.confidence}`);
+            lines.push(`    provenance: "${rel.provenance}"`);
+            lines.push(`    extractor: "${rel.extractorVersion}"`);
+            if (rel.evidence.filePath)
+                lines.push(`    file: "${rel.evidence.filePath}"`);
+            if (rel.evidence.startLine !== undefined)
+                lines.push(`    startLine: ${rel.evidence.startLine}`);
+            lines.push(`    reason: ${JSON.stringify(rel.evidence.reason)}`);
+            lines.push(`    rawEdgeType: "${rel.evidence.rawEdgeType}"`);
+        }
+        return lines.join('\n');
+    }
+    catch (err) {
+        return `error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
 async function getRecipesResource(backend, repoName, taskFamily) {
     const repo = await backend.resolveRepo(repoName);
     let result;
@@ -794,6 +916,9 @@ async function getRecipesResource(backend, repoName, taskFamily) {
         lines.push(`  - id: "${r.id}"`);
         lines.push(`    taskFamily: "${r.taskFamily}"`);
         lines.push(`    snapshotId: "${r.snapshotId}"`);
+        if (r.requiredSubgraphSignature) {
+            lines.push(`    requiredSubgraphSignature: "${r.requiredSubgraphSignature}"`);
+        }
         lines.push(`    accuracy: ${r.accuracy}`);
         lines.push(`    tokens: ${r.tokens}`);
         lines.push(`    latencyMs: ${r.latencyMs}`);

package/dist/mcp/tools.js

@@ -642,6 +642,99 @@ WHEN TO USE: After changing group.yaml or re-indexing member repos.`,
             required: ['name'],
         },
     },
+    {
+        name: 'graphpack_status',
+        description: `Show the team graphpack state for a repo.
+
+WHEN TO USE: before answering team-shared-context questions. Reports whether the answer should be considered canonical main graph, PR overlay, local graph, or missing/fallback.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
+                strict: {
+                    type: 'boolean',
+                    description: 'Recompute graphstore CAS digest instead of trusting local presence.',
+                    default: false,
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'graphpack_publish',
+        description: `Create a thin .codragraph/index.lock.json plus graphpack manifest for GitHub-native artifact publishing.
+
+WHEN TO USE: CI on main or PR branches after analyze. Commits the lock only; heavy graphstore chunks remain artifact storage.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
+                target: {
+                    type: 'string',
+                    enum: ['main', 'pr'],
+                    description: 'Graphpack target.',
+                    default: 'main',
+                },
+                artifact_dir: { type: 'string', description: 'Local artifact staging directory.' },
+                artifact_url: { type: 'string', description: 'Remote artifact URL to record in the lock.' },
+                base_snapshot_id: { type: 'string', description: 'PR overlay base snapshot id.' },
+                head_snapshot_id: { type: 'string', description: 'PR overlay head snapshot id.' },
+                pull_request: { type: 'string', description: 'Pull request number or URL.' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'graphpack_pull',
+        description: `Validate/pull a graphpack from a lock and report whether local materialization can proceed.
+
+WHEN TO USE: developer bootstrap after clone/checkout. If unavailable or incompatible, the result includes a safe local analyze fallback reason.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
+                artifact_dir: { type: 'string', description: 'Local graphpack artifact directory.' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'semantic_relationships',
+        description: `Return developer-intent semantic relationships above raw graph edges.
+
+Families include COMPOSES, ADAPTS, DELEGATES_TO, WRAPS, CONFIGURES, FACTORY_CREATES, ORCHESTRATES, PROXIES_TO, and MAPS_TO. Every edge includes evidence, confidence, extractor version, and provenance.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum relationships to return.',
+                    default: 1000,
+                    minimum: 1,
+                    maximum: 10000,
+                },
+                llm: {
+                    type: 'boolean',
+                    description: 'Allow optional LLM-inferred edges when provider support is configured.',
+                    default: false,
+                },
+            },
+            required: [],
+        },
+    },
     {
         name: 'harness_swarm_run',
         description: `Phase 3 swarm: Explorer + Exploiter (subprocess) + Critic (in-process), with hybrid termination.
@@ -727,6 +820,10 @@ Returns the Pareto frontier plus per-role attribution stats (which role contribu
                     type: 'string',
                     description: 'Phase 4 moat: codragraph-graphstore snapshot id (sha256:...). Required to enable recipe caching.',
                 },
+                required_subgraph_signature: {
+                    type: 'string',
+                    description: 'Phase 4 moat: stable signature of the task-required subgraph. Exact cache reuse keys on (snapshot_id, task_family, required_subgraph_signature).',
+                },
                 use_cache: {
                     type: 'boolean',
                     description: 'Phase 4 moat: when true and an exact (snapshot_id, task_family) recipe exists, return it instead of running the swarm.',
@@ -757,6 +854,10 @@ This is the Phase 4 × Phase 3 moat — versioned recipe memory. Recipes auto-in
             properties: {
                 task_family: { type: 'string', description: 'Filter by task family.' },
                 snapshot_id: { type: 'string', description: 'Filter by snapshot id (sha256:...).' },
+                required_subgraph_signature: {
+                    type: 'string',
+                    description: 'Filter by required subgraph signature.',
+                },
                 recipe_store: {
                     type: 'string',
                     description: 'Recipe store root. Defaults to <cwd>/.codragraph/recipes.',
@@ -780,6 +881,10 @@ WHEN TO USE: before kicking off a swarm. If exact matches exist, you can skip th
             properties: {
                 task_family: { type: 'string', description: 'Task family identifier.' },
                 snapshot_id: { type: 'string', description: 'Current codragraph-graphstore snapshot id.' },
+                required_subgraph_signature: {
+                    type: 'string',
+                    description: 'Stable signature of the subgraph this task needs. Exact reuse requires matching snapshot, family, and signature.',
+                },
                 recipe_store: {
                     type: 'string',
                     description: 'Recipe store root. Defaults to <cwd>/.codragraph/recipes.',

package/dist/server/api.js

@@ -758,6 +758,112 @@ export const createServer = async (port, host = '127.0.0.1', options = {}) => {
     // Lazy-imports the handler from codragraph-harness so the package
     // stays optional at runtime — same pattern as harness_run /
     // harness_swarm_run in local-backend.ts.
+    app.get('/api/graphpack/status', async (req, res) => {
+        try {
+            const entry = await resolveRepo(requestedRepo(req));
+            if (!entry) {
+                res.status(404).json({ error: 'Repository not found' });
+                return;
+            }
+            const { getGraphpackStatus } = await import('../core/graphpack/index.js');
+            const result = await getGraphpackStatus({
+                repoPath: entry.path,
+                storagePath: entry.storagePath,
+                strict: req.query.strict === 'true',
+            });
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message || 'graphpack status failed' });
+        }
+    });
+    app.get('/api/graphpack/lock', async (req, res) => {
+        try {
+            const entry = await resolveRepo(requestedRepo(req));
+            if (!entry) {
+                res.status(404).json({ error: 'Repository not found' });
+                return;
+            }
+            const { defaultLockPath, readGraphpackLock } = await import('../core/graphpack/index.js');
+            const lock = await readGraphpackLock(defaultLockPath(entry.path));
+            if (!lock) {
+                res.status(404).json({ error: 'No .codragraph/index.lock.json found' });
+                return;
+            }
+            res.json(lock);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message || 'graphpack lock failed' });
+        }
+    });
+    app.post('/api/graphpack/publish', async (req, res) => {
+        try {
+            const entry = await resolveRepo(requestedRepo(req));
+            if (!entry) {
+                res.status(404).json({ error: 'Repository not found' });
+                return;
+            }
+            const { publishGraphpack } = await import('../core/graphpack/index.js');
+            const body = (req.body ?? {});
+            const result = await publishGraphpack({
+                repoPath: entry.path,
+                storagePath: entry.storagePath,
+                repoName: typeof body.repo === 'string' ? body.repo : entry.name,
+                analyzerVersion: typeof body.analyzerVersion === 'string' ? body.analyzerVersion : 'http',
+                target: body.target === 'pr' ? 'pr' : 'main',
+                artifactDir: typeof body.artifactDir === 'string' ? body.artifactDir : undefined,
+                artifactUrl: typeof body.artifactUrl === 'string' ? body.artifactUrl : undefined,
+                baseSnapshotId: typeof body.baseSnapshotId === 'string' ? body.baseSnapshotId : undefined,
+                headSnapshotId: typeof body.headSnapshotId === 'string' ? body.headSnapshotId : undefined,
+                pullRequest: typeof body.pullRequest === 'string' ? body.pullRequest : undefined,
+            });
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message || 'graphpack publish failed' });
+        }
+    });
+    app.post('/api/graphpack/pull', async (req, res) => {
+        try {
+            const entry = await resolveRepo(requestedRepo(req));
+            if (!entry) {
+                res.status(404).json({ error: 'Repository not found' });
+                return;
+            }
+            const { pullGraphpack } = await import('../core/graphpack/index.js');
+            const body = (req.body ?? {});
+            const result = await pullGraphpack({
+                repoPath: entry.path,
+                storagePath: entry.storagePath,
+                artifactDir: typeof body.artifactDir === 'string' ? body.artifactDir : undefined,
+            });
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message || 'graphpack pull failed' });
+        }
+    });
+    app.get('/api/semantic/relationships', async (req, res) => {
+        try {
+            const entry = await resolveRepo(requestedRepo(req));
+            if (!entry) {
+                res.status(404).json({ error: 'Repository not found' });
+                return;
+            }
+            const { analyzeSemanticRelationships } = await import('../core/semantic/relationships.js');
+            const limit = typeof req.query.limit === 'string' ? Number.parseInt(req.query.limit, 10) : undefined;
+            const result = await analyzeSemanticRelationships({
+                storagePath: entry.storagePath,
+                limit: Number.isFinite(limit) ? limit : 1000,
+                llm: req.query.llm === 'true',
+                write: false,
+            });
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message || 'semantic relationships failed' });
+        }
+    });
     const importRecipeHandler = async (handlerName) => {
         const moduleId = '@codragraph/harness/mcp/handler';
         try {
@@ -785,6 +891,9 @@ export const createServer = async (port, host = '127.0.0.1', options = {}) => {
                 recipe_store: path.join(entry.storagePath, 'recipes'),
                 task_family: typeof req.query.task_family === 'string' ? req.query.task_family : undefined,
                 snapshot_id: typeof req.query.snapshot_id === 'string' ? req.query.snapshot_id : undefined,
+                required_subgraph_signature: typeof req.query.required_subgraph_signature === 'string'
+                    ? req.query.required_subgraph_signature
+                    : undefined,
                 limit: Number.isFinite(limitParam) ? limitParam : undefined,
             });
             res.json(result);
@@ -813,6 +922,9 @@ export const createServer = async (port, host = '127.0.0.1', options = {}) => {
                 recipe_store: path.join(entry.storagePath, 'recipes'),
                 task_family: taskFamily,
                 snapshot_id: snapshotId,
+                required_subgraph_signature: typeof req.query.required_subgraph_signature === 'string'
+                    ? req.query.required_subgraph_signature
+                    : undefined,
                 limit: typeof req.query.limit === 'string' ? Number.parseInt(req.query.limit, 10) : undefined,
             });
             res.json(result);

package/dist/storage/repo-manager.d.ts

@@ -83,6 +83,35 @@ export interface RepoMeta {
      * — they decode at the read boundary.
      */
     compress?: 'none' | 'brotli' | 'zstd';
+    /**
+     * Query-time index capabilities written by analyze after optional search
+     * indexes are successfully created. Read-only MCP/CLI query paths use this
+     * to avoid expensive probes for indexes that older analyses never wrote.
+     */
+    searchIndexes?: {
+        fts?: boolean;
+    };
+    /**
+     * Runtime policy chosen by `analyze --profile auto|lean|balanced|power`.
+     * This is diagnostic metadata only; readers must not require it because
+     * older indexes do not have a policy record.
+     */
+    adaptiveProfile?: {
+        requested?: 'auto' | 'lean' | 'balanced' | 'power';
+        resolved?: 'lean' | 'balanced' | 'power';
+        platform?: NodeJS.Platform;
+        arch?: NodeJS.Architecture;
+        cpuCount?: number;
+        totalMemoryBytes?: number;
+        heapLimitBytes?: number;
+        compression?: 'none' | 'brotli' | 'zstd';
+        embeddingMode?: 'auto' | 'off' | 'on';
+        embeddingNodeLimit?: number;
+        embeddingDecision?: 'enabled' | 'skipped';
+        embeddingReason?: string;
+        workerPoolSize?: number;
+        workerSubBatchSize?: number;
+    };
     /**
      * Canonical `origin` remote URL captured at index time. Used to
      * fingerprint the same logical repo across multiple on-disk clones