opentology 0.3.1 → 0.3.3

package/README.md

@@ -2,6 +2,8 @@
 
 > Ontology-powered project memory for AI coding assistants — your codebase as a knowledge graph
 
+[![npm](https://img.shields.io/npm/v/opentology)](https://www.npmjs.com/package/opentology) [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE) [![Live Demo](https://img.shields.io/badge/Live_Demo-opentology.dev-6c63ff)](https://opentology.dev)
+
 [English](#english) | [한국어](#한국어)
 
 ---
@@ -14,6 +16,8 @@ When you connect OpenTology to Claude Code (or any MCP client), it doesn't just
 
 The result: an AI assistant that remembers across sessions, understands your codebase structure, and thinks before it acts.
 
+**[See the live knowledge graph at opentology.dev](https://opentology.dev)** — OpenTology scanning its own codebase: 67 modules, 234 call relations, fully interactive.
+
 ### How It Works
 
 ```
@@ -294,6 +298,8 @@ OpenTology를 Claude Code(또는 MCP 호환 클라이언트)에 연결하면,
 
 결과: 세션을 넘어 기억하고, 코드베이스 구조를 이해하며, 행동 전에 생각하는 AI 어시스턴트.
 
+**[opentology.dev에서 라이브 지식 그래프 확인](https://opentology.dev)** — OpenTology가 자기 자신의 코드베이스를 스캔한 결과: 67개 모듈, 234개 호출 관계, 인터랙티브 탐색 가능.
+
 ### 작동 방식
 
 ```

package/dist/commands/context.js

@@ -10,6 +10,8 @@ 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 { generateUserPromptHookScript } from '../templates/user-prompt-hook.js';
+import { generatePostErrorHookScript } from '../templates/post-error-hook.js';
 import { generateSlashCommands } from '../templates/slash-commands.js';
 import { normalizeModuleUri } from '../lib/module-uri.js';
 function ask(question) {
@@ -110,6 +112,26 @@ export function registerContext(program) {
             else {
                 console.log(pc.dim('  Pre-edit hook already exists — skipped'));
             }
+            // Step 3c: Write user-prompt hook script
+            const userPromptHookPath = join(hookDir, 'user-prompt.mjs');
+            if (!existsSync(userPromptHookPath) || opts.force) {
+                mkdirSync(hookDir, { recursive: true });
+                writeFileSync(userPromptHookPath, generateUserPromptHookScript(), 'utf-8');
+                console.log(pc.green(`  Generated hook script: .opentology/hooks/user-prompt.mjs`));
+            }
+            else {
+                console.log(pc.dim('  User-prompt hook already exists — skipped'));
+            }
+            // Step 3d: Write post-error hook script
+            const postErrorHookPath = join(hookDir, 'post-error.mjs');
+            if (!existsSync(postErrorHookPath) || opts.force) {
+                mkdirSync(hookDir, { recursive: true });
+                writeFileSync(postErrorHookPath, generatePostErrorHookScript(), 'utf-8');
+                console.log(pc.green(`  Generated hook script: .opentology/hooks/post-error.mjs`));
+            }
+            else {
+                console.log(pc.dim('  Post-error hook already exists — skipped'));
+            }
             // Step 4: Update CLAUDE.md
             const claudeMdPath = join(process.cwd(), 'CLAUDE.md');
             const section = generateContextSection(config.projectId, config.graphUri);
@@ -190,12 +212,13 @@ export function registerContext(program) {
                 });
                 console.log(pc.green('  Registered SessionStart hook in .claude/settings.json'));
             }
-            // Ask about PreToolUse impact hook
+            // Ask about smart hooks (PreToolUse, UserPromptSubmit, PostToolUse)
             console.log('');
-            const enableImpact = await ask(pc.bold('Enable PreToolUse impact analysis hook? ') +
-                pc.dim('(auto-shows dependents before Edit/Write)') +
+            const enableHooks = await ask(pc.bold('Enable smart context hooks? ') +
+                pc.dim('(auto-impact before edits, keyword search on prompts, error pattern matching)') +
                 ' [Y/n] ');
-            if (enableImpact !== 'n' && enableImpact !== 'no') {
+            if (enableHooks !== 'n' && enableHooks !== 'no') {
+                // PreToolUse: impact analysis before Edit/Write
                 const preEditCmd = 'node .opentology/hooks/pre-edit.mjs';
                 if (!hooks.PreToolUse)
                     hooks.PreToolUse = [];
@@ -210,10 +233,42 @@ export function registerContext(program) {
                         hooks: [{ type: 'command', command: preEditCmd }],
                     });
                 }
-                console.log(pc.green('  Registered PreToolUse impact hook in .claude/settings.json'));
+                console.log(pc.green('  Registered PreToolUse impact hook'));
+                // UserPromptSubmit: keyword-based context search
+                const userPromptCmd = 'node .opentology/hooks/user-prompt.mjs';
+                if (!hooks.UserPromptSubmit)
+                    hooks.UserPromptSubmit = [];
+                const hasUserPromptHook = hooks.UserPromptSubmit.some((h) => {
+                    const entry = h;
+                    const entryHooks = entry.hooks;
+                    return entryHooks?.some((hook) => hook.command === userPromptCmd);
+                });
+                if (!hasUserPromptHook) {
+                    hooks.UserPromptSubmit.push({
+                        matcher: '',
+                        hooks: [{ type: 'command', command: userPromptCmd }],
+                    });
+                }
+                console.log(pc.green('  Registered UserPromptSubmit context search hook'));
+                // PostToolUse: error pattern matching on Bash
+                const postErrorCmd = 'node .opentology/hooks/post-error.mjs';
+                if (!hooks.PostToolUse)
+                    hooks.PostToolUse = [];
+                const hasPostErrorHook = hooks.PostToolUse.some((h) => {
+                    const entry = h;
+                    const entryHooks = entry.hooks;
+                    return entryHooks?.some((hook) => hook.command === postErrorCmd);
+                });
+                if (!hasPostErrorHook) {
+                    hooks.PostToolUse.push({
+                        matcher: 'Bash',
+                        hooks: [{ type: 'command', command: postErrorCmd }],
+                    });
+                }
+                console.log(pc.green('  Registered PostToolUse error pattern hook'));
             }
             else {
-                console.log(pc.dim('  Skipped PreToolUse hook registration'));
+                console.log(pc.dim('  Skipped smart hook registration'));
             }
             settings.hooks = hooks;
             writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
@@ -579,6 +634,103 @@ export function registerContext(program) {
             process.exit(1);
         }
     });
+    // --- context search ---
+    context
+        .command('search')
+        .description('Search the knowledge graph by keywords (Issues, Decisions, Knowledge, Patterns)')
+        .requiredOption('--keywords <words>', 'Comma-separated keywords to search for')
+        .option('--types <types>', 'Comma-separated types to search (Issue,Decision,Knowledge,Pattern)', 'Issue,Decision,Knowledge,Pattern')
+        .option('--limit <n>', 'Maximum results', '10')
+        .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 keywords = opts.keywords.split(',').map(k => k.trim().toLowerCase()).filter(Boolean);
+        if (keywords.length === 0) {
+            console.error(pc.red('Error: No keywords provided.'));
+            process.exit(1);
+        }
+        const types = opts.types.split(',').map(t => t.trim()).filter(Boolean);
+        const typeFilter = types.map(t => `<${OTX}${t}>`).join(', ');
+        const limit = parseInt(opts.limit, 10) || 10;
+        // Build FILTER clause: match any keyword in title or body
+        const keywordFilters = keywords.map(kw => {
+            const escaped = kw.replace(/"/g, '\\"');
+            return `CONTAINS(LCASE(?title), "${escaped}") || CONTAINS(LCASE(COALESCE(?body, "")), "${escaped}")`;
+        });
+        const filterClause = keywordFilters.join(' || ');
+        try {
+            const adapter = await createReadyAdapter(config);
+            const sparql = `
+          PREFIX otx: <${OTX}>
+          SELECT ?type ?title ?body ?status ?date ?solution ?cause ?reason WHERE {
+            GRAPH <${contextUri}> {
+              ?s a ?type .
+              ?s otx:title ?title .
+              OPTIONAL { ?s otx:body ?body }
+              OPTIONAL { ?s otx:status ?status }
+              OPTIONAL { ?s otx:date ?date }
+              OPTIONAL { ?s otx:solution ?solution }
+              OPTIONAL { ?s otx:cause ?cause }
+              OPTIONAL { ?s otx:reason ?reason }
+              FILTER(
+                ?type IN (${typeFilter})
+                && (${filterClause})
+              )
+            }
+          } ORDER BY DESC(?date) LIMIT ${limit}
+        `;
+            const result = await adapter.sparqlQuery(sparql);
+            const results = (result.results?.bindings ?? []).map((b) => ({
+                type: b.type?.value ?? '',
+                title: b.title?.value ?? '',
+                body: b.body?.value,
+                status: b.status?.value,
+                date: b.date?.value,
+                solution: b.solution?.value,
+                cause: b.cause?.value,
+                reason: b.reason?.value,
+            }));
+            if (opts.format === 'json') {
+                console.log(JSON.stringify({ keywords, results }, null, 2));
+            }
+            else {
+                if (results.length === 0) {
+                    console.log(pc.dim(`No results for keywords: ${keywords.join(', ')}`));
+                    return;
+                }
+                console.log(pc.bold(`Search results for: ${keywords.join(', ')}`));
+                console.log('');
+                for (const r of results) {
+                    const tag = r.type.replace(OTX, '');
+                    console.log(`  [${pc.bold(tag)}] ${r.title}${r.status ? ` (${r.status})` : ''}${r.date ? ` ${pc.dim(r.date)}` : ''}`);
+                    if (r.solution)
+                        console.log(`    ${pc.green('Solution:')} ${r.solution}`);
+                    if (r.cause)
+                        console.log(`    ${pc.yellow('Cause:')} ${r.cause}`);
+                    if (r.reason)
+                        console.log(`    ${pc.blue('Reason:')} ${r.reason}`);
+                }
+            }
+        }
+        catch (err) {
+            console.error(pc.red(`Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
     // --- context graph ---
     context
         .command('graph')

package/dist/index.js

@@ -1,44 +1,14 @@
 #!/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';
-import { registerViz } from './commands/viz.js';
-import { registerDoctor } from './commands/doctor.js';
-import { registerRollback } from './commands/rollback.js';
 const program = new Command();
 program
     .name('opentology')
     .version('0.2.4')
     .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);
-registerViz(program);
-registerDoctor(program);
-registerRollback(program);
 program.parse(process.argv);

package/dist/lib/doctor.d.ts

@@ -0,0 +1,6 @@
+export interface CheckResult {
+    name: string;
+    status: 'ok' | 'warn' | 'fail';
+    message: string;
+}
+export declare function runDoctor(): Promise<CheckResult[]>;

package/dist/lib/doctor.js

@@ -0,0 +1,99 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { configExists, loadConfig } from './config.js';
+import { createReadyAdapter } from './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;
+}

package/dist/lib/store-factory.js

@@ -1,7 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { getTrackedFiles } from './config.js';
-import { HttpAdapter } from './http-adapter.js';
 import { EmbeddedAdapter } from './embedded-adapter.js';
 import { materializeInferences } from './reasoner.js';
 // Singleton cache for embedded mode — keeps data alive across MCP tool calls.
@@ -16,9 +15,6 @@ export function resetAdapterCache() {
     loadedFileKeys = new Set();
 }
 export async function createReadyAdapter(config) {
-    if (config.mode !== 'embedded') {
-        return new HttpAdapter(config.endpoint ?? 'http://localhost:7878');
-    }
     // Reuse cached adapter so data persists across MCP tool calls.
     if (!cachedAdapter) {
         cachedAdapter = new EmbeddedAdapter();

package/dist/mcp/server.d.ts

@@ -1,5 +1,32 @@
 import type { OpenTologyConfig } from '../lib/config.js';
 import type { StoreAdapter } from '../lib/store-adapter.js';
+export interface ContextLoadOutput {
+    projectId: string;
+    graphUri: string;
+    sessions: Array<{
+        uri: string;
+        title: string;
+        date: string;
+        nextTodo?: string;
+    }>;
+    openIssues: Array<{
+        uri: string;
+        title: string;
+        date: string;
+    }>;
+    recentDecisions: Array<{
+        uri: string;
+        title: string;
+        date: string;
+        reason?: string;
+    }>;
+    meta: {
+        contextTripleCount: number;
+        sessionsTripleCount: number;
+        loadedAt: string;
+    };
+    warnings?: string[];
+}
 export declare const MAX_TRIPLES_PER_PUSH = 100;
 export declare function assertTripleLimit(tripleCount: number): void;
 /**

package/dist/mcp/server.js

@@ -18,8 +18,10 @@ 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 { generateUserPromptHookScript } from '../templates/user-prompt-hook.js';
+import { generatePostErrorHookScript } from '../templates/post-error-hook.js';
 import { generateSlashCommands } from '../templates/slash-commands.js';
-import { runDoctor } from '../commands/doctor.js';
+import { runDoctor } from '../lib/doctor.js';
 import { syncContext } from '../lib/context-sync.js';
 import { scanCodebase } from '../lib/codebase-scanner.js';
 import { startGraphServer } from '../lib/graph-server.js';
@@ -482,6 +484,18 @@ async function handleContextInit(args) {
         writeFileSync(preEditHookPath, generatePreEditHookScript(), 'utf-8');
         actions.push('Generated hook: .opentology/hooks/pre-edit.mjs');
     }
+    const userPromptHookPath = join(hookDir, 'user-prompt.mjs');
+    if (!existsSync(userPromptHookPath) || force) {
+        mkdirSync(hookDir, { recursive: true });
+        writeFileSync(userPromptHookPath, generateUserPromptHookScript(), 'utf-8');
+        actions.push('Generated hook: .opentology/hooks/user-prompt.mjs');
+    }
+    const postErrorHookPath = join(hookDir, 'post-error.mjs');
+    if (!existsSync(postErrorHookPath) || force) {
+        mkdirSync(hookDir, { recursive: true });
+        writeFileSync(postErrorHookPath, generatePostErrorHookScript(), 'utf-8');
+        actions.push('Generated hook: .opentology/hooks/post-error.mjs');
+    }
     // Update CLAUDE.md
     const claudeMdPath = join(process.cwd(), 'CLAUDE.md');
     const section = generateContextSection(config.projectId, config.graphUri);
@@ -552,6 +566,38 @@ async function handleContextInit(args) {
         });
         hooksChanged = true;
     }
+    // UserPromptSubmit: keyword-based context search
+    const userPromptCmd = 'node .opentology/hooks/user-prompt.mjs';
+    if (!hooks.UserPromptSubmit)
+        hooks.UserPromptSubmit = [];
+    const hasUserPromptHook = hooks.UserPromptSubmit.some((h) => {
+        const entry = h;
+        const entryHooks = entry.hooks;
+        return entryHooks?.some((hook) => hook.command === userPromptCmd);
+    });
+    if (!hasUserPromptHook) {
+        hooks.UserPromptSubmit.push({
+            matcher: '',
+            hooks: [{ type: 'command', command: userPromptCmd }],
+        });
+        hooksChanged = true;
+    }
+    // PostToolUse: error pattern matching on Bash
+    const postErrorCmd = 'node .opentology/hooks/post-error.mjs';
+    if (!hooks.PostToolUse)
+        hooks.PostToolUse = [];
+    const hasPostErrorHook = hooks.PostToolUse.some((h) => {
+        const entry = h;
+        const entryHooks = entry.hooks;
+        return entryHooks?.some((hook) => hook.command === postErrorCmd);
+    });
+    if (!hasPostErrorHook) {
+        hooks.PostToolUse.push({
+            matcher: 'Bash',
+            hooks: [{ type: 'command', command: postErrorCmd }],
+        });
+        hooksChanged = true;
+    }
     if (hooksChanged) {
         settings.hooks = hooks;
         writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
@@ -704,6 +750,54 @@ async function handleContextLoad() {
         delete output.warnings;
     return output;
 }
+async function handleContextSearch(args) {
+    const keywords = args.keywords;
+    if (!keywords || keywords.length === 0)
+        throw new Error('keywords is required (array of strings)');
+    const types = args.types ?? ['Issue', 'Decision', 'Knowledge', 'Pattern'];
+    const limit = args.limit ?? 10;
+    const config = loadConfig();
+    const contextUri = `${config.graphUri}/context`;
+    const OTX = 'https://opentology.dev/vocab#';
+    const adapter = await createReadyAdapter(config);
+    const typeFilter = types.map(t => `<${OTX}${t}>`).join(', ');
+    const keywordFilters = keywords.map(kw => {
+        const escaped = kw.toLowerCase().replace(/"/g, '\\"');
+        return `CONTAINS(LCASE(?title), "${escaped}") || CONTAINS(LCASE(COALESCE(?body, "")), "${escaped}")`;
+    });
+    const filterClause = keywordFilters.join(' || ');
+    const sparql = `
+    PREFIX otx: <${OTX}>
+    SELECT ?type ?title ?body ?status ?date ?solution ?cause ?reason WHERE {
+      GRAPH <${contextUri}> {
+        ?s a ?type .
+        ?s otx:title ?title .
+        OPTIONAL { ?s otx:body ?body }
+        OPTIONAL { ?s otx:status ?status }
+        OPTIONAL { ?s otx:date ?date }
+        OPTIONAL { ?s otx:solution ?solution }
+        OPTIONAL { ?s otx:cause ?cause }
+        OPTIONAL { ?s otx:reason ?reason }
+        FILTER(
+          ?type IN (${typeFilter})
+          && (${filterClause})
+        )
+      }
+    } ORDER BY DESC(?date) LIMIT ${limit}
+  `;
+    const result = await adapter.sparqlQuery(sparql);
+    const results = (result.results?.bindings ?? []).map((b) => ({
+        type: b.type?.value ?? '',
+        title: b.title?.value ?? '',
+        body: b.body?.value,
+        status: b.status?.value,
+        date: b.date?.value,
+        solution: b.solution?.value,
+        cause: b.cause?.value,
+        reason: b.reason?.value,
+    }));
+    return { keywords, results };
+}
 async function handleContextImpact(args) {
     const filePath = args.filePath;
     if (!filePath)
@@ -1196,6 +1290,30 @@ export async function startMcpServer() {
                     properties: {},
                 },
             },
+            {
+                name: 'context_search',
+                description: 'Search the knowledge graph by keywords. Searches across Issues, Decisions, Knowledge, and Patterns by matching keywords against titles and bodies. Use this to find relevant context before investigating code.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        keywords: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Keywords to search for (matched with OR logic against title and body).',
+                        },
+                        types: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'OTX types to search (default: Issue, Decision, Knowledge, Pattern). Use short names without prefix.',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum results (default: 10).',
+                        },
+                    },
+                    required: ['keywords'],
+                },
+            },
             {
                 name: 'context_status',
                 description: 'Check whether project context is initialized. Shows graph triple counts, hook script presence, and CLAUDE.md marker status.',
@@ -1398,6 +1516,9 @@ export async function startMcpServer() {
                 case 'context_load':
                     result = await handleContextLoad();
                     break;
+                case 'context_search':
+                    result = await handleContextSearch(args);
+                    break;
                 case 'context_status':
                     result = await handleContextStatus();
                     break;

package/dist/templates/claude-md-context.js

@@ -7,7 +7,10 @@ export function generateContextSection(projectId, graphUri) {
     return `${MARKER_BEGIN}
 ## Context Management — OpenTology
 
-This project uses OpenTology as its project context graph.
+This project uses OpenTology as its knowledge graph — treat it as the project's **long-term memory**.
+Before reading source files, grep-searching, or making assumptions, **query the graph first**.
+It holds architectural decisions, resolved issues, reusable patterns, module dependencies,
+symbol-level call graphs, and session history. Prefer graph knowledge over re-deriving facts from code.
 
 ### Graph Structure
 

package/dist/templates/post-error-hook.d.ts

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

package/dist/templates/post-error-hook.js

@@ -0,0 +1,146 @@
+export function generatePostErrorHookScript() {
+    return `#!/usr/bin/env node
+// Generated by: opentology context init
+// PostToolUse hook (Bash) — matches error output against known patterns
+import { existsSync, readFileSync } 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);
+
+// Error indicators that trigger pattern search
+const ERROR_PATTERNS = [
+  /\\bError\\b/i,
+  /\\bERR!\\b/,
+  /\\bFailed\\b/i,
+  /\\bfatal\\b/i,
+  /\\bENOENT\\b/,
+  /\\bENOTDIR\\b/,
+  /\\bEACCES\\b/,
+  /\\bSyntaxError\\b/,
+  /\\bTypeError\\b/,
+  /\\bReferenceError\\b/,
+  /\\bModuleNotFoundError\\b/,
+  /\\bexited with code [1-9]/,
+  /\\bcommand not found\\b/,
+  /\\bCannot find module\\b/,
+  /\\bTS\\d{4}:/,
+];
+
+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'],
+  });
+}
+
+function extractErrorKeywords(output) {
+  const keywords = new Set();
+
+  // Extract error class names (TypeError, SyntaxError, etc.)
+  const errorClasses = output.match(/\\b[A-Z][a-zA-Z]*Error\\b/g);
+  if (errorClasses) errorClasses.forEach(e => keywords.add(e));
+
+  // Extract TS error codes
+  const tsCodes = output.match(/TS\\d{4}/g);
+  if (tsCodes) tsCodes.forEach(c => keywords.add(c));
+
+  // Extract "Cannot find module 'xxx'"
+  const modules = output.match(/Cannot find module ['"]([^'"]+)['"]/g);
+  if (modules) modules.forEach(m => {
+    const name = m.match(/['"]([^'"]+)['"]/)?.[1];
+    if (name) keywords.add(name);
+  });
+
+  // Extract file paths from error output
+  const paths = output.match(/(?:src|lib)\\/[\\w/.-]+\\.\\w+/g);
+  if (paths) paths.slice(0, 3).forEach(p => keywords.add(p));
+
+  // Extract npm package names from errors
+  const npmPkgs = output.match(/(?:ERR!|error)\\s+([a-z@][a-z0-9@/.-]+)/gi);
+  if (npmPkgs) npmPkgs.slice(0, 2).forEach(p => {
+    const name = p.replace(/^(?:ERR!|error)\\s+/i, '');
+    if (name.length >= 3) keywords.add(name);
+  });
+
+  return [...keywords].slice(0, 5);
+}
+
+try {
+  const projectRoot = findProjectRoot(process.cwd());
+  if (!projectRoot) process.exit(0);
+
+  // Read tool output from stdin
+  let input = '';
+  try {
+    input = readFileSync('/dev/stdin', 'utf-8');
+  } catch {
+    process.exit(0);
+  }
+
+  let toolOutput = '';
+  let toolName = '';
+  try {
+    const parsed = JSON.parse(input);
+    toolName = parsed.tool_name || '';
+    toolOutput = parsed.tool_output || parsed.stdout || parsed.stderr || '';
+  } catch {
+    toolOutput = input;
+  }
+
+  // Only process Bash tool output
+  if (toolName && toolName !== 'Bash') process.exit(0);
+
+  // Check if output contains error indicators
+  if (!toolOutput || toolOutput.length < 10) process.exit(0);
+  const hasError = ERROR_PATTERNS.some(p => p.test(toolOutput));
+  if (!hasError) process.exit(0);
+
+  const keywords = extractErrorKeywords(toolOutput);
+  if (keywords.length === 0) process.exit(0);
+
+  const raw = run(projectRoot, [
+    'context', 'search',
+    '--keywords', keywords.join(','),
+    '--types', 'Pattern,Issue,Knowledge',
+    '--format', 'json',
+  ]);
+  const data = JSON.parse(raw);
+
+  if (!data.results || data.results.length === 0) process.exit(0);
+
+  const lines = [];
+  lines.push('[Known Pattern Match] Similar errors found in project history:');
+  for (const r of data.results.slice(0, 3)) {
+    const tag = r.type.replace('https://opentology.dev/vocab#', '');
+    lines.push(\`- [\${tag}] \${r.title}\${r.status ? ' (' + r.status + ')' : ''}\`);
+    if (r.solution) lines.push(\`  Solution: \${r.solution}\`);
+    if (r.cause) lines.push(\`  Cause: \${r.cause}\`);
+    if (r.body && r.body.length <= 150) lines.push(\`  \${r.body}\`);
+  }
+
+  console.log(lines.join('\\n'));
+} catch {
+  // Silent exit — do not block command execution
+  process.exit(0);
+}
+`;
+}

package/dist/templates/user-prompt-hook.d.ts

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

package/dist/templates/user-prompt-hook.js

@@ -0,0 +1,139 @@
+export function generateUserPromptHookScript() {
+    return `#!/usr/bin/env node
+// Generated by: opentology context init
+// UserPromptSubmit hook — extracts keywords from user message and queries related context
+import { existsSync, readFileSync } 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);
+
+// Stop words (EN + KO common particles/connectors)
+const STOP_WORDS = new Set([
+  // English
+  'the','a','an','is','are','was','were','be','been','being','have','has','had',
+  'do','does','did','will','would','shall','should','may','might','must','can','could',
+  'this','that','these','those','it','its','i','you','he','she','we','they','me','him',
+  'her','us','them','my','your','his','our','their','what','which','who','whom','when',
+  'where','why','how','not','no','nor','but','and','or','if','then','else','for','from',
+  'with','without','about','above','after','before','between','into','through','during',
+  'to','of','in','on','at','by','as','so','than','too','very','just','also','now','here',
+  'there','all','each','every','both','few','more','most','other','some','such','only',
+  'same','let','please','want','need','like','make','get','use','try','look','see','know',
+  'think','help','show','tell','give','take','come','go','run','file','code','check',
+  // Korean particles/connectors
+  '은','는','이','가','을','를','에','에서','으로','로','와','과','의','도','만',
+  '부터','까지','에게','한테','보다','라고','이라고','하고','해서','해줘','해주세요',
+  '좀','그','저','것','거','수','때','중','후','전','안','못','잘','더','다',
+  '뭐','어떻게','왜','어디','언제','누가','뭘','걸','건','데','게','줘',
+]);
+
+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'],
+  });
+}
+
+function extractKeywords(text) {
+  const keywords = [];
+
+  // Step 1: Split mixed Korean+English tokens (e.g. "persistGraph에서" → "persistGraph", "에서")
+  const raw = text.replace(/[\\n\\r]/g, ' ');
+  const mixedSplit = raw.replace(/([a-zA-Z0-9_./]+)([\\uAC00-\\uD7AF\\u3130-\\u318F]+)/g, '$1 $2')
+                        .replace(/([\\uAC00-\\uD7AF\\u3130-\\u318F]+)([a-zA-Z0-9_./]+)/g, '$1 $2');
+
+  const tokens = mixedSplit
+    .split(/[\\s,.:;!?()\\[\\]{}'"]+/)
+    .filter(Boolean);
+
+  for (const token of tokens) {
+    const lower = token.toLowerCase();
+    if (STOP_WORDS.has(lower)) continue;
+    // English identifiers (camelCase, snake_case, PascalCase) — 4+ chars
+    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(token) && token.length >= 4) {
+      keywords.push(lower);
+    }
+    // Korean content words (3+ chars to skip particles like 에러가→에러)
+    if (/[\\uAC00-\\uD7AF]/.test(token) && token.length >= 3 && !STOP_WORDS.has(token)) {
+      keywords.push(token);
+    }
+    // File paths, module references, Error class names
+    if (token.includes('/') || token.includes('.') || /Error$/.test(token)) {
+      keywords.push(token);
+    }
+  }
+
+  // Deduplicate and limit
+  return [...new Set(keywords)].slice(0, 5);
+}
+
+try {
+  const projectRoot = findProjectRoot(process.cwd());
+  if (!projectRoot) process.exit(0);
+
+  // Read user prompt from stdin
+  let input = '';
+  try {
+    input = readFileSync('/dev/stdin', 'utf-8');
+  } catch {
+    process.exit(0);
+  }
+
+  let userMessage = '';
+  try {
+    const parsed = JSON.parse(input);
+    userMessage = parsed.user_prompt || parsed.message || '';
+  } catch {
+    // Plain text input
+    userMessage = input;
+  }
+
+  if (!userMessage || userMessage.length < 5) process.exit(0);
+
+  const keywords = extractKeywords(userMessage);
+  if (keywords.length === 0) process.exit(0);
+
+  const raw = run(projectRoot, ['context', 'search', '--keywords', keywords.join(','), '--format', 'json']);
+  const data = JSON.parse(raw);
+
+  if (!data.results || data.results.length === 0) process.exit(0);
+
+  const lines = [];
+  lines.push('[Graph Context] Related to your query:');
+  for (const r of data.results.slice(0, 5)) {
+    const tag = r.type.replace('https://opentology.dev/vocab#', '');
+    let line = \`- [\${tag}] \${r.title}\`;
+    if (r.status) line += \` (\${r.status})\`;
+    if (r.date) line += \` [\${r.date}]\`;
+    lines.push(line);
+    if (r.solution) lines.push(\`  Solution: \${r.solution}\`);
+    if (r.reason) lines.push(\`  Reason: \${r.reason}\`);
+    if (r.body && r.body.length <= 200) lines.push(\`  \${r.body}\`);
+  }
+
+  console.log(lines.join('\\n'));
+} catch {
+  // Silent exit — do not block prompt submission
+  process.exit(0);
+}
+`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opentology",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Ontology-powered project memory for AI coding assistants — your codebase as a knowledge graph",
   "type": "module",
   "bin": {