@codragraph/cli 2.1.6 → 2.2.0-rc.6

package/README.md

@@ -65,16 +65,16 @@ If you prefer to configure manually instead of using `codragraph setup`:
 
 ```bash
 # macOS / Linux
-claude mcp add codragraph -- npx -y @codragraph/cli@2.1.6 mcp
+claude mcp add codragraph -- npx -y @codragraph/cli@2.2.0-rc.6 mcp
 
 # Windows
-claude mcp add codragraph -- cmd /c npx -y @codragraph/cli@2.1.6 mcp
+claude mcp add codragraph -- cmd /c npx -y @codragraph/cli@2.2.0-rc.6 mcp
 ```
 
 ### Codex (full support — MCP + skills)
 
 ```bash
-codex mcp add codragraph -- npx -y @codragraph/cli@2.1.6 mcp
+codex mcp add codragraph -- npx -y @codragraph/cli@2.2.0-rc.6 mcp
 ```
 
 ### Cursor / Windsurf
@@ -86,7 +86,7 @@ Add to `~/.cursor/mcp.json` (global — works for all projects):
   "mcpServers": {
     "codragraph": {
       "command": "npx",
-      "args": ["-y", "@codragraph/cli@2.1.6", "mcp"]
+      "args": ["-y", "@codragraph/cli@2.2.0-rc.6", "mcp"]
     }
   }
 }
@@ -101,7 +101,7 @@ Add to `~/.config/opencode/config.json`:
   "mcp": {
     "codragraph": {
       "command": "npx",
-      "args": ["-y", "@codragraph/cli@2.1.6", "mcp"]
+      "args": ["-y", "@codragraph/cli@2.2.0-rc.6", "mcp"]
     }
   }
 }
@@ -309,9 +309,9 @@ It is fixed in **codragraph v1.6.2+**. Upgrade to the current workspace
 version, or pin the version your team has validated:
 
 ```bash
-npx @codragraph/cli@2.1.6 analyze          # no global install
+npx @codragraph/cli@2.2.0-rc.6 analyze     # no global install
 # or
-npm install -g @codragraph/cli@2.1.6       # upgrade a global install
+npm install -g @codragraph/cli@2.2.0-rc.6  # upgrade a global install
 ```
 
 If you still hit npm install issues after upgrading, these generic workarounds

package/dist/cli/graphpack.d.ts

@@ -0,0 +1,48 @@
+import { type GraphpackTarget } from '../core/graphpack/index.js';
+export declare const bootstrapCommand: (opts?: {
+    lock?: string;
+    artifactDir?: string;
+    materialize?: boolean;
+    json?: boolean;
+}) => Promise<void>;
+export declare const graphpackPublishCommand: (opts?: {
+    target?: GraphpackTarget;
+    repo?: string;
+    artifactDir?: string;
+    artifactUrl?: string;
+    baseSnapshot?: string;
+    headSnapshot?: string;
+    pr?: string;
+    json?: boolean;
+}) => Promise<void>;
+export declare const graphpackPullCommand: (opts?: {
+    lock?: string;
+    artifactDir?: string;
+    materialize?: boolean;
+    json?: boolean;
+}) => Promise<void>;
+export declare const graphpackStatusCommand: (opts?: {
+    lock?: string;
+    strict?: boolean;
+    json?: boolean;
+}) => Promise<void>;
+export declare const semanticAnalyzeCommand: (opts?: {
+    llm?: boolean;
+    limit?: string;
+    write?: boolean;
+    json?: boolean;
+}) => Promise<void>;
+export declare const recipesLookupCommand: (opts?: {
+    taskFamily?: string;
+    snapshotId?: string;
+    recipeStore?: string;
+    requiredSubgraphSignature?: string;
+    limit?: string;
+    json?: boolean;
+}) => Promise<void>;
+export declare const teamServeCommand: (opts?: {
+    graphpack?: string;
+    port?: string;
+    host?: string;
+    web?: string;
+}) => Promise<void>;

package/dist/cli/graphpack.js

@@ -0,0 +1,217 @@
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { bootstrapGraphpack, getGraphpackStatus, publishGraphpack, pullGraphpack, } from '../core/graphpack/index.js';
+import { analyzeSemanticRelationships } from '../core/semantic/relationships.js';
+import { findRepo, getStoragePaths, registerRepo } from '../storage/repo-manager.js';
+import { getGitRoot, getInferredRepoName } from '../storage/git.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
+const resolveRepoForGraphpack = async () => {
+    const indexed = await findRepo(process.cwd());
+    if (indexed) {
+        return {
+            repoPath: indexed.repoPath,
+            storagePath: indexed.storagePath,
+            repoName: getInferredRepoName(indexed.repoPath) ?? path.basename(indexed.repoPath),
+        };
+    }
+    const gitRoot = getGitRoot(process.cwd());
+    if (!gitRoot) {
+        throw new Error('Not inside a git repository and no CodraGraph index was found.');
+    }
+    const paths = getStoragePaths(gitRoot);
+    return {
+        repoPath: gitRoot,
+        storagePath: paths.storagePath,
+        repoName: getInferredRepoName(gitRoot) ?? path.basename(gitRoot),
+    };
+};
+export const bootstrapCommand = async (opts = {}) => {
+    const repo = await resolveRepoForGraphpack();
+    const result = await bootstrapGraphpack({
+        repoPath: repo.repoPath,
+        storagePath: repo.storagePath,
+        lockPath: opts.lock ? path.resolve(opts.lock) : undefined,
+        artifactDir: opts.artifactDir ? path.resolve(opts.artifactDir) : undefined,
+    });
+    await maybeRegisterRepo(repo);
+    if (opts.materialize !== false && result.materializable) {
+        await materializeGraphpackHead(result.status.lock?.graphpack.graphstoreHeadCommit);
+    }
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
+    printPullLikeResult('bootstrap', result);
+};
+export const graphpackPublishCommand = async (opts = {}) => {
+    const repo = await resolveRepoForGraphpack();
+    const result = await publishGraphpack({
+        repoPath: repo.repoPath,
+        storagePath: repo.storagePath,
+        repoName: opts.repo ?? repo.repoName,
+        analyzerVersion: pkg.version,
+        target: opts.target ?? 'main',
+        artifactDir: opts.artifactDir ? path.resolve(opts.artifactDir) : undefined,
+        artifactUrl: opts.artifactUrl,
+        baseSnapshotId: opts.baseSnapshot,
+        headSnapshotId: opts.headSnapshot,
+        pullRequest: opts.pr,
+    });
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write([
+        `graphpack: ${result.lock.graphpack.id}`,
+        `target: ${result.lock.graphpack.target}`,
+        `lock: ${result.lockPath}`,
+        `manifest: ${result.manifestPath}`,
+        `snapshot: ${result.lock.graphpack.graphstoreSnapshot ?? '(unknown)'}`,
+        `chunks: ${result.lock.chunks.length}`,
+    ].join('\n') + '\n');
+};
+export const graphpackPullCommand = async (opts = {}) => {
+    const repo = await resolveRepoForGraphpack();
+    const result = await pullGraphpack({
+        repoPath: repo.repoPath,
+        storagePath: repo.storagePath,
+        lockPath: opts.lock ? path.resolve(opts.lock) : undefined,
+        artifactDir: opts.artifactDir ? path.resolve(opts.artifactDir) : undefined,
+    });
+    await maybeRegisterRepo(repo);
+    if (opts.materialize !== false && result.materializable) {
+        await materializeGraphpackHead(result.status.lock?.graphpack.graphstoreHeadCommit);
+    }
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
+    printPullLikeResult('pull', result);
+};
+export const graphpackStatusCommand = async (opts = {}) => {
+    const repo = await resolveRepoForGraphpack();
+    const status = await getGraphpackStatus({
+        repoPath: repo.repoPath,
+        storagePath: repo.storagePath,
+        lockPath: opts.lock ? path.resolve(opts.lock) : undefined,
+        strict: opts.strict,
+    });
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
+        return;
+    }
+    const lines = [
+        `source: ${status.source}`,
+        `lock: ${status.lockPresent ? status.lockPath : 'missing'}`,
+        `local_graphstore: ${status.local.graphstorePresent ? 'present' : 'missing'}`,
+        status.local.headCommit ? `local_head: ${status.local.headCommit}` : undefined,
+        status.lock?.graphpack.graphstoreSnapshot
+            ? `lock_snapshot: ${status.lock.graphpack.graphstoreSnapshot}`
+            : undefined,
+        `chunks: ${status.chunks.verified}/${status.chunks.expected} verified`,
+        `compatible: ${status.compatibility.ok ? 'yes' : 'no'}`,
+    ].filter(Boolean);
+    if (status.compatibility.reasons.length > 0) {
+        lines.push('reasons:');
+        for (const reason of status.compatibility.reasons)
+            lines.push(`  - ${reason}`);
+    }
+    if (status.chunks.missing.length > 0) {
+        lines.push('missing:');
+        for (const chunk of status.chunks.missing)
+            lines.push(`  - ${chunk}`);
+    }
+    process.stdout.write(`${lines.join('\n')}\n`);
+};
+export const semanticAnalyzeCommand = async (opts = {}) => {
+    const repo = await resolveRepoForGraphpack();
+    const report = await analyzeSemanticRelationships({
+        storagePath: repo.storagePath,
+        llm: opts.llm,
+        write: opts.write !== false,
+        limit: opts.limit ? Number.parseInt(opts.limit, 10) : undefined,
+    });
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+        return;
+    }
+    const lines = [
+        `snapshot: ${report.snapshotId ?? '(unknown)'}`,
+        `extractor: ${report.extractorVersion}`,
+        `llm: ${report.llmEnabled ? 'enabled' : 'disabled'}`,
+        `relationships: ${report.relationships.length}`,
+    ];
+    for (const [family, count] of Object.entries(report.summary)) {
+        if (count > 0)
+            lines.push(`  ${family}: ${count}`);
+    }
+    process.stdout.write(`${lines.join('\n')}\n`);
+};
+export const recipesLookupCommand = async (opts = {}) => {
+    if (!opts.taskFamily)
+        throw new Error('recipes lookup requires --task-family <name>');
+    const repo = await resolveRepoForGraphpack();
+    const snapshotId = opts.snapshotId ??
+        (await getGraphpackStatus({ repoPath: repo.repoPath, storagePath: repo.storagePath })).lock
+            ?.graphpack.graphstoreSnapshot;
+    if (!snapshotId) {
+        throw new Error('recipes lookup requires --snapshot-id when no graphpack lock is available.');
+    }
+    const moduleId = '@codragraph/harness/mcp/handler';
+    const mod = (await import(/* @vite-ignore */ moduleId));
+    if (!mod.handleHarnessRecipesLookup) {
+        throw new Error('@codragraph/harness/mcp/handler does not export handleHarnessRecipesLookup');
+    }
+    const result = await mod.handleHarnessRecipesLookup({
+        task_family: opts.taskFamily,
+        snapshot_id: snapshotId,
+        recipe_store: opts.recipeStore ?? path.join(repo.storagePath, 'recipes'),
+        required_subgraph_signature: opts.requiredSubgraphSignature,
+        limit: opts.limit ? Number.parseInt(opts.limit, 10) : undefined,
+    });
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+};
+export const teamServeCommand = async (opts = {}) => {
+    const repo = await resolveRepoForGraphpack();
+    const status = await getGraphpackStatus({
+        repoPath: repo.repoPath,
+        storagePath: repo.storagePath,
+    });
+    if (opts.graphpack && status.lock?.graphpack.id !== opts.graphpack) {
+        throw new Error(`Requested graphpack ${opts.graphpack}, but lock points at ${status.lock?.graphpack.id ?? '(none)'}. Run graphpack pull or pass the matching id.`);
+    }
+    process.env.CODRAGRAPH_TEAM_GRAPH_MODE = '1';
+    process.env.CODRAGRAPH_ACTIVE_GRAPHPACK = opts.graphpack ?? status.lock?.graphpack.id ?? '';
+    const { serveCommand } = await import('./serve.js');
+    await serveCommand({ port: opts.port, host: opts.host, web: opts.web ?? 'hosted' });
+};
+const maybeRegisterRepo = async (repo) => {
+    const indexed = await findRepo(repo.repoPath);
+    if (!indexed?.meta)
+        return;
+    await registerRepo(repo.repoPath, indexed.meta);
+};
+const materializeGraphpackHead = async (headCommit) => {
+    if (!headCommit)
+        return;
+    const { checkoutCommand } = await import('./graphstore.js');
+    await checkoutCommand(headCommit, { materialize: true });
+};
+const printPullLikeResult = (label, result) => {
+    if (result.fallbackRequired) {
+        process.stdout.write([
+            `${label}: fallback required`,
+            `reason: ${result.reason ?? 'graphpack is not available locally'}`,
+            `fallback: ${result.fallbackCommand ?? 'codragraph analyze --skip-agents-md --no-setup'}`,
+        ].join('\n') + '\n');
+        process.exitCode = 1;
+        return;
+    }
+    process.stdout.write([
+        `${label}: ok`,
+        `source: ${result.status.source}`,
+        `graphpack: ${result.status.lock?.graphpack.id ?? '(none)'}`,
+        `materializable: ${result.materializable ? 'yes' : 'no'}`,
+    ].join('\n') + '\n');
+};

package/dist/cli/index.js

@@ -94,6 +94,14 @@ program
     .command('status')
     .description('Show index status for current repo')
     .action(createLazyAction(() => import('./status.js'), 'statusCommand'));
+program
+    .command('bootstrap')
+    .description('Bootstrap a local graph from .codragraph/index.lock.json when available')
+    .option('--lock <path>', 'Path to graphpack lock file')
+    .option('--artifact-dir <path>', 'Local graphpack artifact directory to pull from')
+    .option('--no-materialize', 'Validate/pull graphpack chunks without rebuilding the local cgdb')
+    .option('--json', 'Emit machine-readable JSON')
+    .action(createLazyAction(() => import('./graphpack.js'), 'bootstrapCommand'));
 program
     .command('clean')
     .description('Delete CodraGraph index for current repo')
@@ -191,6 +199,7 @@ program
     .description('Generate the compact agent context pack for a feature cluster')
     .option('-r, --repo <name>', 'Target repository')
     .option('-l, --limit <n>', 'Max members to return (default: 100)')
+    .option('--compress <level>', 'Compression level: balanced, lean, or max')
     .action(createOneShotLazyAction(() => import('./tool.js'), 'contextPackCommand'));
 program
     .command('cluster-impact <name>')
@@ -215,6 +224,69 @@ program
     .option('--idle-timeout <seconds>', 'Auto-shutdown after N seconds idle (0 = disabled)', '0')
     .action(createLazyAction(() => import('./eval-server.js'), 'evalServerCommand'));
 registerGroupCommands(program);
+const graphpackCmd = program
+    .command('graphpack')
+    .description('Publish, pull, and inspect team graphpack artifacts');
+graphpackCmd
+    .command('publish')
+    .description('Publish a graphpack lock/manifest for main or PR artifact workflows')
+    .option('--target <target>', 'Graphpack target: main or pr', 'main')
+    .option('--repo <name>', 'Repository identity stored in the lock')
+    .option('--artifact-dir <path>', 'Local artifact staging directory')
+    .option('--artifact-url <url>', 'Remote artifact URL recorded in the lock')
+    .option('--base-snapshot <id>', 'PR overlay base snapshot id')
+    .option('--head-snapshot <id>', 'PR overlay head snapshot id')
+    .option('--pr <ref>', 'Pull request number or URL for overlay graphpacks')
+    .option('--json', 'Emit machine-readable JSON')
+    .action(createLazyAction(() => import('./graphpack.js'), 'graphpackPublishCommand'));
+graphpackCmd
+    .command('pull')
+    .description('Pull graphpack chunks and prepare local materialization')
+    .option('--lock <path>', 'Path to graphpack lock file')
+    .option('--artifact-dir <path>', 'Local graphpack artifact directory to pull from')
+    .option('--no-materialize', 'Pull/validate without rebuilding the local cgdb')
+    .option('--json', 'Emit machine-readable JSON')
+    .action(createLazyAction(() => import('./graphpack.js'), 'graphpackPullCommand'));
+graphpackCmd
+    .command('status', { isDefault: true })
+    .description('Show graphpack lock, chunk, and local materialization status')
+    .option('--lock <path>', 'Path to graphpack lock file')
+    .option('--strict', 'Recompute graphstore CAS digest instead of trusting local presence')
+    .option('--json', 'Emit machine-readable JSON')
+    .action(createLazyAction(() => import('./graphpack.js'), 'graphpackStatusCommand'));
+const semanticCmd = program
+    .command('semantic')
+    .description('Analyze developer-intent semantic relationships above raw graph edges');
+semanticCmd
+    .command('analyze', { isDefault: true })
+    .description('Extract semantic relationship families with confidence and evidence')
+    .option('--llm', 'Allow optional LLM-inferred semantic edges when provider support is configured')
+    .option('--limit <n>', 'Maximum semantic relationships to return', '1000')
+    .option('--no-write', 'Do not write .codragraph/semantic-relationships.json')
+    .option('--json', 'Emit machine-readable JSON')
+    .action(createLazyAction(() => import('./graphpack.js'), 'semanticAnalyzeCommand'));
+const recipesCmd = program
+    .command('recipes')
+    .description('Lookup graph-snapshot keyed harness recipes');
+recipesCmd
+    .command('lookup')
+    .description('Find reusable harness recipes for a task family and graph snapshot')
+    .requiredOption('--task-family <name>', 'Task family identifier')
+    .option('--snapshot-id <id>', 'Graph snapshot id. Defaults to graphpack lock snapshot.')
+    .option('--required-subgraph-signature <sig>', 'Subgraph signature needed by the task')
+    .option('--recipe-store <path>', 'Recipe store root')
+    .option('--limit <n>', 'Max entries per match kind', '10')
+    .option('--json', 'Emit machine-readable JSON')
+    .action(createLazyAction(() => import('./graphpack.js'), 'recipesLookupCommand'));
+const teamCmd = program.command('team').description('Team graph server commands');
+teamCmd
+    .command('serve')
+    .description('Start hosted/team MCP-compatible HTTP mode for a graphpack')
+    .option('--graphpack <id>', 'Graphpack id to serve')
+    .option('-p, --port <port>', 'Port number', '4747')
+    .option('--host <host>', 'Bind address')
+    .option('--web <mode>', 'Dashboard mode: hosted, local, or off', 'hosted')
+    .action(createLazyAction(() => import('./graphpack.js'), 'teamServeCommand'));
 // ─── Config: unified API-key model (~/.codragraph/config.json) ─────
 const configCmd = program
     .command('config')

package/dist/cli/tool.d.ts

@@ -63,6 +63,7 @@ export declare function clusterContextCommand(name: string, options?: {
 export declare function contextPackCommand(name: string, options?: {
     repo?: string;
     limit?: string;
+    compress?: string;
 }): Promise<void>;
 export declare function clusterImpactCommand(name: string, options?: {
     direction?: string;

package/dist/cli/tool.js

@@ -14,6 +14,7 @@
  * native module which captures the Node.js process.stdout stream during init.
  * See the output() function for details (#324).
  */
+import crypto from 'node:crypto';
 import { writeSync } from 'node:fs';
 import { LocalBackend } from '../mcp/local/local-backend.js';
 import { emitTokenStats } from './compress-stats.js';
@@ -238,8 +239,116 @@ export async function contextPackCommand(name, options) {
         repo,
         limit: options?.limit ? parseInt(options.limit, 10) : undefined,
     });
-    output(result);
-    emitTokenStats(result);
+    const maybeCompressed = options?.compress
+        ? compressContextPackForCli(result, name, options.compress)
+        : result;
+    output(maybeCompressed);
+    emitTokenStats(maybeCompressed);
+}
+function compressContextPackForCli(result, featureName, rawLevel) {
+    const level = normalizeCliCompressionLevel(rawLevel);
+    const originalText = JSON.stringify(result);
+    const compressed = pruneContextPack(result, level);
+    const compressedText = JSON.stringify(compressed);
+    const originalTokens = estimateJsonTokens(originalText);
+    const compressedTokens = estimateJsonTokens(compressedText);
+    const snapshotId = result?.snapshotId ??
+        result?.snapshot_id ??
+        result?.cluster?.lastIndexedCommit ??
+        result?.cluster?.snapshotId ??
+        'unknown';
+    const clusterId = result?.cluster?.id ?? result?.cluster?.slug ?? featureName;
+    const cacheKey = crypto
+        .createHash('sha256')
+        .update(`${snapshotId}\n${clusterId}\n${level}\ncli-context-pack-compressor-v1`)
+        .digest('hex');
+    return {
+        ...compressed,
+        compression: {
+            level,
+            compressorVersion: 'cli-context-pack-compressor-v1',
+            cacheKey: `ctxpack:${cacheKey.slice(0, 32)}`,
+            originalTokens,
+            compressedTokens,
+            tokenSavingsPct: originalTokens > 0
+                ? Number((((originalTokens - compressedTokens) / originalTokens) * 100).toFixed(1))
+                : 0,
+            preserved: [
+                'feature cluster',
+                'files',
+                'line ranges',
+                'symbols',
+                'tests',
+                'routes',
+                'tools',
+                'dependencies',
+                'warnings',
+            ],
+        },
+    };
+}
+function normalizeCliCompressionLevel(raw) {
+    if (raw === 'balanced' || raw === 'lean' || raw === 'max')
+        return raw;
+    throw new Error('context-pack --compress must be one of: balanced, lean, max');
+}
+function pruneContextPack(value, level) {
+    if (!value || typeof value !== 'object')
+        return value;
+    const memberLimit = level === 'max' ? 20 : level === 'lean' ? 40 : 80;
+    const processLimit = level === 'max' ? 5 : level === 'lean' ? 8 : 15;
+    const supportLimit = level === 'max' ? 5 : level === 'lean' ? 10 : 20;
+    return {
+        cluster: value.cluster,
+        members: Array.isArray(value.members)
+            ? value.members.slice(0, memberLimit).map(compactContextPackItem)
+            : value.members,
+        entryPoints: Array.isArray(value.entryPoints)
+            ? value.entryPoints.slice(0, supportLimit).map(compactContextPackItem)
+            : value.entryPoints,
+        routes: value.routes,
+        tools: value.tools,
+        dependencies: value.dependencies,
+        processes: Array.isArray(value.processes)
+            ? value.processes.slice(0, processLimit).map(compactContextPackItem)
+            : value.processes,
+        tests: Array.isArray(value.tests)
+            ? value.tests.slice(0, supportLimit).map(compactContextPackItem)
+            : value.tests,
+        docs: Array.isArray(value.docs)
+            ? value.docs.slice(0, supportLimit).map(compactContextPackItem)
+            : value.docs,
+        warnings: value.warnings ?? value.safeEditSurface?.warnings,
+        safeEditSurface: value.safeEditSurface,
+    };
+}
+function compactContextPackItem(item) {
+    if (!item || typeof item !== 'object')
+        return item;
+    const keys = [
+        'id',
+        'uid',
+        'name',
+        'type',
+        'kind',
+        'filePath',
+        'file',
+        'startLine',
+        'endLine',
+        'route',
+        'method',
+        'summary',
+        'confidence',
+    ];
+    const compact = {};
+    for (const key of keys) {
+        if (item[key] !== undefined)
+            compact[key] = item[key];
+    }
+    return compact;
+}
+function estimateJsonTokens(text) {
+    return Math.ceil(text.length / 4);
 }
 export async function clusterImpactCommand(name, options) {
     if (!name?.trim()) {

package/dist/core/graphpack/index.d.ts

@@ -0,0 +1,14 @@
+import { type GraphpackBootstrapResult, type GraphpackPublishOptions, type GraphpackPublishResult, type GraphpackPullOptions, type GraphpackPullResult, type GraphpackStatus, type GraphpackLock } from './types.js';
+export * from './types.js';
+export declare const defaultLockPath: (repoPath: string) => string;
+export declare const readGraphpackLock: (lockPath: string) => Promise<GraphpackLock | null>;
+export declare const writeGraphpackLock: (lockPath: string, lock: GraphpackLock) => Promise<void>;
+export declare const publishGraphpack: (opts: GraphpackPublishOptions) => Promise<GraphpackPublishResult>;
+export declare const getGraphpackStatus: (opts: {
+    repoPath: string;
+    storagePath: string;
+    lockPath?: string;
+    strict?: boolean;
+}) => Promise<GraphpackStatus>;
+export declare const pullGraphpack: (opts: GraphpackPullOptions) => Promise<GraphpackPullResult>;
+export declare const bootstrapGraphpack: (opts: GraphpackPullOptions) => Promise<GraphpackBootstrapResult>;