iranti 0.3.10 → 0.3.12

package/README.md

@@ -1,19 +1,21 @@
 # Iranti
 
 [![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](https://www.gnu.org/licenses/agpl-3.0.en.html)
+[![MCP Server](https://img.shields.io/badge/MCP-server-purple.svg)](https://modelcontextprotocol.io)
+[![npm](https://img.shields.io/badge/npm-iranti-red.svg)](https://www.npmjs.com/package/iranti)
 [![Python](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
 [![TypeScript](https://img.shields.io/badge/typescript-5.0+-blue.svg)](https://www.typescriptlang.org/)
 [![CrewAI Compatible](https://img.shields.io/badge/CrewAI-compatible-green.svg)](https://www.crewai.com/)
 
-**Memory infrastructure for multi-agent AI systems.**
+**Memory infrastructure for multi-agent AI systems — with a built-in MCP server.**
 
 Iranti gives agents persistent, identity-based memory. Facts written by one agent are retrievable by any other agent through exact entity+key lookup. Iranti also supports hybrid search (lexical + vector) when exact keys are unknown. Memory persists across sessions and survives context window limits.
 
-**Repo version:** `0.3.4`  
+**Repo version:** `0.3.11`
 Published packages:
-- npm `iranti@0.3.4`
-- npm `@iranti/sdk@0.3.4`
-- PyPI `iranti==0.3.4`
+- npm `iranti@0.3.11`
+- npm `@iranti/sdk@0.3.11`
+- PyPI `iranti==0.3.11`
 
 ---
 
@@ -23,6 +25,32 @@ Iranti is a knowledge base for multi-agent systems. The primary read path is ide
 
 ---
 
+## MCP Server
+
+Iranti ships a stdio MCP server compatible with Claude Code, GitHub Copilot, Codex, and any MCP-compliant client:
+
+```bash
+# Fast path for Claude Code
+iranti claude-setup
+
+# Fast path for Codex
+iranti codex-setup
+
+# Fast path for GitHub Copilot
+iranti copilot-setup
+
+# Manual / other MCP clients
+iranti mcp
+```
+
+MCP tools exposed: `iranti_handshake`, `iranti_attend`, `iranti_write`, `iranti_query`, `iranti_search`, `iranti_checkpoint`, `iranti_ingest`, `iranti_relate`, `iranti_related`, `iranti_related_deep`, `iranti_history`, `iranti_who_knows`, `iranti_observe`, and more.
+
+Full setup guides:
+- [Claude Code](docs/guides/claude-code.md)
+- [Codex](docs/guides/codex.md)
+
+---
+
 ## Runtime Roles
 
 - **User**: Person who interacts with an app or chatbot built on Iranti.

package/dist/scripts/claude-code-memory-hook.js

@@ -315,7 +315,9 @@ function emitHookContext(event, additionalContext) {
             additionalContext,
         },
     };
-    process.stdout.write(`${JSON.stringify(payload)}\n`);
+    // Use synchronous write to fd 1 to avoid libuv UV_HANDLE_CLOSING assertion
+    // on Windows when Node exits while an async stdout write is still pending.
+    require('fs').writeSync(1, `${JSON.stringify(payload)}\n`);
 }
 function shouldFetchMemory(prompt) {
     const normalized = prompt.trim();

package/dist/scripts/codex-setup.js

@@ -364,6 +364,147 @@ function writeWorkspaceVsCodeMcpFile(projectEnv, options) {
     }, null, 2)}\n`, 'utf8');
     return { filePath: mcpFile, status: 'updated' };
 }
+/**
+ * Protocol reminder hook script content for Codex UserPromptSubmit.
+ * Same content as the Claude Code version — fires before every user prompt.
+ */
+function buildProtocolReminderHookScript() {
+    return [
+        '#!/usr/bin/env node',
+        "'use strict';",
+        '// Iranti protocol reminder hook — fires on UserPromptSubmit for any Iranti project.',
+        '// Cross-platform: runs on Windows, macOS, Linux via Node.js.',
+        '// Exits cleanly with no output for non-Iranti projects.',
+        "const fs = require('fs');",
+        "const path = require('path');",
+        '',
+        "const envFile = path.join(process.cwd(), '.env.iranti');",
+        'if (!fs.existsSync(envFile)) process.exit(0);',
+        '',
+        'const content = [',
+        "  'IRANTI PROTOCOL (required this turn):',",
+        "  '1. iranti_attend(phase=pre-response) BEFORE replying',",
+        "  '2. iranti_attend BEFORE each Read / Grep / Glob / Bash / WebSearch / WebFetch',",
+        "  '3. iranti_write AFTER each Edit or Write:',",
+        "  '   entity: project/[id]/file/[filename] -- not the broad project entity',",
+        "  '   value must include: absolutePath, lines, before, after, verify, why',",
+        "  '4. iranti_write AFTER each Bash that reveals system state (build, errors, ports, env)',",
+        "  '5. iranti_write AFTER each WebSearch/WebFetch -- write findings AND dead ends / 404s',",
+        "  '6. iranti_attend(phase=post-response) AFTER every response without exception',",
+        "].join('\\n') + '\\n';",
+        "require('fs').writeSync(1, content);",
+        '',
+    ].join('\n');
+}
+/**
+ * Write the protocol-reminder hook script into the project's .codex/ directory
+ * and return a status result matching the workspace file pattern.
+ */
+function writeProtocolReminderHook(projectEnv) {
+    const projectPath = node_path_1.default.dirname(projectEnv);
+    const codexDir = node_path_1.default.join(projectPath, '.codex');
+    const hookFile = node_path_1.default.join(codexDir, 'iranti-protocol-hook.js');
+    const hookContent = buildProtocolReminderHookScript();
+    node_fs_1.default.mkdirSync(codexDir, { recursive: true });
+    if (!node_fs_1.default.existsSync(hookFile)) {
+        node_fs_1.default.writeFileSync(hookFile, hookContent, 'utf8');
+        return { filePath: hookFile, status: 'created' };
+    }
+    const existing = node_fs_1.default.readFileSync(hookFile, 'utf8');
+    if (existing !== hookContent) {
+        node_fs_1.default.writeFileSync(hookFile, hookContent, 'utf8');
+        return { filePath: hookFile, status: 'updated' };
+    }
+    return { filePath: hookFile, status: 'unchanged' };
+}
+/**
+ * Write a .codex/hooks.json referencing the protocol-reminder hook.
+ * This fires on UserPromptSubmit when the codex_hooks feature is enabled.
+ */
+function writeCodexHooksConfig(projectEnv) {
+    const projectPath = node_path_1.default.dirname(projectEnv);
+    const codexDir = node_path_1.default.join(projectPath, '.codex');
+    const hooksConfigFile = node_path_1.default.join(codexDir, 'hooks.json');
+    const hookScriptPath = node_path_1.default.join(codexDir, 'iranti-protocol-hook.js');
+    const hooksConfig = {
+        hooks: {
+            UserPromptSubmit: [
+                {
+                    matcher: '',
+                    hooks: [
+                        {
+                            type: 'command',
+                            command: `node ${hookScriptPath.replace(/\\/g, '/')}`,
+                        },
+                    ],
+                },
+            ],
+        },
+    };
+    node_fs_1.default.mkdirSync(codexDir, { recursive: true });
+    const nextContent = `${JSON.stringify(hooksConfig, null, 2)}\n`;
+    if (!node_fs_1.default.existsSync(hooksConfigFile)) {
+        node_fs_1.default.writeFileSync(hooksConfigFile, nextContent, 'utf8');
+        return { filePath: hooksConfigFile, status: 'created' };
+    }
+    const existing = node_fs_1.default.readFileSync(hooksConfigFile, 'utf8');
+    if (existing === nextContent) {
+        return { filePath: hooksConfigFile, status: 'unchanged' };
+    }
+    // Merge: keep existing hooks, add/replace UserPromptSubmit from iranti.
+    try {
+        const parsed = JSON.parse(existing);
+        const existingHooks = parsed.hooks && typeof parsed.hooks === 'object' && !Array.isArray(parsed.hooks)
+            ? parsed.hooks
+            : {};
+        const merged = {
+            ...parsed,
+            hooks: {
+                ...existingHooks,
+                UserPromptSubmit: hooksConfig.hooks.UserPromptSubmit,
+            },
+        };
+        const mergedContent = `${JSON.stringify(merged, null, 2)}\n`;
+        if (mergedContent === existing) {
+            return { filePath: hooksConfigFile, status: 'unchanged' };
+        }
+        node_fs_1.default.writeFileSync(hooksConfigFile, mergedContent, 'utf8');
+        return { filePath: hooksConfigFile, status: 'updated' };
+    }
+    catch {
+        // Can't parse existing — overwrite
+        node_fs_1.default.writeFileSync(hooksConfigFile, nextContent, 'utf8');
+        return { filePath: hooksConfigFile, status: 'updated' };
+    }
+}
+/**
+ * Check if the codex_hooks feature is enabled globally.
+ */
+function isCodexHooksFeatureEnabled(repoRoot) {
+    try {
+        const output = run('codex', ['features', 'list'], repoRoot);
+        const match = output.match(/codex_hooks\s+\S+\s+(true|false)/);
+        return match?.[1] === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Enable the codex_hooks feature flag if not already enabled.
+ */
+function ensureCodexHooksFeature(repoRoot) {
+    if (isCodexHooksFeatureEnabled(repoRoot)) {
+        return true;
+    }
+    try {
+        run('codex', ['features', 'enable', 'codex_hooks'], repoRoot);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function canUseInstalledIranti(repoRoot) {
     try {
         run('iranti', ['mcp', '--help'], repoRoot);
@@ -428,8 +569,12 @@ async function main() {
             vscode: writeWorkspaceVsCodeMcpFile(workspaceProjectEnv, options),
             agents: writeWorkspaceAgentsFile(workspaceProjectEnv),
             irantiMd: writeWorkspaceIrantiMdFile(workspaceProjectEnv),
+            protocolHook: writeProtocolReminderHook(workspaceProjectEnv),
+            hooksConfig: writeCodexHooksConfig(workspaceProjectEnv),
         }
         : null;
+    // Enable the codex_hooks feature flag so the UserPromptSubmit hook fires.
+    const hooksFeatureEnabled = ensureCodexHooksFeature(repoRoot);
     const registered = run('codex', ['mcp', 'get', options.name], repoRoot);
     console.log(registered);
     console.log('');
@@ -468,6 +613,9 @@ async function main() {
             console.log(`Workspace .vscode/mcp.json: ${workspaceFilesResult.vscode.status} (${workspaceFilesResult.vscode.filePath})`);
             console.log(`Workspace AGENTS.md: ${workspaceFilesResult.agents.status} (${workspaceFilesResult.agents.filePath})`);
             console.log(`Workspace IRANTI.md: ${workspaceFilesResult.irantiMd.status} (${workspaceFilesResult.irantiMd.filePath})`);
+            console.log(`Protocol hook: ${workspaceFilesResult.protocolHook.status} (${workspaceFilesResult.protocolHook.filePath})`);
+            console.log(`Hooks config: ${workspaceFilesResult.hooksConfig.status} (${workspaceFilesResult.hooksConfig.filePath})`);
+            console.log(`codex_hooks feature: ${hooksFeatureEnabled ? 'enabled' : 'not enabled (UserPromptSubmit hook requires codex_hooks feature)'}`);
             const closeout = await (0, scaffoldCloseout_1.writeProjectScaffoldCloseout)({
                 tool: 'codex',
                 projectPath: node_path_1.default.dirname(boundProjectEnv),
@@ -477,6 +625,8 @@ async function main() {
                     { path: workspaceFilesResult.vscode.filePath, status: workspaceFilesResult.vscode.status },
                     { path: workspaceFilesResult.agents.filePath, status: workspaceFilesResult.agents.status },
                     { path: workspaceFilesResult.irantiMd.filePath, status: workspaceFilesResult.irantiMd.status },
+                    { path: workspaceFilesResult.protocolHook.filePath, status: workspaceFilesResult.protocolHook.status },
+                    { path: workspaceFilesResult.hooksConfig.filePath, status: workspaceFilesResult.hooksConfig.status },
                 ],
                 agentId: options.agent || 'codex_code',
             });