opentology 0.1.0

package/dist/index.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerInit } from './commands/init.js';
+import { registerValidate } from './commands/validate.js';
+import { registerPush } from './commands/push.js';
+import { registerQuery } from './commands/query.js';
+import { registerStatus } from './commands/status.js';
+import { registerPull } from './commands/pull.js';
+import { registerDrop } from './commands/drop.js';
+import { registerDelete } from './commands/delete.js';
+import { registerMcp } from './commands/mcp.js';
+import { registerShapes } from './commands/shapes.js';
+import { registerDiff } from './commands/diff.js';
+import { registerGraph } from './commands/graph.js';
+import { registerInfer } from './commands/infer.js';
+import { registerPrefix } from './commands/prefix.js';
+import { registerContext } from './commands/context.js';
+const program = new Command();
+program
+    .name('opentology')
+    .version('0.1.0')
+    .description('CLI-managed RDF/SPARQL infrastructure — Supabase for RDF');
+registerInit(program);
+registerValidate(program);
+registerPush(program);
+registerQuery(program);
+registerStatus(program);
+registerPull(program);
+registerDrop(program);
+registerDelete(program);
+registerMcp(program);
+registerShapes(program);
+registerDiff(program);
+registerGraph(program);
+registerInfer(program);
+registerPrefix(program);
+registerContext(program);
+program.parse(process.argv);

package/dist/lib/codebase-scanner.d.ts

@@ -0,0 +1,41 @@
+export interface DirectoryNode {
+    name: string;
+    type: 'file' | 'directory';
+    children?: DirectoryNode[];
+}
+export interface DependencyEdge {
+    from: string;
+    to: string;
+}
+export interface DependencyGraph {
+    modules: string[];
+    edges: DependencyEdge[];
+}
+export interface CodebaseSnapshot {
+    packageJson: {
+        name?: string;
+        version?: string;
+        description?: string;
+        scripts?: Record<string, string>;
+        dependencies?: Record<string, string>;
+        devDependencies?: Record<string, string>;
+        engines?: Record<string, string>;
+    } | null;
+    tsconfig: {
+        target?: string;
+        module?: string;
+        strict?: boolean;
+        paths?: Record<string, string[]>;
+    } | null;
+    directoryTree: DirectoryNode[];
+    entryPoints: Array<{
+        path: string;
+        content: string;
+    }>;
+    detectedImports: string[];
+    dependencyGraph: DependencyGraph | null;
+    readme: string | null;
+    truncated?: boolean;
+}
+export declare function extractDependencyGraph(rootDir: string, gitFiles: Set<string> | null): Promise<DependencyGraph>;
+export declare function scanCodebase(rootDir: string, maxBytes?: number): Promise<CodebaseSnapshot>;

package/dist/lib/codebase-scanner.js

@@ -0,0 +1,360 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const DEFAULT_MAX_BYTES = 15360;
+const HARDCODED_EXCLUDES = new Set(['.git', 'node_modules', 'dist', 'build', '.opentology', '.claude', '.omc']);
+const MAX_ENTRY_POINT_LINES = 150;
+const MAX_README_LINES = 100;
+async function readJsonFile(filePath) {
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function getGitTrackedFiles(rootDir) {
+    try {
+        const { stdout } = await execFileAsync('git', ['ls-files', '--cached', '--others', '--exclude-standard'], { cwd: rootDir });
+        const files = new Set();
+        for (const line of stdout.split('\n')) {
+            const trimmed = line.trim();
+            if (trimmed)
+                files.add(trimmed);
+        }
+        return files;
+    }
+    catch {
+        return null;
+    }
+}
+function isExcluded(name, gitFiles, relativePath) {
+    if (HARDCODED_EXCLUDES.has(name))
+        return true;
+    if (gitFiles !== null) {
+        // Check if any git-tracked file starts with this path
+        for (const f of gitFiles) {
+            if (f === relativePath || f.startsWith(relativePath + '/'))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+async function buildDirectoryTree(rootDir, currentDir, gitFiles, maxDepth, currentDepth = 0) {
+    if (currentDepth >= maxDepth)
+        return [];
+    let entries;
+    try {
+        entries = await readdir(currentDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const nodes = [];
+    const sorted = entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of sorted) {
+        const relPath = relative(rootDir, join(currentDir, entry.name));
+        if (isExcluded(entry.name, gitFiles, relPath))
+            continue;
+        if (entry.isDirectory()) {
+            const children = await buildDirectoryTree(rootDir, join(currentDir, entry.name), gitFiles, maxDepth, currentDepth + 1);
+            nodes.push({ name: entry.name, type: 'directory', children });
+        }
+        else if (entry.isFile()) {
+            nodes.push({ name: entry.name, type: 'file' });
+        }
+    }
+    return nodes;
+}
+async function readTruncatedFile(filePath, maxLines) {
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+        if (lines.length > maxLines) {
+            return lines.slice(0, maxLines).join('\n') + '\n... (truncated)';
+        }
+        return content;
+    }
+    catch {
+        return null;
+    }
+}
+function detectEntryPoints(pkg) {
+    const entries = [];
+    if (typeof pkg.main === 'string')
+        entries.push(pkg.main);
+    if (typeof pkg.bin === 'string') {
+        entries.push(pkg.bin);
+    }
+    else if (pkg.bin && typeof pkg.bin === 'object') {
+        entries.push(...Object.values(pkg.bin));
+    }
+    if (pkg.exports && typeof pkg.exports === 'object') {
+        const walk = (obj) => {
+            if (typeof obj === 'string') {
+                entries.push(obj);
+                return;
+            }
+            if (obj && typeof obj === 'object') {
+                for (const v of Object.values(obj))
+                    walk(v);
+            }
+        };
+        walk(pkg.exports);
+    }
+    // Deduplicate and resolve dist→src mapping for TS projects
+    const seen = new Set();
+    const result = [];
+    for (const e of entries) {
+        const normalized = e.replace(/^\.\//, '');
+        // Try source version first (dist/index.js → src/index.ts)
+        const srcVersion = normalized.replace(/^dist\//, 'src/').replace(/\.js$/, '.ts');
+        if (!seen.has(srcVersion)) {
+            seen.add(srcVersion);
+            result.push(srcVersion);
+        }
+        if (!seen.has(normalized)) {
+            seen.add(normalized);
+            result.push(normalized);
+        }
+    }
+    return result;
+}
+async function detectImports(rootDir, filePaths) {
+    const imports = new Set();
+    // Also scan up to 5 src/*.ts files
+    const scanPaths = [...filePaths];
+    try {
+        const srcEntries = await readdir(join(rootDir, 'src'), { withFileTypes: true });
+        let count = 0;
+        for (const e of srcEntries) {
+            if (count >= 5)
+                break;
+            if (e.isFile() && e.name.endsWith('.ts')) {
+                const p = `src/${e.name}`;
+                if (!scanPaths.includes(p)) {
+                    scanPaths.push(p);
+                    count++;
+                }
+            }
+        }
+    }
+    catch { /* no src dir */ }
+    for (const fp of scanPaths) {
+        try {
+            const content = await readFile(join(rootDir, fp), 'utf-8');
+            const importRegex = /(?:import|from)\s+['"]([^./'][^'"]*)['"]/g;
+            let match;
+            while ((match = importRegex.exec(content)) !== null) {
+                const pkg = match[1];
+                // Extract package name (handle scoped packages)
+                if (pkg.startsWith('@')) {
+                    const parts = pkg.split('/');
+                    if (parts.length >= 2)
+                        imports.add(`${parts[0]}/${parts[1]}`);
+                }
+                else {
+                    imports.add(pkg.split('/')[0]);
+                }
+            }
+        }
+        catch { /* skip unreadable files */ }
+    }
+    return [...imports].sort();
+}
+async function collectSourceFiles(rootDir, dir, gitFiles) {
+    const results = [];
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        const relPath = relative(rootDir, join(dir, entry.name));
+        if (isExcluded(entry.name, gitFiles, relPath))
+            continue;
+        if (entry.isDirectory()) {
+            results.push(...await collectSourceFiles(rootDir, join(dir, entry.name), gitFiles));
+        }
+        else if (entry.isFile() && /\.[tj]sx?$/.test(entry.name)) {
+            results.push(relPath);
+        }
+    }
+    return results;
+}
+const LOCAL_IMPORT_REGEX = /(?:import|export)\s+(?:(?:type\s+)?(?:\{[^}]*\}|[^'";\n]+)\s+from\s+)?['"](\.\.?\/[^'"]+)['"]/g;
+function normalizeImportPath(fromFile, importPath) {
+    const fromDir = fromFile.includes('/') ? fromFile.substring(0, fromFile.lastIndexOf('/')) : '.';
+    const parts = (fromDir === '.' ? importPath : `${fromDir}/${importPath}`).split('/');
+    const resolved = [];
+    for (const part of parts) {
+        if (part === '.')
+            continue;
+        if (part === '..') {
+            resolved.pop();
+            continue;
+        }
+        resolved.push(part);
+    }
+    let result = resolved.join('/');
+    // Strip file extension for module name
+    result = result.replace(/\.[tj]sx?$/, '').replace(/\.js$/, '');
+    return result || null;
+}
+export async function extractDependencyGraph(rootDir, gitFiles) {
+    const sourceFiles = await collectSourceFiles(rootDir, rootDir, gitFiles);
+    const moduleSet = new Set();
+    const edges = [];
+    for (const filePath of sourceFiles) {
+        const moduleName = filePath.replace(/\.[tj]sx?$/, '');
+        moduleSet.add(moduleName);
+        let content;
+        try {
+            content = await readFile(join(rootDir, filePath), 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        LOCAL_IMPORT_REGEX.lastIndex = 0;
+        let match;
+        while ((match = LOCAL_IMPORT_REGEX.exec(content)) !== null) {
+            const importPath = match[1];
+            const resolved = normalizeImportPath(filePath, importPath);
+            if (resolved) {
+                // Find the actual file (could be .ts, .tsx, /index.ts, etc.)
+                const target = sourceFiles.find(f => {
+                    const noExt = f.replace(/\.[tj]sx?$/, '');
+                    return noExt === resolved || noExt === `${resolved}/index`;
+                });
+                if (target) {
+                    const targetModule = target.replace(/\.[tj]sx?$/, '');
+                    if (targetModule !== moduleName) {
+                        edges.push({ from: moduleName, to: targetModule });
+                    }
+                }
+            }
+        }
+    }
+    // Deduplicate edges
+    const seen = new Set();
+    const uniqueEdges = edges.filter(e => {
+        const key = `${e.from}->${e.to}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    return {
+        modules: [...moduleSet].sort(),
+        edges: uniqueEdges,
+    };
+}
+function byteLength(obj) {
+    return Buffer.byteLength(JSON.stringify(obj), 'utf-8');
+}
+function applyTruncation(snapshot, maxBytes) {
+    // Stage 1: Shorten entry point contents
+    if (byteLength(snapshot) > maxBytes) {
+        snapshot.entryPoints = snapshot.entryPoints.map(ep => ({
+            path: ep.path,
+            content: ep.content.split('\n').slice(0, 50).join('\n') + '\n... (truncated)',
+        }));
+        snapshot.truncated = true;
+    }
+    // Stage 2: Trim README
+    if (byteLength(snapshot) > maxBytes && snapshot.readme) {
+        const lines = snapshot.readme.split('\n');
+        snapshot.readme = lines.slice(0, 30).join('\n') + '\n... (truncated)';
+        snapshot.truncated = true;
+    }
+    // Stage 3: Reduce tree depth to 2
+    if (byteLength(snapshot) > maxBytes) {
+        const pruneDepth = (nodes, depth) => {
+            return nodes.map(n => {
+                if (n.type === 'directory' && n.children) {
+                    if (depth >= 1)
+                        return { name: n.name, type: n.type };
+                    return { ...n, children: pruneDepth(n.children, depth + 1) };
+                }
+                return n;
+            });
+        };
+        snapshot.directoryTree = pruneDepth(snapshot.directoryTree, 0);
+        snapshot.truncated = true;
+    }
+    // Stage 4: Drop detectedImports
+    if (byteLength(snapshot) > maxBytes) {
+        snapshot.detectedImports = [];
+        snapshot.truncated = true;
+    }
+    // Stage 5: Drop dependencyGraph
+    if (byteLength(snapshot) > maxBytes) {
+        snapshot.dependencyGraph = null;
+        snapshot.truncated = true;
+    }
+    return snapshot;
+}
+export async function scanCodebase(rootDir, maxBytes = DEFAULT_MAX_BYTES) {
+    // Read package.json
+    const rawPkg = await readJsonFile(join(rootDir, 'package.json'));
+    const packageJson = rawPkg ? {
+        name: rawPkg.name,
+        version: rawPkg.version,
+        description: rawPkg.description,
+        scripts: rawPkg.scripts,
+        dependencies: rawPkg.dependencies,
+        devDependencies: rawPkg.devDependencies,
+        engines: rawPkg.engines,
+    } : null;
+    // Read tsconfig.json or jsconfig.json
+    let rawTsConfig = await readJsonFile(join(rootDir, 'tsconfig.json'));
+    if (!rawTsConfig) {
+        rawTsConfig = await readJsonFile(join(rootDir, 'jsconfig.json'));
+    }
+    const compilerOptions = rawTsConfig?.compilerOptions;
+    const tsconfig = rawTsConfig ? {
+        target: compilerOptions?.target,
+        module: compilerOptions?.module,
+        strict: compilerOptions?.strict,
+        paths: compilerOptions?.paths,
+    } : null;
+    // Get git-tracked files for gitignore awareness
+    const gitFiles = await getGitTrackedFiles(rootDir);
+    // Build directory tree (depth 3)
+    const directoryTree = await buildDirectoryTree(rootDir, rootDir, gitFiles, 3);
+    // Detect and read entry points
+    const entryPointPaths = rawPkg ? detectEntryPoints(rawPkg) : [];
+    const entryPoints = [];
+    for (const ep of entryPointPaths) {
+        const content = await readTruncatedFile(join(rootDir, ep), MAX_ENTRY_POINT_LINES);
+        if (content !== null) {
+            entryPoints.push({ path: ep, content });
+        }
+    }
+    // Detect imports
+    const detectedImports = await detectImports(rootDir, entryPointPaths);
+    // Extract dependency graph
+    const dependencyGraph = await extractDependencyGraph(rootDir, gitFiles);
+    // Read README
+    const readme = await readTruncatedFile(join(rootDir, 'README.md'), MAX_README_LINES);
+    let snapshot = {
+        packageJson,
+        tsconfig,
+        directoryTree,
+        entryPoints,
+        detectedImports,
+        dependencyGraph,
+        readme,
+    };
+    // Apply byte cap with progressive truncation
+    if (byteLength(snapshot) > maxBytes) {
+        snapshot = applyTruncation(snapshot, maxBytes);
+    }
+    return snapshot;
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,16 @@
+export interface OpenTologyConfig {
+    projectId: string;
+    mode: 'http' | 'embedded';
+    endpoint?: string;
+    graphUri: string;
+    graphs?: Record<string, string>;
+    files?: Record<string, string[]>;
+    prefixes?: Record<string, string>;
+}
+export declare function resolveGraphUri(config: OpenTologyConfig, graphName?: string): string;
+export declare function loadConfig(): OpenTologyConfig;
+export declare function saveConfig(config: OpenTologyConfig): void;
+export declare function configExists(): boolean;
+export declare function resolveEndpoint(config: OpenTologyConfig): string;
+export declare function getTrackedFiles(config: OpenTologyConfig, graphUri: string): string[];
+export declare function addTrackedFile(config: OpenTologyConfig, graphUri: string, filePath: string): void;

package/dist/lib/config.js

@@ -0,0 +1,70 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import path, { join } from 'node:path';
+export function resolveGraphUri(config, graphName) {
+    if (!graphName) {
+        return config.graphUri;
+    }
+    const uri = config.graphs?.[graphName];
+    if (!uri) {
+        throw new Error(`Unknown graph: ${graphName}. Use 'opentology graph create ${graphName}' first.`);
+    }
+    return uri;
+}
+const CONFIG_FILENAME = '.opentology.json';
+function configPath() {
+    return join(process.cwd(), CONFIG_FILENAME);
+}
+export function loadConfig() {
+    const configFilePath = configPath();
+    if (!existsSync(configFilePath)) {
+        throw new Error(`Config file not found at ${configFilePath}. Run 'opentology init' first.`);
+    }
+    try {
+        const raw = readFileSync(configFilePath, 'utf-8');
+        const config = JSON.parse(raw);
+        if (!config.mode) {
+            config.mode = 'http';
+        }
+        if (config.mode === 'http' && !config.endpoint) {
+            config.endpoint = 'http://localhost:7878';
+        }
+        return config;
+    }
+    catch (err) {
+        throw new Error(`Failed to read config file at ${configFilePath}: ${err.message}`);
+    }
+}
+export function saveConfig(config) {
+    const configFilePath = configPath();
+    try {
+        writeFileSync(configFilePath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+    }
+    catch (err) {
+        throw new Error(`Failed to write config file at ${configFilePath}: ${err.message}`);
+    }
+}
+export function configExists() {
+    return existsSync(configPath());
+}
+export function resolveEndpoint(config) {
+    if (config.endpoint)
+        return config.endpoint;
+    if (config.mode === 'embedded') {
+        throw new Error("No endpoint configured: project is in 'embedded' mode.");
+    }
+    return 'http://localhost:7878';
+}
+export function getTrackedFiles(config, graphUri) {
+    return config.files?.[graphUri] ?? [];
+}
+export function addTrackedFile(config, graphUri, filePath) {
+    if (!config.files)
+        config.files = {};
+    if (!config.files[graphUri])
+        config.files[graphUri] = [];
+    // Store relative path
+    const relative = path.relative(process.cwd(), path.resolve(filePath));
+    if (!config.files[graphUri].includes(relative)) {
+        config.files[graphUri].push(relative);
+    }
+}

package/dist/lib/embedded-adapter.d.ts

@@ -0,0 +1,45 @@
+import type { StoreAdapter, SparqlResults } from './store-adapter.js';
+export declare class EmbeddedAdapter implements StoreAdapter {
+    private store;
+    constructor();
+    /**
+     * Load Turtle data directly into a named graph.
+     */
+    loadTurtleIntoGraph(turtle: string, graphUri: string): void;
+    askQuery(query: string): Promise<boolean>;
+    sparqlQuery(query: string): Promise<SparqlResults>;
+    sparqlUpdate(update: string): Promise<void>;
+    constructQuery(query: string): Promise<string>;
+    insertTurtle(graphUri: string, turtle: string): Promise<void>;
+    getGraphTripleCount(graphUri: string): Promise<number>;
+    exportGraph(graphUri: string): Promise<string>;
+    dropGraph(graphUri: string): Promise<void>;
+    deleteTriples(graphUri: string, options: {
+        turtle?: string;
+        where?: string;
+    }): Promise<void>;
+    diffGraph(graphUri: string, localTurtle: string): Promise<{
+        added: string[];
+        removed: string[];
+        unchanged: number;
+    }>;
+    getSchemaOverview(graphUri: string): Promise<{
+        prefixes: Record<string, string>;
+        classes: string[];
+        properties: string[];
+        tripleCount: number;
+    }>;
+    getClassDetails(graphUri: string, classUri: string): Promise<{
+        classUri: string;
+        instanceCount: number;
+        properties: Array<{
+            property: string;
+            count: number;
+        }>;
+        sampleTriples: Array<{
+            s: string;
+            p: string;
+            o: string;
+        }>;
+    }>;
+}