opentology 0.1.0

package/dist/commands/infer.js

@@ -0,0 +1,47 @@
+import pc from 'picocolors';
+import { loadConfig, resolveGraphUri } from '../lib/config.js';
+import { createReadyAdapter } from '../lib/store-factory.js';
+import { materializeInferences, clearInferences } from '../lib/reasoner.js';
+export function registerInfer(program) {
+    program
+        .command('infer')
+        .description('Run RDFS inference on the project graph')
+        .option('--clear', 'Clear the inference graph')
+        .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;
+        try {
+            const adapter = await createReadyAdapter(config);
+            if (opts.clear) {
+                await clearInferences(adapter, graphUri);
+                console.log(pc.green('Cleared inference graph'));
+                return;
+            }
+            const result = await materializeInferences(adapter, graphUri);
+            console.log(pc.green(`Inferred ${pc.cyan(String(result.inferredCount))} triples`));
+            const activeRules = Object.entries(result.rules).filter(([, n]) => n > 0);
+            if (activeRules.length > 0) {
+                const breakdown = activeRules.map(([rule, n]) => `${rule}: ${pc.cyan(String(n))}`).join(', ');
+                console.log(breakdown);
+            }
+        }
+        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/init.d.ts

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

package/dist/commands/init.js

@@ -0,0 +1,53 @@
+import { basename } from 'node:path';
+import pc from 'picocolors';
+import { configExists, saveConfig } from '../lib/config.js';
+const DEFAULT_PREFIXES = {
+    rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+    rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
+    owl: 'http://www.w3.org/2002/07/owl#',
+    xsd: 'http://www.w3.org/2001/XMLSchema#',
+    schema: 'http://schema.org/',
+};
+function slugify(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+export function registerInit(program) {
+    program
+        .command('init [projectId]')
+        .description('Initialize a new OpenTology project')
+        .option('--embedded', 'Use embedded mode (no server needed)')
+        .action((projectId, opts) => {
+        if (configExists()) {
+            console.error('Error: .opentology.json already exists in this directory.');
+            console.error('Remove it first if you want to re-initialize.');
+            process.exit(1);
+        }
+        const id = projectId || slugify(basename(process.cwd()));
+        if (!id) {
+            console.error('Error: Could not determine project ID. Please provide one explicitly.');
+            process.exit(1);
+        }
+        const graphUri = `https://opentology.dev/${id}`;
+        if (opts.embedded) {
+            saveConfig({ projectId: id, mode: 'embedded', graphUri, prefixes: DEFAULT_PREFIXES });
+            console.log(pc.green(`Initialized OpenTology project.`));
+            console.log(`  Project ID: ${id}`);
+            console.log(`  Mode:       embedded (no server needed)`);
+            console.log(`  Graph URI:  ${graphUri}`);
+            console.log(`\nConfig saved to .opentology.json`);
+        }
+        else {
+            const endpoint = 'http://localhost:7878';
+            saveConfig({ projectId: id, mode: 'http', endpoint, graphUri, prefixes: DEFAULT_PREFIXES });
+            console.log(pc.green(`Initialized OpenTology project.`));
+            console.log(`  Project ID: ${id}`);
+            console.log(`  Mode:       http`);
+            console.log(`  Endpoint:   ${endpoint}`);
+            console.log(`  Graph URI:  ${graphUri}`);
+            console.log(`\nConfig saved to .opentology.json`);
+        }
+    });
+}

package/dist/commands/mcp.d.ts

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

package/dist/commands/mcp.js

@@ -0,0 +1,9 @@
+import { startMcpServer } from '../mcp/server.js';
+export function registerMcp(program) {
+    program
+        .command('mcp')
+        .description('Start MCP server for AI agent integration')
+        .action(async () => {
+        await startMcpServer();
+    });
+}

package/dist/commands/prefix.d.ts

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

package/dist/commands/prefix.js

@@ -0,0 +1,73 @@
+import pc from 'picocolors';
+import { loadConfig, saveConfig } from '../lib/config.js';
+export function registerPrefix(program) {
+    const prefix = program
+        .command('prefix')
+        .description('Manage project-level SPARQL prefix declarations');
+    prefix
+        .command('list')
+        .description('Show all registered prefixes')
+        .action(() => {
+        let config;
+        try {
+            config = loadConfig();
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+        const prefixes = config.prefixes ?? {};
+        const entries = Object.entries(prefixes);
+        if (entries.length === 0) {
+            console.log('No prefixes registered. Use `opentology prefix add <name> <uri>` to add one.');
+            return;
+        }
+        const maxName = Math.max(...entries.map(([n]) => n.length), 6);
+        console.log(`${'PREFIX'.padEnd(maxName)}  URI`);
+        console.log(`${'-'.repeat(maxName)}  ${'-'.repeat(40)}`);
+        for (const [name, uri] of entries) {
+            console.log(`${pc.cyan(name.padEnd(maxName))}  ${uri}`);
+        }
+    });
+    prefix
+        .command('add <name> <uri>')
+        .description('Add a prefix mapping')
+        .action((name, uri) => {
+        let config;
+        try {
+            config = loadConfig();
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+        if (!config.prefixes)
+            config.prefixes = {};
+        config.prefixes[name] = uri;
+        saveConfig(config);
+        console.log(pc.green(`Added prefix ${pc.cyan(name)}: → ${uri}`));
+    });
+    prefix
+        .command('remove <name>')
+        .description('Remove a prefix mapping')
+        .action((name) => {
+        let config;
+        try {
+            config = loadConfig();
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+        if (!config.prefixes?.[name]) {
+            console.error(`Error: prefix '${name}' is not registered.`);
+            process.exit(1);
+        }
+        delete config.prefixes[name];
+        if (Object.keys(config.prefixes).length === 0) {
+            config.prefixes = undefined;
+        }
+        saveConfig(config);
+        console.log(pc.green(`Removed prefix ${pc.cyan(name)}`));
+    });
+}

package/dist/commands/pull.d.ts

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

package/dist/commands/pull.js

@@ -0,0 +1,43 @@
+import { writeFileSync } from 'node:fs';
+import { loadConfig, resolveGraphUri } from '../lib/config.js';
+import { createReadyAdapter } from '../lib/store-factory.js';
+export function registerPull(program) {
+    program
+        .command('pull [output]')
+        .description('Export graph from triplestore as Turtle')
+        .option('--graph <name>', 'Target a specific named graph')
+        .action(async (output, 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 = await adapter.exportGraph(graphUri);
+            const count = await adapter.getGraphTripleCount(graphUri);
+            if (output) {
+                writeFileSync(output, turtle, 'utf-8');
+                console.log(`Exported ${count} triples to ${output}`);
+            }
+            else if (process.stdout.isTTY) {
+                // Interactive terminal — write to default file
+                const filename = `${config.projectId}.ttl`;
+                writeFileSync(filename, turtle, 'utf-8');
+                console.log(`Exported ${count} triples to ${filename}`);
+            }
+            else {
+                // Piped — write turtle to stdout
+                process.stdout.write(turtle);
+            }
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/push.d.ts

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

package/dist/commands/push.js

@@ -0,0 +1,79 @@
+import { readFileSync } from 'node:fs';
+import pc from 'picocolors';
+import { loadConfig, resolveGraphUri, saveConfig, addTrackedFile } from '../lib/config.js';
+import { createReadyAdapter } from '../lib/store-factory.js';
+import { validateTurtleFile } from '../lib/validator.js';
+import { discoverShapes, validateWithShacl, hasShapes } from '../lib/shacl.js';
+import { materializeInferences } from '../lib/reasoner.js';
+export function registerPush(program) {
+    program
+        .command('push <file>')
+        .description('Push a Turtle file to the triplestore')
+        .option('--replace', 'Replace entire graph contents (drop + push)')
+        .option('--no-shacl', 'Skip SHACL validation')
+        .option('--no-infer', 'Skip RDFS inference after push')
+        .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 result = await validateTurtleFile(file);
+            if (!result.valid) {
+                console.error(`Validation failed: ${result.error}`);
+                process.exit(1);
+            }
+            const turtle = readFileSync(file, 'utf-8');
+            // Auto-validate against SHACL when shapes exist (unless --no-shacl)
+            if (opts.shacl !== false && hasShapes()) {
+                const shapePaths = discoverShapes();
+                const report = await validateWithShacl(turtle, shapePaths);
+                if (!report.conforms) {
+                    for (const v of report.violations) {
+                        console.error(pc.red(`SHACL Violation: ${v.focusNode} — ${v.message} (path: ${v.path})`));
+                    }
+                    process.exit(1);
+                }
+                console.log('SHACL: conforms');
+            }
+            const adapter = await createReadyAdapter(config);
+            if (opts.replace) {
+                await adapter.dropGraph(graphUri);
+            }
+            await adapter.insertTurtle(graphUri, turtle);
+            // In embedded mode, track the file
+            if (config.mode === 'embedded') {
+                addTrackedFile(config, graphUri, file);
+                saveConfig(config);
+            }
+            if (opts.replace) {
+                console.log(pc.green(`Replaced graph with ${result.tripleCount} triples`));
+            }
+            else {
+                console.log(pc.green(`Pushed ${result.tripleCount} triples to ${graphUri}`));
+            }
+            if (opts.infer !== false) {
+                const inference = await materializeInferences(adapter, graphUri);
+                if (inference.inferredCount > 0) {
+                    console.log(pc.green(`Inferred ${pc.cyan(String(inference.inferredCount))} additional triples`));
+                }
+            }
+        }
+        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/query.d.ts

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

package/dist/commands/query.js

@@ -0,0 +1,119 @@
+import { loadConfig, resolveGraphUri } from '../lib/config.js';
+import { createReadyAdapter } from '../lib/store-factory.js';
+import { hasGraphScope, autoScopeQuery } from '../lib/sparql-utils.js';
+function injectPrefixes(sparql, prefixes) {
+    const lines = Object.entries(prefixes)
+        .filter(([prefix]) => {
+        // Skip if the query already declares this prefix
+        const re = new RegExp(`PREFIX\\s+${prefix}\\s*:`, 'i');
+        return !re.test(sparql);
+    })
+        .map(([prefix, uri]) => `PREFIX ${prefix}: <${uri}>`);
+    if (lines.length === 0)
+        return sparql;
+    return lines.join('\n') + '\n' + sparql;
+}
+function formatTable(vars, bindings) {
+    if (bindings.length === 0) {
+        return '(no results)';
+    }
+    // Calculate column widths
+    const widths = {};
+    for (const v of vars) {
+        widths[v] = v.length;
+    }
+    for (const row of bindings) {
+        for (const v of vars) {
+            const val = row[v]?.value ?? '';
+            widths[v] = Math.max(widths[v], val.length);
+        }
+    }
+    // Build header
+    const header = vars.map(v => v.padEnd(widths[v])).join('  ');
+    const separator = vars.map(v => '-'.repeat(widths[v])).join('  ');
+    // Build rows
+    const rows = bindings.map(row => vars.map(v => (row[v]?.value ?? '').padEnd(widths[v])).join('  '));
+    return [header, separator, ...rows].join('\n');
+}
+function formatCsv(vars, bindings) {
+    const header = vars.join(',');
+    const rows = bindings.map(row => vars.map(v => {
+        const val = row[v]?.value ?? '';
+        // Escape values containing commas, quotes, or newlines
+        if (val.includes(',') || val.includes('"') || val.includes('\n')) {
+            return `"${val.replace(/"/g, '""')}"`;
+        }
+        return val;
+    }).join(','));
+    return [header, ...rows].join('\n');
+}
+export function registerQuery(program) {
+    program
+        .command('query <sparql>')
+        .description('Run a SPARQL query against the triplestore')
+        .option('--format <type>', 'Output format: table, json, csv', 'table')
+        .option('--json', 'Output raw JSON (alias for --format json)')
+        .option('--raw', 'Skip automatic Named Graph scoping')
+        .option('--graph <name>', 'Target a specific named graph')
+        .action(async (sparql, options) => {
+        let config;
+        try {
+            config = loadConfig();
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+        const graphUri = options.graph ? resolveGraphUri(config, options.graph) : config.graphUri;
+        // Resolve format: --json flag overrides --format
+        const format = options.json ? 'json' : (options.format || 'table');
+        // Inject project-level PREFIX declarations from config
+        let effectiveSparql = sparql;
+        if (config.prefixes) {
+            effectiveSparql = injectPrefixes(effectiveSparql, config.prefixes);
+        }
+        // Auto-scope the query to the project's Named Graph unless the user
+        // has already specified graph scoping or passed --raw.
+        if (!options.raw && !hasGraphScope(effectiveSparql)) {
+            const scoped = autoScopeQuery(effectiveSparql, graphUri);
+            if (scoped !== null) {
+                effectiveSparql = scoped;
+            }
+            else {
+                // Transformation failed — run as-is and warn.
+                console.warn(`Warning: could not auto-scope query. Add GRAPH <${graphUri}> manually or use --raw.`);
+            }
+        }
+        try {
+            const adapter = await createReadyAdapter(config);
+            const results = await adapter.sparqlQuery(effectiveSparql);
+            switch (format) {
+                case 'json':
+                    console.log(JSON.stringify(results, null, 2));
+                    break;
+                case 'csv':
+                    console.log(formatCsv(results.head.vars, results.results.bindings));
+                    break;
+                default: {
+                    const output = formatTable(results.head.vars, results.results.bindings);
+                    console.log(output);
+                    if (results.results.bindings.length === 0) {
+                        console.log(`\nHint: use GRAPH <${graphUri}> in your WHERE clause`);
+                    }
+                    break;
+                }
+            }
+        }
+        catch (err) {
+            const message = err.message;
+            console.error(`Error: ${message}`);
+            if (message.includes('fetch failed') || message.includes('ECONNREFUSED')) {
+                console.error(`Cannot connect to triplestore at ${config.endpoint ?? 'unknown'}. Is it running? Start with: docker compose up -d`);
+            }
+            if (message.toLowerCase().includes('parse') && sparql.includes('\\!')) {
+                console.error(`Hint: if your query contains !=, your shell may have escaped the '!' character. Try wrapping the query in $'...' or use FILTER(?x NOT IN (<uri>)) instead.`);
+            }
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/shapes.d.ts

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

package/dist/commands/shapes.js

@@ -0,0 +1,67 @@
+import { readFileSync } from 'node:fs';
+import { basename } from 'node:path';
+import { Parser } from 'n3';
+import { discoverShapes } from '../lib/shacl.js';
+/**
+ * Parse a Turtle file and extract sh:targetClass values.
+ */
+function extractTargetClasses(turtle) {
+    const classes = [];
+    const parser = new Parser();
+    const quads = parser.parse(turtle);
+    for (const quad of quads) {
+        if (quad.predicate.value === 'http://www.w3.org/ns/shacl#targetClass') {
+            classes.push(quad.object.value);
+        }
+    }
+    return classes;
+}
+export function registerShapes(program) {
+    const shapes = program
+        .command('shapes')
+        .description('List and inspect SHACL shapes');
+    shapes
+        .command('list', { isDefault: true })
+        .description('List all shapes in shapes/ directory')
+        .action(() => {
+        const shapePaths = discoverShapes();
+        if (shapePaths.length === 0) {
+            console.log('No shapes found in shapes/ directory');
+            return;
+        }
+        console.log('Shapes:');
+        console.log('');
+        console.log(padRight('File', 30) + padRight('Target Classes', 50));
+        console.log(padRight('—', 30, '—') + padRight('—', 50, '—'));
+        for (const shapePath of shapePaths) {
+            const name = basename(shapePath);
+            try {
+                const content = readFileSync(shapePath, 'utf-8');
+                const targets = extractTargetClasses(content);
+                const targetStr = targets.length > 0 ? targets.join(', ') : '(none)';
+                console.log(padRight(name, 30) + padRight(targetStr, 50));
+            }
+            catch {
+                console.log(padRight(name, 30) + padRight('(parse error)', 50));
+            }
+        }
+    });
+    shapes
+        .command('show <file>')
+        .description('Display a shape file\'s contents')
+        .action((file) => {
+        const shapePaths = discoverShapes();
+        const match = shapePaths.find((p) => basename(p) === file || p === file);
+        if (!match) {
+            console.error(`Shape file not found: ${file}`);
+            process.exit(1);
+        }
+        const content = readFileSync(match, 'utf-8');
+        console.log(content);
+    });
+}
+function padRight(str, len, fill = ' ') {
+    if (str.length >= len)
+        return str;
+    return str + fill.repeat(len - str.length);
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,47 @@
+import pc from 'picocolors';
+import { loadConfig, resolveGraphUri, getTrackedFiles } from '../lib/config.js';
+import { createReadyAdapter } from '../lib/store-factory.js';
+import { getInferenceGraphUri } from '../lib/sparql-utils.js';
+export function registerStatus(program) {
+    program
+        .command('status')
+        .description('Show project status and triplestore info')
+        .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;
+        console.log(`${pc.cyan('Project:')}   ${config.projectId}`);
+        console.log(`${pc.cyan('Graph URI:')} ${graphUri}`);
+        console.log(`${pc.cyan('Mode:')}      ${config.mode}`);
+        if (config.endpoint) {
+            console.log(`${pc.cyan('Endpoint:')}  ${config.endpoint}`);
+        }
+        if (opts.graph) {
+            console.log(`${pc.cyan('Graph:')}     ${opts.graph}`);
+        }
+        if (config.mode === 'embedded') {
+            const trackedCount = getTrackedFiles(config, graphUri).length;
+            console.log(`${pc.cyan('Tracked files:')} ${trackedCount}`);
+        }
+        try {
+            const adapter = await createReadyAdapter(config);
+            const inferenceGraphUri = getInferenceGraphUri(graphUri);
+            const assertedCount = await adapter.getGraphTripleCount(graphUri);
+            const inferredCount = await adapter.getGraphTripleCount(inferenceGraphUri);
+            const totalCount = assertedCount + inferredCount;
+            console.log(`${pc.cyan('Triples (asserted):')} ${assertedCount}`);
+            console.log(`${pc.cyan('Triples (inferred):')} ${inferredCount}`);
+            console.log(`${pc.cyan('Triples (total):')}    ${totalCount}`);
+        }
+        catch {
+            console.log(`${pc.cyan('Triples:')}   Cannot connect to triplestore. Is it running?`);
+        }
+    });
+}

package/dist/commands/validate.d.ts

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

package/dist/commands/validate.js

@@ -0,0 +1,46 @@
+import { readFileSync } from 'node:fs';
+import pc from 'picocolors';
+import { validateTurtleFile } from '../lib/validator.js';
+import { discoverShapes, validateWithShacl } from '../lib/shacl.js';
+export function registerValidate(program) {
+    program
+        .command('validate <file>')
+        .description('Validate a local Turtle/RDF file')
+        .option('--shacl', 'Also validate against SHACL shapes in shapes/ directory')
+        .action(async (file, opts) => {
+        try {
+            const result = await validateTurtleFile(file);
+            if (result.valid) {
+                const prefixList = Object.keys(result.prefixes).join(', ') || '(none)';
+                console.log(pc.green(`Valid — ${result.tripleCount} triples, prefixes: ${prefixList}`));
+            }
+            else {
+                console.error(pc.red(`Validation failed: ${result.error}`));
+                process.exit(1);
+            }
+            if (opts.shacl) {
+                const shapePaths = discoverShapes();
+                if (shapePaths.length === 0) {
+                    console.log('SHACL: no shapes found in shapes/ directory');
+                }
+                else {
+                    const content = readFileSync(file, 'utf-8');
+                    const report = await validateWithShacl(content, shapePaths);
+                    if (report.conforms) {
+                        console.log(pc.green('SHACL: conforms'));
+                    }
+                    else {
+                        for (const v of report.violations) {
+                            console.error(pc.yellow(`SHACL Violation: ${v.focusNode} — ${v.message} (path: ${v.path})`));
+                        }
+                        process.exit(1);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};