opentology 0.1.0

package/dist/commands/context.js

@@ -0,0 +1,369 @@
+import pc from 'picocolors';
+import { existsSync, mkdirSync, writeFileSync, unlinkSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadConfig, saveConfig } from '../lib/config.js';
+import { createReadyAdapter } from '../lib/store-factory.js';
+import { OTX_BOOTSTRAP_TURTLE } from '../templates/otx-ontology.js';
+import { generateContextSection, updateClaudeMd } from '../templates/claude-md-context.js';
+import { generateHookScript } from '../templates/session-start-hook.js';
+import { generateSlashCommands } from '../templates/slash-commands.js';
+export function registerContext(program) {
+    const context = program
+        .command('context')
+        .description('Manage project context graph for Claude Code integration');
+    // --- context init ---
+    context
+        .command('init')
+        .description('Initialize project context graph and Claude Code hook')
+        .option('--force', 'Regenerate hook script and CLAUDE.md even if they exist')
+        .action(async (opts) => {
+        let config;
+        try {
+            config = loadConfig();
+        }
+        catch {
+            console.error(pc.red('Error: No .opentology.json found. Run `opentology init` first.'));
+            process.exit(1);
+        }
+        const graphs = config.graphs ?? {};
+        const contextUri = `${config.graphUri}/context`;
+        const sessionsUri = `${config.graphUri}/sessions`;
+        let createdHook = false;
+        let createdClaudeMd = false;
+        try {
+            // Step 1: Create graphs in config
+            let graphsChanged = false;
+            if (!graphs['context']) {
+                graphs['context'] = contextUri;
+                graphsChanged = true;
+                console.log(pc.green(`  Created graph 'context' -> ${contextUri}`));
+            }
+            else {
+                console.log(pc.dim(`  Graph 'context' already exists — skipped`));
+            }
+            if (!graphs['sessions']) {
+                graphs['sessions'] = sessionsUri;
+                graphsChanged = true;
+                console.log(pc.green(`  Created graph 'sessions' -> ${sessionsUri}`));
+            }
+            else {
+                console.log(pc.dim(`  Graph 'sessions' already exists — skipped`));
+            }
+            if (graphsChanged) {
+                config.graphs = graphs;
+            }
+            // Step 2: Bootstrap ontology — persist as tracked file for embedded mode
+            const ontologyDir = join(process.cwd(), '.opentology');
+            const ontologyPath = join(ontologyDir, 'ontology.ttl');
+            if (!existsSync(ontologyPath) || opts.force) {
+                mkdirSync(ontologyDir, { recursive: true });
+                writeFileSync(ontologyPath, OTX_BOOTSTRAP_TURTLE, 'utf-8');
+                // Track ontology file so embedded adapter loads it automatically
+                if (!config.files)
+                    config.files = {};
+                if (!config.files[contextUri])
+                    config.files[contextUri] = [];
+                const relPath = '.opentology/ontology.ttl';
+                if (!config.files[contextUri].includes(relPath)) {
+                    config.files[contextUri].push(relPath);
+                }
+                console.log(pc.green('  Bootstrapped otx ontology vocabulary (6 classes, 12 properties)'));
+            }
+            else {
+                console.log(pc.dim('  Ontology already bootstrapped — skipped'));
+            }
+            // Create adapter after config is updated with tracked files
+            const adapter = await createReadyAdapter(config);
+            // Step 3: Write hook script
+            const hookDir = join(process.cwd(), '.opentology', 'hooks');
+            const hookPath = join(hookDir, 'session-start.mjs');
+            if (!existsSync(hookPath) || opts.force) {
+                mkdirSync(hookDir, { recursive: true });
+                writeFileSync(hookPath, generateHookScript(), 'utf-8');
+                createdHook = true;
+                console.log(pc.green(`  Generated hook script: .opentology/hooks/session-start.mjs`));
+            }
+            else {
+                console.log(pc.dim('  Hook script already exists — skipped (use --force to regenerate)'));
+            }
+            // Step 4: Update CLAUDE.md
+            const claudeMdPath = join(process.cwd(), 'CLAUDE.md');
+            const section = generateContextSection(config.projectId, config.graphUri);
+            if (!existsSync(claudeMdPath) || opts.force) {
+                updateClaudeMd(claudeMdPath, section);
+                createdClaudeMd = true;
+                console.log(pc.green('  Updated CLAUDE.md with context management instructions'));
+            }
+            else {
+                // Check for markers — update if present, append if not
+                const { readFileSync } = await import('node:fs');
+                const content = readFileSync(claudeMdPath, 'utf-8');
+                if (content.includes('OPENTOLOGY:CONTEXT:BEGIN')) {
+                    updateClaudeMd(claudeMdPath, section);
+                    createdClaudeMd = true;
+                    console.log(pc.green('  Updated CLAUDE.md context section'));
+                }
+                else {
+                    updateClaudeMd(claudeMdPath, section);
+                    createdClaudeMd = true;
+                    console.log(pc.green('  Appended context section to CLAUDE.md'));
+                }
+            }
+            // Step 5: Generate slash commands
+            const commandsDir = join(process.cwd(), '.claude', 'commands');
+            const slashCommands = generateSlashCommands();
+            const expectedFilenames = new Set(slashCommands.map((c) => c.filename));
+            let slashCreated = 0;
+            mkdirSync(commandsDir, { recursive: true });
+            // Clean up stale slash command files from previous naming conventions
+            if (existsSync(commandsDir)) {
+                for (const file of readdirSync(commandsDir)) {
+                    if (file.endsWith('.md') && !expectedFilenames.has(file) && file.includes('context-')) {
+                        unlinkSync(join(commandsDir, file));
+                    }
+                }
+            }
+            for (const cmd of slashCommands) {
+                const cmdPath = join(commandsDir, cmd.filename);
+                if (!existsSync(cmdPath) || opts.force) {
+                    writeFileSync(cmdPath, cmd.content, 'utf-8');
+                    slashCreated++;
+                }
+            }
+            if (slashCreated > 0) {
+                console.log(pc.green(`  Generated ${slashCreated} slash commands in .claude/commands/`));
+            }
+            else {
+                console.log(pc.dim('  Slash commands already exist — skipped'));
+            }
+            // Step 6: Save config LAST (atomic commit point)
+            saveConfig(config);
+            // Print hook registration instructions
+            console.log('');
+            console.log(pc.bold('Add this to your project .claude/settings.json:'));
+            console.log('');
+            console.log(JSON.stringify({
+                hooks: {
+                    SessionStart: [{
+                            type: 'command',
+                            command: 'node .opentology/hooks/session-start.mjs',
+                        }],
+                },
+            }, null, 2));
+            console.log('');
+            console.log(pc.dim('Consider adding .opentology/hooks/ to version control so team members share the hook.'));
+        }
+        catch (err) {
+            // Rollback: clean up files created in this run
+            if (createdHook) {
+                const hookPath = join(process.cwd(), '.opentology', 'hooks', 'session-start.mjs');
+                try {
+                    unlinkSync(hookPath);
+                }
+                catch { /* ignore */ }
+            }
+            if (createdClaudeMd) {
+                // Only delete if we created a new file (not appended to existing)
+                const claudeMdPath = join(process.cwd(), 'CLAUDE.md');
+                // Don't delete existing CLAUDE.md — too risky. Just warn.
+            }
+            console.error(pc.red(`Error during context init: ${err.message}`));
+            console.error(pc.dim('Config was NOT modified. Fix the error and retry.'));
+            process.exit(1);
+        }
+    });
+    // --- context load ---
+    context
+        .command('load')
+        .description('Load project context (recent sessions, open issues, decisions)')
+        .option('--format <type>', 'Output format: table, json', 'table')
+        .action(async (opts) => {
+        let config;
+        try {
+            config = loadConfig();
+        }
+        catch {
+            console.error('Error: No .opentology.json found. Run `opentology init` first.');
+            process.exit(1);
+        }
+        const graphs = config.graphs ?? {};
+        if (!graphs['context'] || !graphs['sessions']) {
+            console.error('Error: Context not initialized. Run `opentology context init` first.');
+            process.exit(1);
+        }
+        const contextUri = graphs['context'];
+        const sessionsUri = graphs['sessions'];
+        const output = {
+            projectId: config.projectId,
+            graphUri: config.graphUri,
+            sessions: [],
+            openIssues: [],
+            recentDecisions: [],
+            meta: {
+                contextTripleCount: 0,
+                sessionsTripleCount: 0,
+                loadedAt: new Date().toISOString(),
+            },
+            warnings: [],
+        };
+        try {
+            const adapter = await createReadyAdapter(config);
+            // Query 1: Recent sessions
+            try {
+                const sessionsResult = await adapter.sparqlQuery(`
+            PREFIX otx: <https://opentology.dev/vocab#>
+            SELECT ?session ?title ?date ?nextTodo WHERE {
+              GRAPH <${sessionsUri}> {
+                ?session a otx:Session ;
+                         otx:title ?title ;
+                         otx:date ?date .
+                OPTIONAL { ?session otx:nextTodo ?nextTodo }
+              }
+            } ORDER BY DESC(?date) LIMIT 3
+          `);
+                output.sessions = sessionsResult.results.bindings.map((b) => ({
+                    uri: b['session']?.value ?? '',
+                    title: b['title']?.value ?? '',
+                    date: b['date']?.value ?? '',
+                    ...(b['nextTodo']?.value ? { nextTodo: b['nextTodo'].value } : {}),
+                }));
+            }
+            catch (err) {
+                output.warnings.push(`Failed to query sessions: ${err.message}`);
+            }
+            // Query 2: Open issues
+            try {
+                const issuesResult = await adapter.sparqlQuery(`
+            PREFIX otx: <https://opentology.dev/vocab#>
+            SELECT ?issue ?title ?date WHERE {
+              GRAPH <${contextUri}> {
+                ?issue a otx:Issue ;
+                       otx:title ?title ;
+                       otx:date ?date ;
+                       otx:status "open" .
+              }
+            } ORDER BY DESC(?date) LIMIT 10
+          `);
+                output.openIssues = issuesResult.results.bindings.map((b) => ({
+                    uri: b['issue']?.value ?? '',
+                    title: b['title']?.value ?? '',
+                    date: b['date']?.value ?? '',
+                }));
+            }
+            catch (err) {
+                output.warnings.push(`Failed to query issues: ${err.message}`);
+            }
+            // Query 3: Recent decisions
+            try {
+                const decisionsResult = await adapter.sparqlQuery(`
+            PREFIX otx: <https://opentology.dev/vocab#>
+            SELECT ?decision ?title ?date ?reason WHERE {
+              GRAPH <${contextUri}> {
+                ?decision a otx:Decision ;
+                          otx:title ?title ;
+                          otx:date ?date .
+                OPTIONAL { ?decision otx:reason ?reason }
+              }
+            } ORDER BY DESC(?date) LIMIT 3
+          `);
+                output.recentDecisions = decisionsResult.results.bindings.map((b) => ({
+                    uri: b['decision']?.value ?? '',
+                    title: b['title']?.value ?? '',
+                    date: b['date']?.value ?? '',
+                    ...(b['reason']?.value ? { reason: b['reason'].value } : {}),
+                }));
+            }
+            catch (err) {
+                output.warnings.push(`Failed to query decisions: ${err.message}`);
+            }
+            // Meta: triple counts
+            try {
+                output.meta.contextTripleCount = await adapter.getGraphTripleCount(contextUri);
+            }
+            catch { /* ignore */ }
+            try {
+                output.meta.sessionsTripleCount = await adapter.getGraphTripleCount(sessionsUri);
+            }
+            catch { /* ignore */ }
+            // Clean up empty warnings
+            if (output.warnings.length === 0)
+                delete output.warnings;
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+        if (opts.format === 'json') {
+            console.log(JSON.stringify(output, null, 2));
+        }
+        else {
+            // Table format
+            console.log(pc.bold(`Project: ${output.projectId}`));
+            console.log('');
+            if (output.sessions.length > 0) {
+                console.log(pc.bold('Recent Sessions:'));
+                for (const s of output.sessions) {
+                    console.log(`  ${pc.dim(s.date)}  ${s.title}`);
+                    if (s.nextTodo)
+                        console.log(`    ${pc.dim('Next:')} ${s.nextTodo}`);
+                }
+                console.log('');
+            }
+            if (output.openIssues.length > 0) {
+                console.log(pc.bold(`Open Issues (${output.openIssues.length}):`));
+                for (const i of output.openIssues) {
+                    console.log(`  ${pc.dim(i.date)}  ${i.title}`);
+                }
+                console.log('');
+            }
+            if (output.recentDecisions.length > 0) {
+                console.log(pc.bold('Recent Decisions:'));
+                for (const d of output.recentDecisions) {
+                    console.log(`  ${pc.dim(d.date)}  ${d.title}`);
+                }
+                console.log('');
+            }
+            console.log(pc.dim(`Context: ${output.meta.contextTripleCount} triples | Sessions: ${output.meta.sessionsTripleCount} triples`));
+        }
+    });
+    // --- context status ---
+    context
+        .command('status')
+        .description('Show context initialization status')
+        .action(async () => {
+        let config;
+        try {
+            config = loadConfig();
+        }
+        catch {
+            console.log('Context:     ' + pc.red('not initialized') + ' (no .opentology.json)');
+            return;
+        }
+        const graphs = config.graphs ?? {};
+        const hasContext = !!graphs['context'];
+        const hasSessions = !!graphs['sessions'];
+        const initialized = hasContext && hasSessions;
+        console.log('Context:     ' + (initialized ? pc.green('initialized') : pc.red('not initialized')));
+        if (initialized) {
+            const adapter = await createReadyAdapter(config);
+            const contextCount = await adapter.getGraphTripleCount(graphs['context']).catch(() => 0);
+            const sessionsCount = await adapter.getGraphTripleCount(graphs['sessions']).catch(() => 0);
+            console.log('Graphs:');
+            console.log(`  context    ${graphs['context']}   (${contextCount} triples)`);
+            console.log(`  sessions   ${graphs['sessions']}  (${sessionsCount} triples)`);
+        }
+        const hookPath = join(process.cwd(), '.opentology', 'hooks', 'session-start.mjs');
+        const hookExists = existsSync(hookPath);
+        console.log('Hook:        .opentology/hooks/session-start.mjs ' + (hookExists ? pc.green('(exists)') : pc.red('(missing)')));
+        const claudeMdPath = join(process.cwd(), 'CLAUDE.md');
+        if (!existsSync(claudeMdPath)) {
+            console.log('CLAUDE.md:   ' + pc.red('file missing'));
+        }
+        else {
+            const { readFileSync } = await import('node:fs');
+            const content = readFileSync(claudeMdPath, 'utf-8');
+            const hasMarkers = content.includes('OPENTOLOGY:CONTEXT:BEGIN');
+            console.log('CLAUDE.md:   ' + (hasMarkers ? pc.green('markers present') : pc.yellow('markers missing')));
+        }
+    });
+}

package/dist/commands/delete.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerDelete(program: Command): void;

package/dist/commands/delete.js

@@ -0,0 +1,46 @@
+import { readFileSync } from 'node:fs';
+import pc from 'picocolors';
+import { loadConfig, resolveGraphUri } from '../lib/config.js';
+import { createReadyAdapter } from '../lib/store-factory.js';
+export function registerDelete(program) {
+    program
+        .command('delete [file]')
+        .description('Delete specific triples from the project graph')
+        .option('--where <pattern>', 'SPARQL WHERE pattern for pattern-based deletion')
+        .option('--graph <name>', 'Target a specific named graph')
+        .action(async (file, opts) => {
+        let config;
+        try {
+            config = loadConfig();
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+        if (!file && !opts.where) {
+            console.error('Provide a Turtle file or --where pattern');
+            process.exit(1);
+        }
+        if (config.mode === 'embedded') {
+            console.error('Delete is not supported in embedded mode — edit your .ttl files directly.');
+            process.exit(1);
+        }
+        const graphUri = opts.graph ? resolveGraphUri(config, opts.graph) : config.graphUri;
+        try {
+            const adapter = await createReadyAdapter(config);
+            if (file) {
+                const content = readFileSync(file, 'utf-8');
+                await adapter.deleteTriples(graphUri, { turtle: content });
+                console.log(pc.green(`Deleted triples from ${file}`));
+            }
+            else if (opts.where) {
+                await adapter.deleteTriples(graphUri, { where: opts.where });
+                console.log(pc.green('Deleted triples matching pattern'));
+            }
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/diff.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerDiff(program: Command): void;

package/dist/commands/diff.js

@@ -0,0 +1,43 @@
+import { readFileSync } from 'node:fs';
+import pc from 'picocolors';
+import { loadConfig, resolveGraphUri } from '../lib/config.js';
+import { createReadyAdapter } from '../lib/store-factory.js';
+export function registerDiff(program) {
+    program
+        .command('diff <file>')
+        .description('Show differences between a local Turtle file and the remote graph')
+        .option('--graph <name>', 'Target a specific named graph')
+        .action(async (file, opts) => {
+        let config;
+        try {
+            config = loadConfig();
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+        const graphUri = opts.graph ? resolveGraphUri(config, opts.graph) : config.graphUri;
+        try {
+            const adapter = await createReadyAdapter(config);
+            const turtle = readFileSync(file, 'utf-8');
+            const result = await adapter.diffGraph(graphUri, turtle);
+            for (const triple of result.added) {
+                console.log(pc.green(`+ ${triple}`));
+            }
+            for (const triple of result.removed) {
+                console.log(pc.red(`- ${triple}`));
+            }
+            console.log(`\n${result.added.length} added, ${result.removed.length} removed, ${result.unchanged} unchanged`);
+        }
+        catch (err) {
+            const message = err.message;
+            if (message.includes('fetch failed') || message.includes('ECONNREFUSED')) {
+                console.error(`Cannot connect to Oxigraph at ${config.endpoint ?? 'unknown'}. Is it running? Start with: docker compose up -d`);
+            }
+            else {
+                console.error(`Error: ${message}`);
+            }
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/drop.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerDrop(program: Command): void;

package/dist/commands/drop.js

@@ -0,0 +1,41 @@
+import pc from 'picocolors';
+import { loadConfig, resolveGraphUri, saveConfig } from '../lib/config.js';
+import { createReadyAdapter } from '../lib/store-factory.js';
+export function registerDrop(program) {
+    program
+        .command('drop')
+        .description('Drop (delete) the entire project graph')
+        .option('--force', 'Skip confirmation and drop immediately')
+        .option('--graph <name>', 'Target a specific named graph')
+        .action(async (opts) => {
+        let config;
+        try {
+            config = loadConfig();
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+        const graphUri = opts.graph ? resolveGraphUri(config, opts.graph) : config.graphUri;
+        if (!opts.force) {
+            console.error(pc.red(`This will delete all triples in ${graphUri}. Use --force to confirm.`));
+            process.exit(1);
+        }
+        try {
+            const adapter = await createReadyAdapter(config);
+            await adapter.dropGraph(graphUri);
+            // In embedded mode, clear tracked files for this graph
+            if (config.mode === 'embedded') {
+                if (!config.files)
+                    config.files = {};
+                config.files[graphUri] = [];
+                saveConfig(config);
+            }
+            console.log(pc.green(`Dropped graph ${graphUri}`));
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/graph.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerGraph(program: Command): void;

package/dist/commands/graph.js

@@ -0,0 +1,130 @@
+import pc from 'picocolors';
+import { loadConfig, saveConfig, resolveGraphUri } from '../lib/config.js';
+import { createReadyAdapter } from '../lib/store-factory.js';
+export function registerGraph(program) {
+    const graph = program
+        .command('graph')
+        .description('Manage named graphs for the project');
+    graph
+        .command('list')
+        .description('List all named graphs for the project')
+        .action(async () => {
+        let config;
+        try {
+            config = loadConfig();
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+        try {
+            const adapter = await createReadyAdapter(config);
+            // Query for all graphs that start with the project's base URI
+            const results = await adapter.sparqlQuery(`SELECT DISTINCT ?g (COUNT(*) AS ?count) WHERE { GRAPH ?g { ?s ?p ?o } } GROUP BY ?g`);
+            const baseUri = config.graphUri;
+            const remoteGraphs = new Map();
+            for (const binding of results.results.bindings) {
+                const g = binding['g']?.value;
+                const count = binding['count']?.value;
+                if (g && g.startsWith(baseUri)) {
+                    remoteGraphs.set(g, count ? parseInt(count, 10) : 0);
+                }
+            }
+            // Merge with config.graphs
+            const configGraphs = config.graphs ?? {};
+            const allUris = new Set([
+                baseUri,
+                ...remoteGraphs.keys(),
+                ...Object.values(configGraphs),
+            ]);
+            // Build name lookup: URI -> logical name
+            const uriToName = new Map();
+            uriToName.set(baseUri, '(default)');
+            for (const [name, uri] of Object.entries(configGraphs)) {
+                uriToName.set(uri, name);
+            }
+            // Print table
+            console.log(`${'Name'.padEnd(20)}  ${'URI'.padEnd(60)}  ${'Triples'.padStart(8)}`);
+            console.log(`${'-'.repeat(20)}  ${'-'.repeat(60)}  ${'-'.repeat(8)}`);
+            for (const uri of allUris) {
+                const name = uriToName.get(uri) ?? '?';
+                const count = remoteGraphs.get(uri);
+                const tripleStr = count !== undefined ? String(count) : '?';
+                console.log(`${name.padEnd(20)}  ${uri.padEnd(60)}  ${tripleStr.padStart(8)}`);
+            }
+        }
+        catch (err) {
+            const message = err.message;
+            if (message.includes('fetch failed') || message.includes('ECONNREFUSED')) {
+                console.error(`Cannot connect to Oxigraph at ${config.endpoint ?? 'unknown'}. Is it running? Start with: docker compose up -d`);
+            }
+            else {
+                console.error(`Error: ${message}`);
+            }
+            process.exit(1);
+        }
+    });
+    graph
+        .command('create <name>')
+        .description('Create a new named graph')
+        .action(async (name) => {
+        let config;
+        try {
+            config = loadConfig();
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+        const graphs = config.graphs ?? {};
+        if (graphs[name]) {
+            console.error(`Graph '${name}' already exists: ${graphs[name]}`);
+            process.exit(1);
+        }
+        const uri = `${config.graphUri}/${name}`;
+        graphs[name] = uri;
+        config.graphs = graphs;
+        saveConfig(config);
+        console.log(pc.green(`Created graph '${name}' -> ${uri}`));
+    });
+    graph
+        .command('drop <name>')
+        .description('Drop a named graph')
+        .option('--force', 'Skip confirmation and drop immediately')
+        .action(async (name, opts) => {
+        let config;
+        try {
+            config = loadConfig();
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+        let graphUri;
+        try {
+            graphUri = resolveGraphUri(config, name);
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+            return;
+        }
+        if (!opts.force) {
+            console.error(pc.red(`This will delete all triples in graph '${name}' (${graphUri}). Use --force to confirm.`));
+            process.exit(1);
+        }
+        try {
+            const adapter = await createReadyAdapter(config);
+            await adapter.dropGraph(graphUri);
+            const graphs = config.graphs ?? {};
+            delete graphs[name];
+            config.graphs = Object.keys(graphs).length > 0 ? graphs : undefined;
+            saveConfig(config);
+            console.log(pc.green(`Dropped graph '${name}' (${graphUri})`));
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/infer.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerInfer(program: Command): void;