neurain 0.1.0-alpha.0

package/src/core/connect.mjs

@@ -0,0 +1,355 @@
+import { spawnSync } from 'node:child_process';
+import { absPath } from './fs.mjs';
+
+export async function connectCommand(args) {
+  const host = args._[0];
+  const root = absPath(args._[1] || args.root || process.cwd());
+  if (!['codex', 'claude', 'gemini', 'runtime'].includes(host)) throw new Error('connect supports: codex, claude, gemini, runtime');
+  const dryRun = Boolean(args['dry-run']);
+  const lifecycleHooks = Boolean(args['lifecycle-hooks'] || args.lifecycle);
+  if (lifecycleHooks) return lifecycleHooksConnect(host, root, { dryRun, json: Boolean(args.json), scope: args.scope || 'local' });
+  if (host === 'runtime') return runtimeConnect(root, { dryRun, json: Boolean(args.json) });
+  const command = connectShellCommand(host, root, args);
+  if (!dryRun) {
+    const [bin, ...cmdArgs] = command;
+    const result = spawnSync(bin, cmdArgs, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    if (result.status !== 0) {
+      throw new Error(`${host} MCP connect failed:\n${result.stderr || result.stdout || 'no output'}`);
+    }
+  }
+  const payload = { ok: true, host, root, dry_run: dryRun, command };
+  if (args.json) return { json: true, payload };
+  return {
+    text: [
+      `# Neurain connect ${host}${dryRun ? ' [dry-run]' : ''}`,
+      '',
+      `- Root: ${root}`,
+      `- Command: ${shellQuote(command)}`,
+      dryRun ? '- No host config changed.' : '- Host MCP config updated.',
+    ].join('\n'),
+  };
+}
+
+function connectShellCommand(host, root, args = {}) {
+  if (host === 'codex') return codexCommand(root);
+  if (host === 'claude') return claudeCommand(root, args.scope || 'local');
+  if (host === 'gemini') return geminiCommand(root, args.scope || 'project');
+  throw new Error(`Unsupported host: ${host}`);
+}
+
+export function codexCommand(root) {
+  return ['codex', 'mcp', 'add', 'neurain', '--env', `NEURAIN_ROOT=${root}`, '--', 'npx', '-y', 'neurain', 'mcp', '--root', root];
+}
+
+export function claudeCommand(root, scope = 'local') {
+  return ['claude', 'mcp', 'add', '--scope', scope, '-e', `NEURAIN_ROOT=${root}`, 'neurain', '--', 'npx', '-y', 'neurain', 'mcp', '--root', root];
+}
+
+export function geminiCommand(root, scope = 'project') {
+  return [
+    'gemini',
+    'mcp',
+    'add',
+    '--scope',
+    scope,
+    '--env',
+    `NEURAIN_ROOT=${root}`,
+    '--include-tools',
+    geminiIncludedTools().join(','),
+    'neurain',
+    'npx',
+    '-y',
+    'neurain',
+    'mcp',
+    '--root',
+    root,
+  ];
+}
+
+export function geminiConfigSnippet(root) {
+  return `${JSON.stringify({
+    mcpServers: {
+      neurain: {
+        command: 'npx',
+        args: ['-y', 'neurain', 'mcp', '--root', root],
+        env: { NEURAIN_ROOT: root },
+        trust: false,
+        includeTools: geminiIncludedTools(),
+      },
+    },
+  }, null, 2)}\n`;
+}
+
+export function runtimeConfigSnippet(root) {
+  return [
+    'mcp_servers:',
+    '  neurain:',
+    '    command: "npx"',
+    `    args: ["-y", "neurain", "mcp", "--root", ${JSON.stringify(root)}]`,
+    '    env:',
+    `      NEURAIN_ROOT: ${JSON.stringify(root)}`,
+    '    tools:',
+    '      include:',
+    '        - neurain_status',
+    '        - neurain_search',
+    '        - neurain_recall_search',
+    '        - neurain_recall_status',
+    '        - neurain_recall_verify',
+    '        - neurain_recall_cross_host_eval',
+    '        - neurain_answer_quality_eval',
+    '        - neurain_live_cases_scaffold',
+    '        - neurain_lifecycle_report',
+    '        - neurain_watch_report',
+    '        - neurain_review_worker',
+    '        - neurain_scheduler_tick',
+    '        - neurain_scheduler_eval',
+    '        - neurain_wrap_preview',
+    '      resources: false',
+    '      prompts: false',
+  ].join('\n');
+}
+
+export function geminiIncludedTools() {
+  return [
+    'neurain_status',
+    'neurain_search',
+    'neurain_adopt_scan',
+    'neurain_recap',
+    'neurain_capabilities',
+    'neurain_recall_status',
+    'neurain_recall_search',
+    'neurain_recall_semantic_search',
+    'neurain_recall_hybrid_search',
+    'neurain_recall_verify',
+    'neurain_recall_cross_host_eval',
+    'neurain_recall_semantic_eval',
+    'neurain_answer_quality_eval',
+    'neurain_live_cases_scaffold',
+    'neurain_lifecycle_report',
+    'neurain_lifecycle_eval',
+    'neurain_lessons_list',
+    'neurain_lessons_candidates',
+    'neurain_lessons_eval',
+    'neurain_watch_report',
+    'neurain_review_worker',
+    'neurain_scheduler_tick',
+    'neurain_scheduler_eval',
+    'neurain_wrap_preview',
+  ];
+}
+
+export function lifecycleHookCommand(host, root) {
+  return ['npx', '-y', 'neurain', 'lifecycle', 'hook', root, '--host', host, '--confirm', '1건 저장 진행', '--quiet'];
+}
+
+export function claudeLifecycleSettingsSnippet(root) {
+  const command = shellQuote(lifecycleHookCommand('claude', root));
+  return JSON.stringify({
+    hooks: {
+      SessionStart: [
+        {
+          matcher: 'startup|resume|clear|compact',
+          hooks: [{ type: 'command', command, timeout: 10 }],
+        },
+      ],
+      UserPromptSubmit: [
+        {
+          hooks: [{ type: 'command', command, timeout: 10 }],
+        },
+      ],
+      Stop: [
+        {
+          hooks: [{ type: 'command', command, timeout: 10 }],
+        },
+      ],
+      SessionEnd: [
+        {
+          hooks: [{ type: 'command', command, timeout: 10 }],
+        },
+      ],
+    },
+  }, null, 2);
+}
+
+export function codexLifecycleHooksSnippet(root) {
+  const command = shellQuote(lifecycleHookCommand('codex', root));
+  return JSON.stringify({
+    hooks: {
+      SessionStart: [
+        {
+          hooks: [
+            {
+              type: 'command',
+              command,
+              timeout: 10,
+              statusMessage: 'Neurain records session boundary metadata...',
+            },
+          ],
+        },
+      ],
+      PostToolUse: [
+        {
+          matcher: 'Edit|Write',
+          hooks: [
+            {
+              type: 'command',
+              command,
+              timeout: 10,
+              statusMessage: 'Neurain marks review due after durable edits...',
+            },
+          ],
+        },
+      ],
+    },
+  }, null, 2);
+}
+
+export function runtimeLifecycleProxySnippet(root) {
+  return JSON.stringify({
+    command: lifecycleHookCommand('runtime', root),
+    payload_contract: {
+      required: ['session_id', 'hook_event_name'],
+      supported_hook_event_name_values: [
+        'session_start',
+        'turn_start',
+        'turn_end',
+        'wrap_complete',
+        'review_due',
+        'review_complete',
+        'compaction',
+        'resume',
+        'session_end',
+      ],
+      optional: ['turn_id', 'parent_session_id', 'source'],
+      forbidden_to_store: ['prompt', 'messages', 'transcript_path', 'stdout', 'stderr', 'tool_result'],
+    },
+    example_payload: {
+      session_id: 'runtime-session-1',
+      hook_event_name: 'turn_end',
+      turn_id: 'turn-1',
+      source: 'agent-loop-boundary',
+    },
+  }, null, 2);
+}
+
+function runtimeConnect(root, { dryRun, json }) {
+  if (!dryRun) {
+    throw new Error('Runtime connect alpha is config-preview only. Run with --dry-run, then adapt the snippet to the target host MCP config.');
+  }
+  const payload = {
+    ok: true,
+    host: 'runtime',
+    root,
+    dry_run: true,
+    config_path: 'host-managed MCP config',
+    reload_command: 'host-specific MCP reload',
+    config_snippet: runtimeConfigSnippet(root),
+    note: 'Runtime connector alpha emits a bounded Neurain MCP config snippet for an agent host that supports MCP. It does not edit any host config directly.',
+  };
+  if (json) return { json: true, payload };
+  return {
+    text: [
+      '# Neurain connect runtime [dry-run]',
+      '',
+      `- Root: ${root}`,
+      '- Config path: host-managed MCP config',
+      '- Reload: use the target host MCP reload flow',
+      '- No host config changed.',
+      '',
+      '```yaml',
+      payload.config_snippet,
+      '```',
+    ].join('\n'),
+  };
+}
+
+function lifecycleHooksConnect(host, root, { dryRun, json, scope }) {
+  if (!dryRun) {
+    throw new Error('Lifecycle hook connector alpha is preview-only. Run with --dry-run, inspect the snippet, and paste it into the host config yourself.');
+  }
+  const supported = ['claude', 'codex', 'runtime'].includes(host);
+  const payload = {
+    ok: true,
+    host,
+    root,
+    dry_run: true,
+    lifecycle_hooks: {
+      supported,
+      status: lifecycleHookStatus(host),
+      writes_host_config: false,
+      durable_neurain_write_when_hook_fires: supported,
+      stored_payload_body: false,
+      transcript_path_stored: false,
+      native_host_config_verified: supported && host !== 'runtime',
+      events: lifecycleHookEvents(host),
+      mapped_events: lifecycleHookMappedEvents(host),
+    },
+    manual_commands: manualLifecycleCommands(host, root),
+  };
+  if (host === 'claude') {
+    payload.config_path = scope === 'user' ? '~/.claude/settings.json' : scope === 'project' ? '.claude/settings.json' : '.claude/settings.local.json';
+    payload.settings_snippet = claudeLifecycleSettingsSnippet(root);
+    payload.note = 'Claude Code supports command hooks. This preview records only lifecycle boundary metadata and stores no prompt body, transcript path, or success stdout in model context.';
+  } else if (host === 'codex') {
+    payload.config_path = '.codex/hooks.json';
+    payload.settings_snippet = codexLifecycleHooksSnippet(root);
+    payload.note = 'Codex hook preview records SessionStart and marks review_due after Edit or Write PostToolUse. It stores no prompt body, transcript path, tool stdout, or tool stderr in model context.';
+  } else if (host === 'gemini') {
+    payload.config_path = '.gemini/settings.json';
+    payload.settings_snippet = geminiConfigSnippet(root);
+    payload.note = 'Gemini CLI MCP connection is supported, but lifecycle hooks are manual-only in this alpha. Use lifecycle emit commands when you need explicit Gemini boundary receipts.';
+  } else {
+    payload.config_path = 'host-managed runtime lifecycle bridge';
+    payload.settings_snippet = runtimeLifecycleProxySnippet(root);
+    payload.note = 'Runtime lifecycle bridge is a host-proxy contract, not a native config edit. An agent runtime can call the command with direct lifecycle boundary payloads while Neurain stores only metadata.';
+  }
+  if (json) return { json: true, payload };
+  const lines = [
+    `# Neurain connect ${host} lifecycle hooks [dry-run]`,
+    '',
+    `- Root: ${root}`,
+    `- Hook automation supported: ${supported ? 'yes' : 'no'}`,
+    '- No host config changed.',
+    `- Note: ${payload.note}`,
+  ];
+  if (payload.settings_snippet) {
+    lines.push('', `- Suggested config path: ${payload.config_path}`, '', '```json', payload.settings_snippet, '```');
+  }
+  lines.push('', '## Manual lifecycle commands', '', ...payload.manual_commands.map((command) => `- ${shellQuote(command)}`));
+  return { text: lines.join('\n') };
+}
+
+function lifecycleHookStatus(host) {
+  if (host === 'claude') return 'claude_code_settings_preview';
+  if (host === 'codex') return 'codex_hooks_json_preview';
+  if (host === 'runtime') return 'runtime_host_proxy_contract_preview';
+  if (host === 'gemini') return 'gemini_mcp_manual_lifecycle_only';
+  return 'manual_lifecycle_only';
+}
+
+function lifecycleHookEvents(host) {
+  if (host === 'claude') return ['SessionStart', 'UserPromptSubmit', 'Stop', 'SessionEnd'];
+  if (host === 'codex') return ['SessionStart', 'PostToolUse'];
+  if (host === 'runtime') return ['session_start', 'turn_start', 'turn_end', 'wrap_complete', 'review_due', 'review_complete', 'compaction', 'resume', 'session_end'];
+  return [];
+}
+
+function lifecycleHookMappedEvents(host) {
+  if (host === 'claude') return ['session_start', 'resume', 'compaction', 'turn_start', 'turn_end', 'session_end'];
+  if (host === 'codex') return ['session_start', 'resume', 'compaction', 'review_due'];
+  if (host === 'runtime') return lifecycleHookEvents(host);
+  return [];
+}
+
+function manualLifecycleCommands(host, root) {
+  const safeHost = ['codex', 'claude', 'gemini', 'runtime'].includes(host) ? host : 'generic';
+  return [
+    ['npx', '-y', 'neurain', 'lifecycle', 'emit', root, '--host', safeHost, '--event', 'session_start', '--session-id', `${safeHost}-session-1`, '--confirm', '1건 저장 진행'],
+    ['npx', '-y', 'neurain', 'lifecycle', 'emit', root, '--host', safeHost, '--event', 'turn_end', '--session-id', `${safeHost}-session-1`, '--turn-id', 'turn-1', '--confirm', '1건 저장 진행'],
+    ['npx', '-y', 'neurain', 'lifecycle', 'report', root, '--host', safeHost],
+  ];
+}
+
+function shellQuote(parts) {
+  return parts.map((part) => /^[A-Za-z0-9_./:=@-]+$/.test(part) ? part : JSON.stringify(part)).join(' ');
+}