opentology 0.2.0 → 0.2.2

package/README.md

@@ -1,6 +1,6 @@
 # OpenTology
 
-> CLI-managed RDF/SPARQL infrastructure with RDFS reasoning and SHACL validation -- Supabase for knowledge graphs
+> CLI-managed RDF/SPARQL infrastructure with RDFS reasoning, SHACL validation, and interactive graph visualization -- Supabase for knowledge graphs
 
 [English](#english) | [한국어](#한국어)
 
@@ -22,7 +22,7 @@ graph TB
     end
 
     subgraph MCP["MCP Server"]
-        Tools[18 Tools]
+        Tools[23 Tools]
         Resource["opentology://schema"]
     end
 
@@ -42,7 +42,7 @@ graph TB
     Pipeline --> Adapter
 ```
 
-Existing ontology tools have terrible developer experience. OpenTology gives you managed RDF with a simple CLI -- initialize a project, write Turtle, validate with SHACL, push with automatic RDFS inference, and query, all from your terminal. It ships an MCP server so AI assistants can manage your knowledge graph directly. It runs in embedded mode with zero Docker dependency, or connects to an Oxigraph server over HTTP.
+Existing ontology tools have terrible developer experience. OpenTology gives you managed RDF with a simple CLI -- initialize a project, write Turtle, validate with SHACL, push with automatic RDFS inference, query, and visualize your graph in an interactive web UI, all from your terminal. It ships an MCP server so AI assistants can manage your knowledge graph directly. It runs in embedded mode with zero Docker dependency, or connects to an Oxigraph server over HTTP.
 
 ### System Requirements
 
@@ -97,7 +97,7 @@ graph LR
 | Docker required | No (embedded mode) | Yes | Yes |
 | RDFS reasoning | Automatic on push | Manual SPARQL CONSTRUCT | Not native |
 | SHACL validation | Built-in | Manual tooling | N/A |
-| AI integration | MCP server with 18 tools | None | Plugin ecosystem |
+| AI integration | MCP server with 23 tools | None | Plugin ecosystem |
 | Query language | SPARQL (auto-prefixed) | SPARQL (raw) | Cypher |
 | Data format | Turtle files | Turtle/N-Triples | Property graph |
 | Project scoping | Automatic named graphs | Manual | Database-level |
@@ -106,7 +106,7 @@ graph LR
 
 **Core**
 
-- 14 CLI commands covering the full RDF lifecycle
+- 18 CLI commands covering the full RDF lifecycle
 - Project-level configuration with `.opentology.json`
 - Named graph scoping -- queries are automatically scoped to your project
 - Two modes: HTTP (Oxigraph server) and embedded (WASM, zero Docker)
@@ -126,10 +126,16 @@ graph LR
 
 **AI Integration**
 
-- MCP server with 18 tools and 1 resource
+- MCP server with 23 tools and 1 resource
 - `opentology://schema` resource auto-loads ontology overview
 - Works with Claude Code, Cursor, and any MCP-compatible client
 
+**Visualization**
+
+- Interactive graph visualization web UI (`opentology context graph`)
+- Explore classes, instances, and relationships visually with vis-network
+- SPARQL query editor, node filtering, search, and focus mode
+
 ### Two Modes
 
 | | HTTP Mode | Embedded Mode |
@@ -175,6 +181,9 @@ For embedded mode, no additional setup is needed.
 | `opentology infer` | Run RDFS materialization (`--clear` to remove inferred triples) |
 | `opentology graph` | List, create, or drop named graphs |
 | `opentology prefix` | List, add, or remove project prefixes |
+| `opentology context` | Project context management (`init`, `load`, `status`, `scan`, `impact`, `sync`, `graph`) |
+| `opentology viz` | Visualize ontology schema (`schema`) |
+| `opentology doctor` | Check project health (config, store, context, hooks, dependencies) |
 | `opentology mcp` | Start the MCP server |
 
 ### MCP Integration
@@ -192,7 +201,7 @@ Add to your MCP client configuration (`.mcp.json`):
 }
 ```
 
-**18 Tools:**
+**23 Tools:**
 
 | Tool | Description |
 |------|-------------|
@@ -210,10 +219,15 @@ Add to your MCP client configuration (`.mcp.json`):
 | `opentology_graph_list` | List named graphs |
 | `opentology_graph_create` | Create a named graph |
 | `opentology_graph_drop` | Drop a named graph |
+| `opentology_visualize` | Generate schema visualization (Mermaid/DOT) |
 | `opentology_context_init` | Initialize project context graph |
 | `opentology_context_load` | Load project context |
 | `opentology_context_status` | Check context initialization status |
 | `opentology_context_scan` | Scan codebase (module or symbol-level) |
+| `opentology_context_impact` | Analyze file modification impact (dependents, dependencies, related context) |
+| `opentology_context_sync` | Auto-sync: recover missed sessions from git, rescan module graph |
+| `opentology_context_graph` | Start interactive graph visualization web UI |
+| `opentology_doctor` | Check project health (config, store, hooks, dependencies) |
 
 **1 Resource:**
 
@@ -324,8 +338,8 @@ npm install web-tree-sitter tree-sitter-wasms
 
 ### Roadmap
 
-- [x] CLI with 14 commands
-- [x] MCP server with 18 tools and 1 resource
+- [x] CLI with 18 commands
+- [x] MCP server with 23 tools and 1 resource
 - [x] Schema introspection (MCP resource + tool)
 - [x] Complete CRUD (push --replace, drop, delete)
 - [x] SHACL validation (shape constraints on push)
@@ -338,7 +352,7 @@ npm install web-tree-sitter tree-sitter-wasms
 - [ ] OWL reasoning (owl:sameAs, owl:inverseOf)
 - [ ] Remote ontology import
 - [ ] Version control for ontology snapshots
-- [ ] Web UI for graph exploration
+- [x] Interactive graph visualization web UI
 
 ### Contributing
 
@@ -369,7 +383,7 @@ graph TB
     end
 
     subgraph MCP["MCP Server"]
-        Tools[18 Tools]
+        Tools[23 Tools]
         Resource["opentology://schema"]
     end
 
@@ -389,7 +403,7 @@ graph TB
     Pipeline --> Adapter
 ```
 
-온톨로지 도구들은 개발자 경험이 열악합니다. OpenTology는 터미널에서 RDF의 전체 생애주기를 관리합니다. 프로젝트 초기화, Turtle 작성, SHACL 검증, RDFS 추론이 포함된 푸시, SPARQL 쿼리까지 CLI 하나로 처리합니다. MCP 서버를 내장하고 있어 AI 어시스턴트가 지식 그래프를 직접 다룰 수 있고, Docker 없이 임베디드 모드로 바로 시작할 수 있습니다.
+온톨로지 도구들은 개발자 경험이 열악합니다. OpenTology는 터미널에서 RDF의 전체 생애주기를 관리합니다. 프로젝트 초기화, Turtle 작성, SHACL 검증, RDFS 추론이 포함된 푸시, SPARQL 쿼리, 인터랙티브 그래프 시각화까지 CLI 하나로 처리합니다. MCP 서버를 내장하고 있어 AI 어시스턴트가 지식 그래프를 직접 다룰 수 있고, Docker 없이 임베디드 모드로 바로 시작할 수 있습니다.
 
 ### 시스템 요구사항
 
@@ -444,7 +458,7 @@ graph LR
 | Docker 필수 | 아니오 (임베디드 모드) | 예 | 예 |
 | RDFS 추론 | 푸시 시 자동 | SPARQL CONSTRUCT 수동 작성 | 네이티브 미지원 |
 | SHACL 검증 | 내장 | 별도 도구 필요 | 해당 없음 |
-| AI 연동 | MCP 서버 18개 도구 | 없음 | 플러그인 생태계 |
+| AI 연동 | MCP 서버 23개 도구 | 없음 | 플러그인 생태계 |
 | 쿼리 언어 | SPARQL (접두사 자동 삽입) | SPARQL (수동) | Cypher |
 | 데이터 형식 | Turtle 파일 | Turtle/N-Triples | 속성 그래프 |
 | 프로젝트 구분 | Named Graph 자동 | 수동 관리 | 데이터베이스 단위 |
@@ -453,7 +467,7 @@ graph LR
 
 **핵심**
 
-- RDF 전체 생애주기를 다루는 14개 CLI 명령어
+- RDF 전체 생애주기를 다루는 18개 CLI 명령어
 - `.opentology.json` 기반 프로젝트 설정
 - Named Graph 자동 스코핑 -- 쿼리가 프로젝트 그래프에 자동 한정
 - HTTP 모드(Oxigraph 서버)와 임베디드 모드(WASM, Docker 불필요) 지원
@@ -473,10 +487,16 @@ graph LR
 
 **AI 연동**
 
-- 18개 도구와 1개 리소스를 제공하는 MCP 서버
+- 23개 도구와 1개 리소스를 제공하는 MCP 서버
 - `opentology://schema` 리소스로 온톨로지 개요 자동 로드
 - Claude Code, Cursor 등 MCP 호환 클라이언트와 연동
 
+**시각화**
+
+- 인터랙티브 그래프 시각화 웹 UI (`opentology context graph`)
+- vis-network로 클래스, 인스턴스, 관계를 시각적으로 탐색
+- SPARQL 쿼리 편집기, 노드 필터링, 검색, 포커스 모드
+
 ### 두 가지 모드
 
 | | HTTP 모드 | 임베디드 모드 |
@@ -522,6 +542,9 @@ docker run -p 7878:7878 ghcr.io/oxigraph/oxigraph \
 | `opentology infer` | RDFS 물질화 실행 (`--clear`로 추론 트리플 제거) |
 | `opentology graph` | Named Graph 목록/생성/삭제 |
 | `opentology prefix` | 프로젝트 접두사 목록/추가/제거 |
+| `opentology context` | 프로젝트 컨텍스트 관리 (`init`, `load`, `status`, `scan`, `impact`, `sync`, `graph`) |
+| `opentology viz` | 온톨로지 스키마 시각화 (`schema`) |
+| `opentology doctor` | 프로젝트 건강 진단 (설정, 스토어, 컨텍스트, 훅, 의존성) |
 | `opentology mcp` | MCP 서버 시작 |
 
 ### MCP 연동
@@ -539,7 +562,7 @@ MCP 클라이언트 설정 파일(`.mcp.json`)에 추가:
 }
 ```
 
-**18개 도구:**
+**23개 도구:**
 
 | 도구 | 설명 |
 |------|------|
@@ -557,10 +580,15 @@ MCP 클라이언트 설정 파일(`.mcp.json`)에 추가:
 | `opentology_graph_list` | Named Graph 목록 조회 |
 | `opentology_graph_create` | Named Graph 생성 |
 | `opentology_graph_drop` | Named Graph 삭제 |
+| `opentology_visualize` | 스키마 시각화 생성 (Mermaid/DOT) |
 | `opentology_context_init` | 프로젝트 컨텍스트 그래프 초기화 |
 | `opentology_context_load` | 프로젝트 컨텍스트 로드 |
 | `opentology_context_status` | 컨텍스트 초기화 상태 확인 |
 | `opentology_context_scan` | 코드베이스 스캔 (모듈/심볼 수준) |
+| `opentology_context_impact` | 파일 수정 영향 분석 (의존 모듈, 관련 컨텍스트) |
+| `opentology_context_sync` | 자동 동기화: git에서 누락 세션 복구, 모듈 그래프 재스캔 |
+| `opentology_context_graph` | 인터랙티브 그래프 시각화 웹 UI 시작 |
+| `opentology_doctor` | 프로젝트 건강 진단 (설정, 스토어, 훅, 의존성) |
 
 **1개 리소스:**
 
@@ -671,8 +699,8 @@ npm install web-tree-sitter tree-sitter-wasms
 
 ### 로드맵
 
-- [x] 14개 CLI 명령어
-- [x] 18개 도구와 1개 리소스를 갖춘 MCP 서버
+- [x] 18개 CLI 명령어
+- [x] 23개 도구와 1개 리소스를 갖춘 MCP 서버
 - [x] 스키마 조회 (MCP 리소스 + 도구)
 - [x] 완전한 CRUD (push --replace, drop, delete)
 - [x] SHACL 검증 (푸시 시 형상 제약 자동 검증)
@@ -685,7 +713,7 @@ npm install web-tree-sitter tree-sitter-wasms
 - [ ] OWL 추론 (owl:sameAs, owl:inverseOf)
 - [ ] 원격 온톨로지 임포트
 - [ ] 온톨로지 스냅샷 버전 관리
-- [ ] 그래프 탐색 웹 UI
+- [x] 인터랙티브 그래프 시각화 웹 UI
 
 ### 기여 방법
 

package/dist/commands/context.js

@@ -1,12 +1,25 @@
 import pc from 'picocolors';
-import { existsSync, mkdirSync, writeFileSync, unlinkSync, readdirSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { createInterface } from 'node:readline';
 import { loadConfig, saveConfig } from '../lib/config.js';
 import { createReadyAdapter } from '../lib/store-factory.js';
+import { startGraphServer } from '../lib/graph-server.js';
+import { syncContext } from '../lib/context-sync.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 { generatePreEditHookScript } from '../templates/pre-edit-hook.js';
 import { generateSlashCommands } from '../templates/slash-commands.js';
+function ask(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase());
+        });
+    });
+}
 export function registerContext(program) {
     const context = program
         .command('context')
@@ -86,6 +99,16 @@ export function registerContext(program) {
             else {
                 console.log(pc.dim('  Hook script already exists — skipped (use --force to regenerate)'));
             }
+            // Step 3b: Write pre-edit hook script
+            const preEditHookPath = join(hookDir, 'pre-edit.mjs');
+            if (!existsSync(preEditHookPath) || opts.force) {
+                mkdirSync(hookDir, { recursive: true });
+                writeFileSync(preEditHookPath, generatePreEditHookScript(), 'utf-8');
+                console.log(pc.green(`  Generated hook script: .opentology/hooks/pre-edit.mjs`));
+            }
+            else {
+                console.log(pc.dim('  Pre-edit hook already exists — skipped'));
+            }
             // Step 4: Update CLAUDE.md
             const claudeMdPath = join(process.cwd(), 'CLAUDE.md');
             const section = generateContextSection(config.projectId, config.graphUri);
@@ -138,18 +161,51 @@ export function registerContext(program) {
             }
             // 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:'));
+            // Step 7: Register hooks in .claude/settings.json
+            const settingsDir = join(process.cwd(), '.claude');
+            const settingsPath = join(settingsDir, 'settings.json');
+            mkdirSync(settingsDir, { recursive: true });
+            let settings = {};
+            if (existsSync(settingsPath)) {
+                try {
+                    settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+                }
+                catch { /* start fresh */ }
+            }
+            const hooks = (settings.hooks ?? {});
+            // Always register SessionStart hook
+            const sessionStartCmd = 'node .opentology/hooks/session-start.mjs';
+            if (!hooks.SessionStart)
+                hooks.SessionStart = [];
+            const hasSessionHook = hooks.SessionStart.some((h) => h.command === sessionStartCmd);
+            if (!hasSessionHook) {
+                hooks.SessionStart.push({ type: 'command', command: sessionStartCmd });
+                console.log(pc.green('  Registered SessionStart hook in .claude/settings.json'));
+            }
+            // Ask about PreToolUse impact hook
             console.log('');
-            console.log(JSON.stringify({
-                hooks: {
-                    SessionStart: [{
-                            type: 'command',
-                            command: 'node .opentology/hooks/session-start.mjs',
-                        }],
-                },
-            }, null, 2));
+            const enableImpact = await ask(pc.bold('Enable PreToolUse impact analysis hook? ') +
+                pc.dim('(auto-shows dependents before Edit/Write)') +
+                ' [Y/n] ');
+            if (enableImpact !== 'n' && enableImpact !== 'no') {
+                const preEditCmd = 'node .opentology/hooks/pre-edit.mjs';
+                if (!hooks.PreToolUse)
+                    hooks.PreToolUse = [];
+                const hasPreEditHook = hooks.PreToolUse.some((h) => h.command === preEditCmd);
+                if (!hasPreEditHook) {
+                    hooks.PreToolUse.push({
+                        type: 'command',
+                        command: preEditCmd,
+                        matcher: { tool_name: 'Edit|Write' },
+                    });
+                }
+                console.log(pc.green('  Registered PreToolUse impact hook in .claude/settings.json'));
+            }
+            else {
+                console.log(pc.dim('  Skipped PreToolUse hook registration'));
+            }
+            settings.hooks = hooks;
+            writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
             console.log('');
             console.log(pc.dim('Consider adding .opentology/hooks/ to version control so team members share the hook.'));
         }
@@ -366,4 +422,170 @@ export function registerContext(program) {
             console.log('CLAUDE.md:   ' + (hasMarkers ? pc.green('markers present') : pc.yellow('markers missing')));
         }
     });
+    // --- context impact ---
+    context
+        .command('impact')
+        .description('Analyze impact of modifying a file (dependents, dependencies, related context)')
+        .requiredOption('--file <path>', 'Relative file path to analyze')
+        .option('--format <type>', 'Output format: table, json', 'table')
+        .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 ?? {};
+        if (!graphs['context']) {
+            console.error(pc.red('Error: Context not initialized. Run `opentology context init` first.'));
+            process.exit(1);
+        }
+        const contextUri = graphs['context'];
+        const OTX = 'https://opentology.dev/vocab#';
+        const moduleUriStr = `urn:module:${opts.file}`;
+        try {
+            const adapter = await createReadyAdapter(config);
+            // Dependents (reverse deps)
+            const dependentsResult = await adapter.sparqlQuery(`
+          SELECT ?dependent WHERE {
+            GRAPH <${contextUri}> {
+              ?dependent <${OTX}dependsOn> <${moduleUriStr}> .
+            }
+          }`);
+            const dependents = (dependentsResult.results?.bindings ?? []).map((b) => b.dependent?.value?.replace('urn:module:', '') ?? '').filter(Boolean);
+            // Dependencies
+            const depsResult = await adapter.sparqlQuery(`
+          SELECT ?dep WHERE {
+            GRAPH <${contextUri}> {
+              <${moduleUriStr}> <${OTX}dependsOn> ?dep .
+            }
+          }`);
+            const dependencies = (depsResult.results?.bindings ?? []).map((b) => b.dep?.value?.replace('urn:module:', '') ?? '').filter(Boolean);
+            // Related context entries
+            let related = [];
+            try {
+                const relatedResult = await adapter.sparqlQuery(`
+            SELECT ?type ?title ?status ?date WHERE {
+              GRAPH <${contextUri}> {
+                ?s <${OTX}body> ?body .
+                ?s a ?type .
+                ?s <${OTX}title> ?title .
+                OPTIONAL { ?s <${OTX}status> ?status }
+                OPTIONAL { ?s <${OTX}date> ?date }
+                FILTER(CONTAINS(?body, "${opts.file}"))
+              }
+            } LIMIT 10`);
+                related = (relatedResult.results?.bindings ?? []).map((b) => ({
+                    type: b.type?.value?.replace(OTX, '') ?? '',
+                    title: b.title?.value ?? '',
+                    status: b.status?.value,
+                    date: b.date?.value,
+                }));
+            }
+            catch {
+                // FILTER/CONTAINS may not be supported
+            }
+            const impact = dependents.length === 0 ? 'low' : dependents.length <= 3 ? 'medium' : 'high';
+            if (opts.format === 'json') {
+                console.log(JSON.stringify({ filePath: opts.file, dependents, dependencies, related, impact }, null, 2));
+            }
+            else {
+                console.log(pc.bold(`Impact Analysis: ${opts.file}`));
+                console.log(`Impact level: ${impact === 'high' ? pc.red(impact) : impact === 'medium' ? pc.yellow(impact) : pc.green(impact)}`);
+                console.log('');
+                if (dependents.length > 0) {
+                    console.log(pc.bold(`Dependents (${dependents.length}):`));
+                    for (const d of dependents)
+                        console.log(`  ${d}`);
+                    console.log('');
+                }
+                if (dependencies.length > 0) {
+                    console.log(pc.bold(`Dependencies (${dependencies.length}):`));
+                    for (const d of dependencies)
+                        console.log(`  ${d}`);
+                    console.log('');
+                }
+                if (related.length > 0) {
+                    console.log(pc.bold('Related context:'));
+                    for (const r of related) {
+                        console.log(`  [${r.type}] ${r.title}${r.status ? ` (${r.status})` : ''}`);
+                    }
+                }
+                if (dependents.length === 0 && dependencies.length === 0) {
+                    console.log(pc.dim('No module dependencies found. Run `opentology context scan` to populate.'));
+                }
+            }
+        }
+        catch (err) {
+            console.error(pc.red(`Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    // --- context sync ---
+    context
+        .command('sync')
+        .description('Auto-sync context graph: recover missed sessions from git log, rescan module dependencies')
+        .option('--format <type>', 'Output format: table, json', 'table')
+        .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);
+        }
+        try {
+            const result = await syncContext(config, process.cwd());
+            if (opts.format === 'json') {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log(pc.bold('Context Sync'));
+                for (const action of result.actions) {
+                    console.log(`  ${pc.green('•')} ${action}`);
+                }
+            }
+        }
+        catch (err) {
+            console.error(pc.red(`Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    // --- context graph ---
+    context
+        .command('graph')
+        .description('Open interactive graph visualization in the browser')
+        .option('--port <number>', 'Server port (default: auto)', parseInt)
+        .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 ?? {};
+        if (!graphs['context']) {
+            console.error(pc.red('Error: Context not initialized. Run `opentology context init` first.'));
+            process.exit(1);
+        }
+        try {
+            const { port } = await startGraphServer({ port: opts.port });
+            const url = `http://localhost:${port}`;
+            console.log(pc.green(`Graph server running at ${url}`));
+            // Open browser
+            const { exec } = await import('node:child_process');
+            const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+            exec(`${cmd} ${url}`);
+            console.log(pc.dim('Press Ctrl+C to stop the server.'));
+        }
+        catch (err) {
+            console.error(pc.red(`Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
 }

package/dist/commands/doctor.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+interface CheckResult {
+    name: string;
+    status: 'ok' | 'warn' | 'fail';
+    message: string;
+}
+export declare function runDoctor(): Promise<CheckResult[]>;
+export declare function registerDoctor(program: Command): void;
+export {};

package/dist/commands/doctor.js

@@ -0,0 +1,132 @@
+import pc from 'picocolors';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { configExists, loadConfig } from '../lib/config.js';
+import { createReadyAdapter } from '../lib/store-factory.js';
+export async function runDoctor() {
+    const results = [];
+    // 1. Config check
+    if (!configExists()) {
+        results.push({ name: 'Config', status: 'fail', message: 'No .opentology.json found. Run `opentology init` first.' });
+        return results; // Can't proceed without config
+    }
+    const config = loadConfig();
+    results.push({ name: 'Config', status: 'ok', message: `Project: ${config.projectId} (${config.mode} mode)` });
+    // 2. Store connectivity
+    try {
+        const adapter = await createReadyAdapter(config);
+        const r = await adapter.sparqlQuery(`SELECT (COUNT(*) AS ?c) WHERE { GRAPH <${config.graphUri}> { ?s ?p ?o } }`);
+        const count = r.results?.bindings?.[0]?.c?.value ?? '0';
+        results.push({ name: 'Store', status: 'ok', message: `Connected — ${count} triples in default graph` });
+    }
+    catch (err) {
+        results.push({ name: 'Store', status: 'fail', message: `Cannot connect: ${err.message}` });
+    }
+    // 3. Context initialization
+    const graphs = config.graphs ?? {};
+    if (graphs['context'] && graphs['sessions']) {
+        results.push({ name: 'Context', status: 'ok', message: `context: ${graphs['context']}` });
+    }
+    else {
+        results.push({ name: 'Context', status: 'warn', message: 'Not initialized. Run `opentology context init`.' });
+    }
+    // 4. Hook scripts
+    const hookDir = join(process.cwd(), '.opentology', 'hooks');
+    const sessionHook = join(hookDir, 'session-start.mjs');
+    const preEditHook = join(hookDir, 'pre-edit.mjs');
+    const hooksExist = existsSync(sessionHook) && existsSync(preEditHook);
+    if (hooksExist) {
+        results.push({ name: 'Hooks', status: 'ok', message: 'session-start.mjs + pre-edit.mjs present' });
+    }
+    else {
+        results.push({ name: 'Hooks', status: 'warn', message: 'Hook scripts missing. Run `opentology context init`.' });
+    }
+    // 5. Hook registration in .claude/settings.json
+    const settingsPath = join(process.cwd(), '.claude', 'settings.json');
+    if (existsSync(settingsPath)) {
+        try {
+            const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+            const hooks = settings.hooks ?? {};
+            const hasSession = (hooks.SessionStart ?? []).some((h) => h.command?.includes('session-start.mjs'));
+            const hasPreEdit = (hooks.PreToolUse ?? []).some((h) => h.command?.includes('pre-edit.mjs'));
+            if (hasSession && hasPreEdit) {
+                results.push({ name: 'Settings', status: 'ok', message: 'Both hooks registered in .claude/settings.json' });
+            }
+            else {
+                const missing = [];
+                if (!hasSession)
+                    missing.push('SessionStart');
+                if (!hasPreEdit)
+                    missing.push('PreToolUse');
+                results.push({ name: 'Settings', status: 'warn', message: `Missing hooks: ${missing.join(', ')}. Run \`opentology context init\`.` });
+            }
+        }
+        catch {
+            results.push({ name: 'Settings', status: 'warn', message: 'Cannot parse .claude/settings.json' });
+        }
+    }
+    else {
+        results.push({ name: 'Settings', status: 'warn', message: 'No .claude/settings.json found. Run `opentology context init`.' });
+    }
+    // 6. CLAUDE.md
+    const claudeMdPath = join(process.cwd(), 'CLAUDE.md');
+    if (existsSync(claudeMdPath)) {
+        const content = readFileSync(claudeMdPath, 'utf-8');
+        if (content.includes('OPENTOLOGY:CONTEXT:BEGIN') || content.includes('OpenTology')) {
+            results.push({ name: 'CLAUDE.md', status: 'ok', message: 'Context section present' });
+        }
+        else {
+            results.push({ name: 'CLAUDE.md', status: 'warn', message: 'Exists but no OpenTology context section' });
+        }
+    }
+    else {
+        results.push({ name: 'CLAUDE.md', status: 'warn', message: 'Not found. Run `opentology context init`.' });
+    }
+    // 7. Optional dependencies
+    const optDeps = [
+        { name: 'ts-morph', desc: 'TypeScript deep scan' },
+        { name: 'web-tree-sitter', desc: 'Multi-language deep scan' },
+    ];
+    for (const dep of optDeps) {
+        try {
+            await import(dep.name);
+            results.push({ name: dep.name, status: 'ok', message: dep.desc });
+        }
+        catch {
+            results.push({ name: dep.name, status: 'warn', message: `Not installed (optional — ${dep.desc})` });
+        }
+    }
+    return results;
+}
+export function registerDoctor(program) {
+    program
+        .command('doctor')
+        .description('Check project health: config, store, context, hooks, dependencies')
+        .option('--format <type>', 'Output format: table, json', 'table')
+        .action(async (opts) => {
+        const results = await runDoctor();
+        if (opts.format === 'json') {
+            console.log(JSON.stringify(results, null, 2));
+            return;
+        }
+        console.log(pc.bold('\nOpenTology Doctor\n'));
+        for (const r of results) {
+            const icon = r.status === 'ok' ? pc.green('✓') : r.status === 'warn' ? pc.yellow('!') : pc.red('✗');
+            const msg = r.status === 'fail' ? pc.red(r.message) : r.status === 'warn' ? pc.yellow(r.message) : r.message;
+            console.log(`  ${icon} ${pc.bold(r.name)}: ${msg}`);
+        }
+        const fails = results.filter((r) => r.status === 'fail').length;
+        const warns = results.filter((r) => r.status === 'warn').length;
+        console.log('');
+        if (fails > 0) {
+            console.log(pc.red(`  ${fails} error(s), ${warns} warning(s)`));
+            process.exit(1);
+        }
+        else if (warns > 0) {
+            console.log(pc.yellow(`  ${warns} warning(s), everything else looks good`));
+        }
+        else {
+            console.log(pc.green('  All checks passed!'));
+        }
+    });
+}

package/dist/index.js

@@ -16,10 +16,11 @@ import { registerInfer } from './commands/infer.js';
 import { registerPrefix } from './commands/prefix.js';
 import { registerContext } from './commands/context.js';
 import { registerViz } from './commands/viz.js';
+import { registerDoctor } from './commands/doctor.js';
 const program = new Command();
 program
     .name('opentology')
-    .version('0.1.0')
+    .version('0.2.2')
     .description('CLI-managed RDF/SPARQL infrastructure — Supabase for RDF');
 registerInit(program);
 registerValidate(program);
@@ -37,4 +38,5 @@ registerInfer(program);
 registerPrefix(program);
 registerContext(program);
 registerViz(program);
+registerDoctor(program);
 program.parse(process.argv);

package/dist/lib/context-sync.d.ts

@@ -0,0 +1,15 @@
+import { OpenTologyConfig } from './config.js';
+export interface SyncResult {
+    sessionsRecovered: number;
+    modulesUpdated: boolean;
+    moduleStats: {
+        modules: number;
+        edges: number;
+    } | null;
+    actions: string[];
+}
+/**
+ * Core sync logic: recover missed sessions and rescan modules.
+ * Persists via .ttl files for embedded mode compatibility.
+ */
+export declare function syncContext(config: OpenTologyConfig, projectRoot: string): Promise<SyncResult>;