opentology 0.2.1 → 0.2.2

package/README.md

@@ -22,7 +22,7 @@ graph TB
     end
 
     subgraph MCP["MCP Server"]
-        Tools[20 Tools]
+        Tools[23 Tools]
         Resource["opentology://schema"]
     end
 
@@ -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 20 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**
 
-- 16 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,7 +126,7 @@ graph LR
 
 **AI Integration**
 
-- MCP server with 20 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
 
@@ -181,8 +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`, `graph`) |
+| `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
@@ -200,7 +201,7 @@ Add to your MCP client configuration (`.mcp.json`):
 }
 ```
 
-**20 Tools:**
+**23 Tools:**
 
 | Tool | Description |
 |------|-------------|
@@ -223,7 +224,10 @@ Add to your MCP client configuration (`.mcp.json`):
 | `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:**
 
@@ -334,8 +338,8 @@ npm install web-tree-sitter tree-sitter-wasms
 
 ### Roadmap
 
-- [x] CLI with 16 commands
-- [x] MCP server with 20 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)
@@ -379,7 +383,7 @@ graph TB
     end
 
     subgraph MCP["MCP Server"]
-        Tools[20 Tools]
+        Tools[23 Tools]
         Resource["opentology://schema"]
     end
 
@@ -454,7 +458,7 @@ graph LR
 | Docker 필수 | 아니오 (임베디드 모드) | 예 | 예 |
 | RDFS 추론 | 푸시 시 자동 | SPARQL CONSTRUCT 수동 작성 | 네이티브 미지원 |
 | SHACL 검증 | 내장 | 별도 도구 필요 | 해당 없음 |
-| AI 연동 | MCP 서버 20개 도구 | 없음 | 플러그인 생태계 |
+| AI 연동 | MCP 서버 23개 도구 | 없음 | 플러그인 생태계 |
 | 쿼리 언어 | SPARQL (접두사 자동 삽입) | SPARQL (수동) | Cypher |
 | 데이터 형식 | Turtle 파일 | Turtle/N-Triples | 속성 그래프 |
 | 프로젝트 구분 | Named Graph 자동 | 수동 관리 | 데이터베이스 단위 |
@@ -463,7 +467,7 @@ graph LR
 
 **핵심**
 
-- RDF 전체 생애주기를 다루는 16개 CLI 명령어
+- RDF 전체 생애주기를 다루는 18개 CLI 명령어
 - `.opentology.json` 기반 프로젝트 설정
 - Named Graph 자동 스코핑 -- 쿼리가 프로젝트 그래프에 자동 한정
 - HTTP 모드(Oxigraph 서버)와 임베디드 모드(WASM, Docker 불필요) 지원
@@ -483,7 +487,7 @@ graph LR
 
 **AI 연동**
 
-- 20개 도구와 1개 리소스를 제공하는 MCP 서버
+- 23개 도구와 1개 리소스를 제공하는 MCP 서버
 - `opentology://schema` 리소스로 온톨로지 개요 자동 로드
 - Claude Code, Cursor 등 MCP 호환 클라이언트와 연동
 
@@ -538,8 +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`, `graph`) |
+| `opentology context` | 프로젝트 컨텍스트 관리 (`init`, `load`, `status`, `scan`, `impact`, `sync`, `graph`) |
 | `opentology viz` | 온톨로지 스키마 시각화 (`schema`) |
+| `opentology doctor` | 프로젝트 건강 진단 (설정, 스토어, 컨텍스트, 훅, 의존성) |
 | `opentology mcp` | MCP 서버 시작 |
 
 ### MCP 연동
@@ -557,7 +562,7 @@ MCP 클라이언트 설정 파일(`.mcp.json`)에 추가:
 }
 ```
 
-**20개 도구:**
+**23개 도구:**
 
 | 도구 | 설명 |
 |------|------|
@@ -580,7 +585,10 @@ MCP 클라이언트 설정 파일(`.mcp.json`)에 추가:
 | `opentology_context_load` | 프로젝트 컨텍스트 로드 |
 | `opentology_context_status` | 컨텍스트 초기화 상태 확인 |
 | `opentology_context_scan` | 코드베이스 스캔 (모듈/심볼 수준) |
+| `opentology_context_impact` | 파일 수정 영향 분석 (의존 모듈, 관련 컨텍스트) |
+| `opentology_context_sync` | 자동 동기화: git에서 누락 세션 복구, 모듈 그래프 재스캔 |
 | `opentology_context_graph` | 인터랙티브 그래프 시각화 웹 UI 시작 |
+| `opentology_doctor` | 프로젝트 건강 진단 (설정, 스토어, 훅, 의존성) |
 
 **1개 리소스:**
 
@@ -691,8 +699,8 @@ npm install web-tree-sitter tree-sitter-wasms
 
 ### 로드맵
 
-- [x] 16개 CLI 명령어
-- [x] 20개 도구와 1개 리소스를 갖춘 MCP 서버
+- [x] 18개 CLI 명령어
+- [x] 23개 도구와 1개 리소스를 갖춘 MCP 서버
 - [x] 스키마 조회 (MCP 리소스 + 도구)
 - [x] 완전한 CRUD (push --replace, drop, delete)
 - [x] SHACL 검증 (푸시 시 형상 제약 자동 검증)

package/dist/commands/context.js

@@ -1,13 +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')
@@ -87,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);
@@ -139,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.'));
         }
@@ -367,6 +422,138 @@ 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')

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>;

package/dist/lib/context-sync.js

@@ -0,0 +1,229 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { addTrackedFile, saveConfig } from './config.js';
+import { createReadyAdapter } from './store-factory.js';
+import { extractDependencyGraph } from './codebase-scanner.js';
+const OTX = 'https://opentology.dev/vocab#';
+const XSD = 'http://www.w3.org/2001/XMLSchema#';
+/**
+ * Get the most recent session date from the sessions graph.
+ * Returns ISO date string (YYYY-MM-DD) or null if no sessions exist.
+ */
+async function getLastSessionDate(adapter, sessionsUri) {
+    const r = await adapter.sparqlQuery(`
+    SELECT ?date WHERE {
+      GRAPH <${sessionsUri}> {
+        ?s a <${OTX}Session> ; <${OTX}date> ?date .
+      }
+    } ORDER BY DESC(?date) LIMIT 1
+  `);
+    const binding = r.results?.bindings?.[0];
+    return binding?.date?.value ?? null;
+}
+/**
+ * Get git commits since a given date, grouped by date.
+ * Returns map of date -> commit messages.
+ */
+function getCommitsSince(projectRoot, sinceDate) {
+    const dateMap = new Map();
+    try {
+        const args = ['log', '--format=%ad|%s', '--date=short'];
+        if (sinceDate) {
+            args.push(`--after=${sinceDate}`);
+        }
+        else {
+            args.push('--since=7 days ago');
+        }
+        const output = execFileSync('git', args, {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        if (!output)
+            return dateMap;
+        for (const line of output.split('\n')) {
+            const sepIdx = line.indexOf('|');
+            if (sepIdx === -1)
+                continue;
+            const date = line.slice(0, sepIdx).trim();
+            const msg = line.slice(sepIdx + 1).trim();
+            if (!date || !msg)
+                continue;
+            if (!dateMap.has(date))
+                dateMap.set(date, []);
+            dateMap.get(date).push(msg);
+        }
+    }
+    catch {
+        // git not available or not a repo
+    }
+    return dateMap;
+}
+/**
+ * Check if any source files changed since a given date.
+ */
+function hasSourceChanges(projectRoot, sinceDate) {
+    if (!sinceDate)
+        return true;
+    try {
+        const output = execFileSync('git', [
+            'log', '--oneline', `--after=${sinceDate}`,
+            '--', '*.ts', '*.js', '*.tsx', '*.jsx', '*.py', '*.go', '*.rs', '*.java', '*.swift',
+        ], {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return output.length > 0;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Generate Turtle content for auto-recovered sessions.
+ */
+function generateSessionTurtle(commitsByDate) {
+    const lines = [
+        `@prefix otx: <${OTX}> .`,
+        `@prefix xsd: <${XSD}> .`,
+        '',
+    ];
+    for (const [date, messages] of commitsByDate) {
+        const title = messages.length === 1
+            ? messages[0]
+            : `${messages.length} commits`;
+        const body = messages.join('\n');
+        const uri = `urn:session:${date}-auto`;
+        lines.push(`<${uri}> a otx:Session ;`);
+        lines.push(`    otx:title "${escapeTurtle(title)}" ;`);
+        lines.push(`    otx:date "${date}"^^xsd:date ;`);
+        lines.push(`    otx:body "${escapeTurtle(body)}" .`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Generate Turtle content for module dependency graph.
+ */
+function generateModuleTurtle(modules, edges) {
+    const lines = [
+        `@prefix otx: <${OTX}> .`,
+        '',
+    ];
+    for (const mod of modules) {
+        lines.push(`<urn:module:${mod}> a otx:Module .`);
+    }
+    lines.push('');
+    for (const edge of edges) {
+        lines.push(`<urn:module:${edge.from}> otx:dependsOn <urn:module:${edge.to}> .`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Core sync logic: recover missed sessions and rescan modules.
+ * Persists via .ttl files for embedded mode compatibility.
+ */
+export async function syncContext(config, projectRoot) {
+    const graphs = config.graphs ?? {};
+    const contextUri = graphs['context'];
+    const sessionsUri = graphs['sessions'];
+    if (!contextUri || !sessionsUri) {
+        throw new Error('Context not initialized. Run `opentology context init` first.');
+    }
+    const adapter = await createReadyAdapter(config);
+    const actions = [];
+    let sessionsRecovered = 0;
+    let modulesUpdated = false;
+    let moduleStats = null;
+    const syncDir = join(projectRoot, '.opentology', 'sync');
+    mkdirSync(syncDir, { recursive: true });
+    // === Step 1: Recover missed sessions from git log ===
+    const lastDate = await getLastSessionDate(adapter, sessionsUri);
+    const commitsByDate = getCommitsSince(projectRoot, lastDate);
+    if (commitsByDate.size > 0) {
+        const turtle = generateSessionTurtle(commitsByDate);
+        const sessionsFile = join(syncDir, 'auto-sessions.ttl');
+        // Append to existing auto-sessions file or create new
+        if (existsSync(sessionsFile)) {
+            const existing = readFileSync(sessionsFile, 'utf-8');
+            // Only add new sessions (check URIs)
+            const newEntries = [];
+            for (const [date] of commitsByDate) {
+                const uri = `urn:session:${date}-auto`;
+                if (!existing.includes(uri)) {
+                    newEntries.push(date);
+                }
+            }
+            if (newEntries.length > 0) {
+                const newMap = new Map();
+                for (const date of newEntries) {
+                    newMap.set(date, commitsByDate.get(date));
+                }
+                if (newMap.size > 0) {
+                    const newTurtle = generateSessionTurtle(newMap);
+                    // Remove prefix lines from appended content
+                    const body = newTurtle.split('\n').filter(l => !l.startsWith('@prefix') && l.trim() !== '').join('\n');
+                    writeFileSync(sessionsFile, existing.trimEnd() + '\n\n' + body + '\n', 'utf-8');
+                    await adapter.insertTurtle(sessionsUri, newTurtle);
+                    sessionsRecovered = newMap.size;
+                }
+            }
+        }
+        else {
+            writeFileSync(sessionsFile, turtle, 'utf-8');
+            await adapter.insertTurtle(sessionsUri, turtle);
+            sessionsRecovered = commitsByDate.size;
+        }
+        if (sessionsRecovered > 0) {
+            // Track the file for embedded persistence
+            const relPath = '.opentology/sync/auto-sessions.ttl';
+            addTrackedFile(config, sessionsUri, relPath);
+            const totalCommits = [...commitsByDate.values()].reduce((s, m) => s + m.length, 0);
+            actions.push(`Recovered ${sessionsRecovered} session(s) from ${totalCommits} git commit(s)`);
+        }
+        else {
+            actions.push('No missed sessions to recover');
+        }
+    }
+    else {
+        actions.push('No missed sessions to recover');
+    }
+    // === Step 2: Rescan module dependency graph if source files changed ===
+    const shouldRescan = hasSourceChanges(projectRoot, lastDate);
+    if (shouldRescan) {
+        try {
+            const dg = await extractDependencyGraph(projectRoot, null);
+            if (dg.modules.length > 0) {
+                const turtle = generateModuleTurtle(dg.modules, dg.edges);
+                const modulesFile = join(syncDir, 'modules.ttl');
+                // Replace modules file entirely (fresh scan)
+                writeFileSync(modulesFile, turtle, 'utf-8');
+                // Drop old module triples, then insert fresh
+                await adapter.sparqlUpdate(`DELETE { GRAPH <${contextUri}> { ?s ?p ?o } } WHERE { GRAPH <${contextUri}> { ?s a <${OTX}Module> . ?s ?p ?o } }`);
+                await adapter.sparqlUpdate(`DELETE { GRAPH <${contextUri}> { ?s <${OTX}dependsOn> ?o } } WHERE { GRAPH <${contextUri}> { ?s <${OTX}dependsOn> ?o } }`);
+                await adapter.insertTurtle(contextUri, turtle);
+                const relPath = '.opentology/sync/modules.ttl';
+                addTrackedFile(config, contextUri, relPath);
+                moduleStats = { modules: dg.modules.length, edges: dg.edges.length };
+                modulesUpdated = true;
+                actions.push(`Rescanned modules: ${dg.modules.length} modules, ${dg.edges.length} edges`);
+            }
+        }
+        catch {
+            actions.push('Module rescan failed (non-fatal)');
+        }
+    }
+    else {
+        actions.push('No source changes detected — module rescan skipped');
+    }
+    // Save config with tracked files
+    saveConfig(config);
+    return { sessionsRecovered, modulesUpdated, moduleStats, actions };
+}
+function escapeTurtle(s) {
+    return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+}

package/dist/lib/graph-server.js

@@ -70,8 +70,9 @@ function html(config) {
   <div id="app">
     <div id="sidebar">
       <h1>OpenTology — ${projectId}</h1>
-      <div id="graph-list">
-        <select id="graphSelect"><option value="">Loading graphs...</option></select>
+      <div id="graph-list" style="display:flex;gap:6px;align-items:center;">
+        <select id="graphSelect" style="flex:1;"><option value="">Loading graphs...</option></select>
+        <button id="refreshBtn" onclick="refreshAll()" title="Refresh graph data" style="padding:5px 10px;background:#0550ae;color:#fff;border:none;border-radius:6px;cursor:pointer;font-size:12px;white-space:nowrap;">&#8635; Refresh</button>
       </div>
       <div class="stats" id="stats"></div>
       <div id="query-box">
@@ -189,6 +190,30 @@ function html(config) {
       loadGraph(sel.value);
     }
 
+    async function refreshAll() {
+      const btn = document.getElementById('refreshBtn');
+      btn.textContent = '\\u21bb ...';
+      btn.disabled = true;
+      try {
+        const gs = await fetch('/api/graphs').then(r => r.json());
+        const sel = document.getElementById('graphSelect');
+        const prev = sel.value;
+        sel.innerHTML = '';
+        for (const g of gs) {
+          sel.innerHTML += '<option value="' + g.uri + '"' + (g.uri === prev ? ' selected' : '') + '>' + g.name + ' (' + g.triples + ')</option>';
+        }
+        try {
+          const schema = await fetch('/api/schema').then(r => r.json());
+          classSet = new Set();
+          (schema.classes || []).forEach(c => classSet.add(c));
+        } catch {}
+        await runQuery();
+      } finally {
+        btn.innerHTML = '&#8635; Refresh';
+        btn.disabled = false;
+      }
+    }
+
     async function loadGraph(graphUri) {
       const q = graphUri
         ? 'SELECT ?s ?p ?o WHERE { GRAPH <' + graphUri + '> { ?s ?p ?o } } LIMIT 500'

package/dist/mcp/server.js

@@ -10,12 +10,15 @@ import { validateTurtle } from '../lib/validator.js';
 import { discoverShapes, validateWithShacl, hasShapes } from '../lib/shacl.js';
 import { materializeInferences, clearInferences } from '../lib/reasoner.js';
 import { fromSchemaData, toMermaid, toDot } from '../lib/visualizer.js';
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 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';
+import { runDoctor } from '../commands/doctor.js';
+import { syncContext } from '../lib/context-sync.js';
 import { scanCodebase } from '../lib/codebase-scanner.js';
 import { startGraphServer } from '../lib/graph-server.js';
 export const MAX_TRIPLES_PER_PUSH = 100;
@@ -337,14 +340,39 @@ async function handleContextScan(args) {
                 : 'Deep scan completed but triple push failed. Use push manually with the generated triples.',
         };
     }
-    // Default: module-level scan (existing behavior)
+    // Default: module-level scan — now auto-pushes module triples like context_init
     const maxBytes = args.maxSnapshotBytes ?? 15360;
     const snapshot = await scanCodebase(process.cwd(), maxBytes);
+    let moduleStats = null;
+    try {
+        const config = loadConfig();
+        const contextUri = `${config.graphUri}/context`;
+        const adapter = await createReadyAdapter(config);
+        if (snapshot.dependencyGraph && snapshot.dependencyGraph.modules.length > 0) {
+            const dg = snapshot.dependencyGraph;
+            // Scoped delete: clear stale module triples before re-insert
+            await adapter.sparqlUpdate(`DELETE WHERE { GRAPH <${contextUri}> { ?m a <https://opentology.dev/vocab#Module> . ?m ?p ?o } }`);
+            // Insert fresh triples
+            const sparqlTriples = [];
+            for (const mod of dg.modules) {
+                sparqlTriples.push(`<urn:module:${mod}> a <https://opentology.dev/vocab#Module> .`);
+            }
+            for (const edge of dg.edges) {
+                sparqlTriples.push(`<urn:module:${edge.from}> <https://opentology.dev/vocab#dependsOn> <urn:module:${edge.to}> .`);
+            }
+            await adapter.sparqlUpdate(`INSERT DATA { GRAPH <${contextUri}> {\n${sparqlTriples.join('\n')}\n} }`);
+            moduleStats = { modules: dg.modules.length, edges: dg.edges.length };
+        }
+    }
+    catch {
+        // Non-fatal: module triple push is best-effort
+    }
     return {
         codebaseSnapshot: snapshot,
-        _hint: snapshot.dependencyGraph && snapshot.dependencyGraph.modules.length > 0
-            ? 'Analyze codebaseSnapshot and push Knowledge triples via push. Module dependency triples (otx:Module + otx:dependsOn) are available in dependencyGraph — push them to the context graph as-is.'
-            : 'Analyze codebaseSnapshot and push Knowledge triples via push. No dependency graph was auto-extracted (non-JS/TS project or parsing issue). Inspect key source files manually and push otx:Module + otx:dependsOn triples for the important modules you identify.',
+        moduleStats,
+        _hint: moduleStats
+            ? `Module triples auto-pushed: ${moduleStats.modules} modules, ${moduleStats.edges} edges. Query with: SELECT ?m WHERE { ?m a otx:Module }`
+            : 'No dependency graph auto-extracted or push failed. Inspect key source files manually.',
     };
 }
 async function handleContextInit(args) {
@@ -388,6 +416,13 @@ async function handleContextInit(args) {
         writeFileSync(hookPath, generateHookScript(), 'utf-8');
         actions.push('Generated hook: .opentology/hooks/session-start.mjs');
     }
+    // Generate pre-edit hook script
+    const preEditHookPath = join(hookDir, 'pre-edit.mjs');
+    if (!existsSync(preEditHookPath) || force) {
+        mkdirSync(hookDir, { recursive: true });
+        writeFileSync(preEditHookPath, generatePreEditHookScript(), 'utf-8');
+        actions.push('Generated hook: .opentology/hooks/pre-edit.mjs');
+    }
     // Update CLAUDE.md
     const claudeMdPath = join(process.cwd(), 'CLAUDE.md');
     const section = generateContextSection(config.projectId, config.graphUri);
@@ -415,6 +450,44 @@ async function handleContextInit(args) {
         actions.push(`Generated ${slashCreated} slash commands in .claude/commands/`);
     }
     saveConfig(config);
+    // Auto-register hooks in .claude/settings.json (non-interactive, both hooks)
+    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 ?? {});
+    let hooksChanged = false;
+    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 });
+        hooksChanged = true;
+    }
+    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' },
+        });
+        hooksChanged = true;
+    }
+    if (hooksChanged) {
+        settings.hooks = hooks;
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+        actions.push('Auto-registered hooks in .claude/settings.json');
+    }
     // Auto-push Module triples from dependency graph
     let moduleStats = null;
     try {
@@ -448,14 +521,7 @@ async function handleContextInit(args) {
         actions,
         moduleStats,
         dependencyHint,
-        hookSnippet: {
-            hooks: {
-                SessionStart: [{
-                        type: 'command',
-                        command: 'node .opentology/hooks/session-start.mjs',
-                    }],
-            },
-        },
+        hooksAutoInstalled: hooksChanged,
     };
 }
 async function handleContextLoad() {
@@ -553,6 +619,71 @@ async function handleContextLoad() {
         delete output.warnings;
     return output;
 }
+async function handleContextImpact(args) {
+    const filePath = args.filePath;
+    if (!filePath)
+        throw new Error('filePath is required');
+    const config = loadConfig();
+    const contextUri = `${config.graphUri}/context`;
+    const adapter = await createReadyAdapter(config);
+    const OTX = 'https://opentology.dev/vocab#';
+    const moduleUriStr = `urn:module:${filePath}`;
+    // 1. Modules that depend on this file (dependents / reverse deps)
+    const dependentsQuery = `
+    SELECT ?dependent WHERE {
+      GRAPH <${contextUri}> {
+        ?dependent <${OTX}dependsOn> <${moduleUriStr}> .
+      }
+    }`;
+    const dependentsResult = await adapter.sparqlQuery(dependentsQuery);
+    const dependents = (dependentsResult.results?.bindings ?? []).map((b) => b.dependent?.value?.replace('urn:module:', '') ?? '').filter(Boolean);
+    // 2. Modules this file depends on (dependencies)
+    const depsQuery = `
+    SELECT ?dep WHERE {
+      GRAPH <${contextUri}> {
+        <${moduleUriStr}> <${OTX}dependsOn> ?dep .
+      }
+    }`;
+    const depsResult = await adapter.sparqlQuery(depsQuery);
+    const dependencies = (depsResult.results?.bindings ?? []).map((b) => b.dep?.value?.replace('urn:module:', '') ?? '').filter(Boolean);
+    // 3. Related decisions, issues, knowledge mentioning this file
+    const relatedQuery = `
+    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, "${filePath}"))
+      }
+    } LIMIT 10`;
+    let related = [];
+    try {
+        const relatedResult = await adapter.sparqlQuery(relatedQuery);
+        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 — skip gracefully
+    }
+    const hasDeps = dependents.length > 0 || dependencies.length > 0;
+    return {
+        filePath,
+        moduleUri: moduleUriStr,
+        dependents,
+        dependencies,
+        related,
+        impact: dependents.length === 0 ? 'low' : dependents.length <= 3 ? 'medium' : 'high',
+        _hint: hasDeps
+            ? `This file has ${dependents.length} dependent(s) and ${dependencies.length} dependency(ies). Review dependents before making breaking changes.`
+            : 'No module dependencies found in the graph. Run context_scan first to populate module triples.',
+    };
+}
 async function handleContextStatus() {
     const config = loadConfig();
     const graphs = config.graphs ?? {};
@@ -1063,6 +1194,36 @@ export async function startMcpServer() {
                     },
                 },
             },
+            {
+                name: 'context_impact',
+                description: 'Analyze the impact of modifying a file. Returns modules that depend on the target, modules it depends on, and related decisions/issues/knowledge from the context graph. Use this BEFORE editing files to understand the blast radius of changes.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        filePath: {
+                            type: 'string',
+                            description: 'Relative file path to analyze (e.g., "src/lib/store-factory.ts")',
+                        },
+                    },
+                    required: ['filePath'],
+                },
+            },
+            {
+                name: 'context_sync',
+                description: 'Auto-sync context graph: recover missed sessions from git log and rescan module dependency graph. Call this at session start to ensure the graph is up to date. Idempotent — safe to call multiple times.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'doctor',
+                description: 'Check project health: config, store connectivity, context initialization, hook scripts, Claude Code settings, and optional dependencies. Returns a list of checks with ok/warn/fail status.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
         ],
     }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -1133,6 +1294,15 @@ export async function startMcpServer() {
                     result = { url: `http://localhost:${srv.port}`, port: srv.port, message: `Graph server running at http://localhost:${srv.port}` };
                     break;
                 }
+                case 'context_impact':
+                    result = await handleContextImpact(args);
+                    break;
+                case 'context_sync':
+                    result = await syncContext(loadConfig(), process.cwd());
+                    break;
+                case 'doctor':
+                    result = await runDoctor();
+                    break;
                 default:
                     throw new Error(`Unknown tool: ${name}`);
             }

package/dist/templates/pre-edit-hook.d.ts

@@ -0,0 +1 @@
+export declare function generatePreEditHookScript(): string;

package/dist/templates/pre-edit-hook.js

@@ -0,0 +1,101 @@
+export function generatePreEditHookScript() {
+    return `#!/usr/bin/env node
+// Generated by: opentology context init
+// PreToolUse hook — queries impact analysis before Edit/Write
+import { existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { join, resolve, dirname } from 'node:path';
+
+const TIMEOUT = parseInt(process.env.OPENTOLOGY_HOOK_TIMEOUT || '3000', 10);
+
+function findProjectRoot(startDir) {
+  let dir = resolve(startDir);
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, '.opentology.json'))) return dir;
+    dir = dirname(dir);
+  }
+  return null;
+}
+
+function findBin(projectRoot) {
+  const local = join(projectRoot, 'node_modules', '.bin', 'opentology');
+  if (existsSync(local)) return { bin: local, args: [] };
+  return { bin: 'npx', args: ['opentology'] };
+}
+
+function run(projectRoot, cmdArgs) {
+  const { bin, args } = findBin(projectRoot);
+  return execFileSync(bin, [...args, ...cmdArgs], {
+    cwd: projectRoot,
+    timeout: TIMEOUT,
+    encoding: 'utf-8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+}
+
+try {
+  const projectRoot = findProjectRoot(process.cwd());
+  if (!projectRoot) process.exit(0);
+
+  // Parse tool input from stdin (Claude Code passes JSON via stdin for hooks)
+  let input = '';
+  try {
+    input = require('fs').readFileSync('/dev/stdin', 'utf-8');
+  } catch {
+    process.exit(0);
+  }
+
+  let toolInput;
+  try {
+    toolInput = JSON.parse(input);
+  } catch {
+    process.exit(0);
+  }
+
+  // Extract file path from Edit or Write tool arguments
+  const filePath = toolInput?.tool_input?.file_path;
+  if (!filePath) process.exit(0);
+
+  // Convert absolute path to project-relative path
+  const relative = filePath.startsWith(projectRoot)
+    ? filePath.slice(projectRoot.length + 1)
+    : filePath;
+
+  // Skip non-source files
+  if (relative.startsWith('node_modules/') || relative.startsWith('.')) process.exit(0);
+
+  const raw = run(projectRoot, ['context', 'impact', '--file', relative, '--format', 'json']);
+  const data = JSON.parse(raw);
+
+  // Only output if there are meaningful dependencies
+  if (data.dependents?.length > 0 || data.related?.length > 0) {
+    const lines = [];
+    lines.push(\`[Impact Analysis] \${relative}\`);
+
+    if (data.dependents.length > 0) {
+      lines.push(\`Dependents (\${data.dependents.length}): \${data.dependents.slice(0, 5).join(', ')}\${data.dependents.length > 5 ? '...' : ''}\`);
+    }
+
+    if (data.dependencies?.length > 0) {
+      lines.push(\`Dependencies (\${data.dependencies.length}): \${data.dependencies.slice(0, 5).join(', ')}\${data.dependencies.length > 5 ? '...' : ''}\`);
+    }
+
+    if (data.related?.length > 0) {
+      lines.push('Related:');
+      for (const r of data.related.slice(0, 3)) {
+        lines.push(\`  - [\${r.type}] \${r.title}\${r.status ? ' (' + r.status + ')' : ''}\`);
+      }
+    }
+
+    if (data.impact === 'high') {
+      lines.push('\\u26a0\\ufe0f HIGH IMPACT — multiple modules depend on this file. Review dependents before making breaking changes.');
+    }
+
+    console.log(lines.join('\\n'));
+  }
+} catch {
+  // Silent exit — do not block editing
+  process.exit(0);
+}
+`;
+}

package/dist/templates/session-start-hook.js

@@ -74,6 +74,26 @@ try {
   const projectRoot = findProjectRoot(process.cwd());
   if (!projectRoot) process.exit(0);
 
+  // Step 1: Auto-sync — recover missed sessions and rescan modules
+  let syncSummary = '';
+  try {
+    const syncRaw = run(projectRoot, ['context', 'sync', '--format', 'json']);
+    const syncData = JSON.parse(syncRaw);
+    const parts = [];
+    if (syncData.sessionsRecovered > 0) {
+      parts.push(\`\${syncData.sessionsRecovered} session(s) recovered from git\`);
+    }
+    if (syncData.modulesUpdated) {
+      parts.push(\`modules rescanned (\${syncData.moduleStats?.modules ?? 0} modules)\`);
+    }
+    if (parts.length > 0) {
+      syncSummary = 'Auto-sync: ' + parts.join(', ') + '.';
+    }
+  } catch {
+    // Sync failed — continue with load
+  }
+
+  // Step 2: Load context
   const raw = run(projectRoot, ['context', 'load', '--format', 'json']);
   const data = JSON.parse(raw);
 
@@ -82,8 +102,15 @@ try {
                   (data.recentDecisions?.length > 0);
 
   if (hasData) {
-    console.log(formatOutput(data));
+    const output = formatOutput(data);
+    if (syncSummary) {
+      console.log(syncSummary + '\\n');
+    }
+    console.log(output);
   } else {
+    if (syncSummary) {
+      console.log(syncSummary);
+    }
     console.log(\`OpenTology context active for \${data.projectId}. No session data yet.\`);
   }
 } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opentology",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "CLI-managed RDF/SPARQL infrastructure — Supabase for RDF",
   "type": "module",
   "bin": {