opentology 0.3.2 → 0.3.4

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/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/{commands → lib}/doctor.d.ts

@@ -1,9 +1,6 @@
-import { Command } from 'commander';
-interface CheckResult {
+export 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 → lib}/doctor.js

@@ -1,8 +1,7 @@
-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';
+import { configExists, loadConfig } from './config.js';
+import { createReadyAdapter } from './store-factory.js';
 export async function runDoctor() {
     const results = [];
     // 1. Config check
@@ -98,35 +97,3 @@ export async function runDoctor() {
     }
     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/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/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.2",
+  "version": "0.3.4",
   "description": "Ontology-powered project memory for AI coding assistants — your codebase as a knowledge graph",
   "type": "module",
   "bin": {

package/dist/commands/context.d.ts

@@ -1,29 +0,0 @@
-import { Command } from 'commander';
-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 function registerContext(program: Command): void;