@fugui200/llmwiki 0.1.2-beta.0

package/scripts/init-project.js

@@ -0,0 +1,704 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * llmwiki init - configure project-level LLM Wiki integration.
+ *
+ * Examples:
+ *   llmwiki init --agent claude-code
+ *   llmwiki init --agent codex
+ *   llmwiki init --agent gemini
+ *   llmwiki init --agent all
+ *   llmwiki init --profile local --agent codex
+ *   llmwiki init --workspace --profile team --wiki-root /path/to/team-wiki --agent claude-code
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { writeProjectConfig, writeWorkspaceConfig } = require('./classify-project');
+
+const LLMWIKI_CONTEXT_BLOCK_START = '<!-- LLMWIKI:START -->';
+const LLMWIKI_CONTEXT_BLOCK_END = '<!-- LLMWIKI:END -->';
+const STOP_HOOK_COMMAND = [
+  'if [ -d ~/.llmwiki/.git ]; then',
+  'echo \'[LLM Wiki] 如果本次工作产出了新知识',
+  '（架构决策、经验模式、踩坑记录等），',
+  '可以说「归档到 llmwiki」来沉淀。\'; fi',
+].join(' ');
+
+const AGENT_OPTIONS = [
+  { id: 'claude-code', name: 'Claude Code', description: '.claude/settings.json hooks' },
+  { id: 'codex', name: 'Codex CLI', description: 'global hooks + marker' },
+  { id: 'gemini', name: 'Gemini CLI', description: 'GEMINI.md context' },
+  { id: 'all', name: 'All agents', description: 'install every integration' },
+];
+
+function parseArgs(argv) {
+  if (argv[0] === 'init') argv = argv.slice(1);
+  const out = {
+    agent: null,
+    workspace: false,
+    workspaceAsked: false,
+    profile: null,
+    wikiRoot: null,
+    branch: null,
+    help: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === 'help' || arg === '--help' || arg === '-h') {
+      out.help = true;
+    } else if (arg === '--workspace') {
+      out.workspace = true;
+      out.workspaceAsked = true;
+    } else if (arg === '--profile') {
+      out.profile = argv[i + 1] || null;
+      i += 1;
+    } else if (arg.startsWith('--profile=')) {
+      out.profile = arg.slice('--profile='.length);
+    } else if (arg === '--wiki-root') {
+      out.wikiRoot = argv[i + 1] || null;
+      i += 1;
+    } else if (arg.startsWith('--wiki-root=')) {
+      out.wikiRoot = arg.slice('--wiki-root='.length);
+    } else if (arg === '--branch') {
+      out.branch = argv[i + 1] || null;
+      i += 1;
+    } else if (arg.startsWith('--branch=')) {
+      out.branch = arg.slice('--branch='.length);
+    } else if (arg === '--agent') {
+      out.agent = argv[i + 1] || null;
+      i += 1;
+    } else if (arg.startsWith('--agent=')) {
+      out.agent = arg.slice('--agent='.length);
+    } else if (!arg.startsWith('-') && !out.agent) {
+      out.agent = arg;
+    }
+  }
+
+  out.agent = normalizeAgent(out.agent);
+  return out;
+}
+
+function normalizeAgent(agent) {
+  if (!agent) return null;
+  const value = agent.toLowerCase();
+  if (['claude', 'claude-code', 'claudecode'].includes(value)) return 'claude-code';
+  if (['code', 'codex', 'openai-code'].includes(value)) return 'codex';
+  if (value === 'gemini') return 'gemini';
+  if (value === 'all') return 'all';
+  return value;
+}
+
+function showInitHelp() {
+  console.log('用法: llmwiki init [--workspace] [--profile personal|team|local] [--wiki-root <path>] [--agent <agent>]');
+  console.log('');
+  console.log('说明:');
+  console.log('  为当前项目导入指定 Agent 的 LLM Wiki 接入配置。');
+  console.log('');
+  console.log('Agent:');
+  console.log('  claude-code  写入 .claude/settings.json hooks');
+  console.log('  codex        写入 .llmwiki.json 项目标记，并安装全局 Codex hooks');
+  console.log('  gemini       写入 GEMINI.md 项目上下文入口');
+  console.log('  all          同时导入 claude-code、codex、gemini');
+  console.log('');
+  console.log('选项:');
+  console.log('  --workspace  生成 workspace 配置 .llmwiki.json，用于多子项目归属判断');
+  console.log('  --profile    设置知识库同步边界: personal | team | local');
+  console.log('  --wiki-root  设置当前项目使用的物理 wiki 根目录');
+  console.log('  --branch     设置 git 同步分支，默认 main');
+  console.log('  --help, -h   显示 init 帮助信息');
+}
+
+function createSelectionState() {
+  return {
+    cursor: 0,
+    selected: new Set(),
+    done: false,
+    cancelled: false,
+  };
+}
+
+function applySelectionKey(state, key) {
+  const next = {
+    cursor: state.cursor,
+    selected: new Set(state.selected),
+    done: state.done,
+    cancelled: state.cancelled,
+  };
+
+  if (key === 'up') {
+    next.cursor = (next.cursor - 1 + AGENT_OPTIONS.length) % AGENT_OPTIONS.length;
+  } else if (key === 'down') {
+    next.cursor = (next.cursor + 1) % AGENT_OPTIONS.length;
+  } else if (key === 'space') {
+    const id = AGENT_OPTIONS[next.cursor].id;
+    if (next.selected.has(id)) {
+      next.selected.delete(id);
+    } else if (id === 'all') {
+      next.selected = new Set(['all']);
+    } else {
+      next.selected.delete('all');
+      next.selected.add(id);
+    }
+  } else if (key === 'enter') {
+    next.done = true;
+  } else if (key === 'escape') {
+    next.cancelled = true;
+    next.done = true;
+  }
+
+  return next;
+}
+
+function keyFromChunk(chunk) {
+  return keysFromChunk(chunk)[0] || null;
+}
+
+function keysFromChunk(chunk) {
+  const value = chunk.toString('utf8');
+  const keys = [];
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    const triple = value.slice(i, i + 3);
+    if (triple === '\u001b[A') {
+      keys.push('up');
+      i += 2;
+    } else if (triple === '\u001b[B') {
+      keys.push('down');
+      i += 2;
+    } else if (char === '\u0003' || char === '\u001b') {
+      keys.push('escape');
+    } else if (char === ' ') {
+      keys.push('space');
+    } else if (char === '\r' || char === '\n') {
+      keys.push('enter');
+    }
+  }
+  return keys;
+}
+
+function renderAgentPicker(output, state, message = '') {
+  const lines = [
+    '',
+    '╭─ Choose your AI assistant ─────────────────────────╮',
+    ...AGENT_OPTIONS.map((agent, index) => {
+      const cursor = index === state.cursor ? '›' : ' ';
+      const mark = state.selected.has(agent.id) ? '●' : '○';
+      return `│ ${cursor} ${mark} ${agent.id.padEnd(12)} ${agent.name.padEnd(14)} ${agent.description.padEnd(27)} │`;
+    }),
+    '│                                                        │',
+    `│ ${message || 'Use ↑/↓ to navigate, Space to select, Enter to submit'.padEnd(54)} │`,
+    '╰────────────────────────────────────────────────────────╯',
+  ];
+
+  output.write('\u001b[2J\u001b[H');
+  output.write(lines.join('\n'));
+}
+
+function promptAgentSelection(input = process.stdin, output = process.stdout) {
+  if (!input.isTTY || !output.isTTY) return Promise.resolve(null);
+
+  let state = createSelectionState();
+  let message = '';
+
+  return new Promise(resolve => {
+    const cleanup = () => {
+      input.setRawMode(false);
+      input.pause();
+      output.write('\u001b[?25h\n');
+      input.removeListener('data', onData);
+    };
+
+    const finish = value => {
+      cleanup();
+      resolve(value);
+    };
+
+    const onData = chunk => {
+      const keys = keysFromChunk(chunk);
+      for (const key of keys) {
+        const next = applySelectionKey(state, key);
+        if (next.cancelled) {
+          finish([]);
+          return;
+        }
+        if (next.done && next.selected.size === 0) {
+          state = { ...next, done: false };
+          message = 'Select at least one agent with Space, or Esc to cancel'.padEnd(54);
+          renderAgentPicker(output, state, message);
+          return;
+        }
+        state = next;
+
+        if (state.done) {
+          finish([...state.selected]);
+          return;
+        }
+      }
+
+      message = '';
+      renderAgentPicker(output, state, message);
+    };
+
+    output.write('\u001b[?25l');
+    renderAgentPicker(output, state, message);
+    input.setRawMode(true);
+    input.resume();
+    input.on('data', onData);
+  });
+}
+
+function renderSinglePicker(output, title, options, cursor, hint = '') {
+  const lines = [
+    '',
+    `╭─ ${title} ─────────────────────────╮`,
+    ...options.map((option, index) => {
+      const pointer = index === cursor ? '›' : ' ';
+      return `│ ${pointer} ${option.label.padEnd(16)} ${option.description || ''}`.padEnd(54) + '│';
+    }),
+    '│'.padEnd(54) + '│',
+    `│ ${hint || 'Use ↑/↓ to navigate, Enter to submit'.padEnd(50)} │`,
+    '╰────────────────────────────────────╯',
+  ];
+
+  output.write('\u001b[2J\u001b[H');
+  output.write(lines.join('\n'));
+}
+
+function promptSingleSelection(title, options, input = process.stdin, output = process.stdout) {
+  if (!input.isTTY || !output.isTTY) return Promise.resolve(null);
+
+  let cursor = 0;
+  return new Promise(resolve => {
+    const cleanup = () => {
+      input.setRawMode(false);
+      input.pause();
+      output.write('\u001b[?25h\n');
+      input.removeListener('data', onData);
+    };
+
+    const finish = value => {
+      cleanup();
+      resolve(value);
+    };
+
+    const onData = chunk => {
+      for (const key of keysFromChunk(chunk)) {
+        if (key === 'escape') {
+          finish(null);
+          return;
+        }
+        if (key === 'up') cursor = (cursor - 1 + options.length) % options.length;
+        if (key === 'down') cursor = (cursor + 1) % options.length;
+        if (key === 'space' || key === 'enter') {
+          finish(options[cursor].value);
+          return;
+        }
+      }
+      renderSinglePicker(output, title, options, cursor);
+    };
+
+    output.write('\u001b[?25l');
+    renderSinglePicker(output, title, options, cursor);
+    input.setRawMode(true);
+    input.resume();
+    input.on('data', onData);
+  });
+}
+
+function promptLine(question, defaultValue = '', input = process.stdin, output = process.stdout) {
+  if (!input.isTTY || !output.isTTY) return Promise.resolve(null);
+
+  const suffix = defaultValue ? ` (${defaultValue})` : '';
+  output.write(`${question}${suffix}: `);
+  return new Promise(resolve => {
+    const onLine = line => {
+      input.pause();
+      input.removeListener('data', onData);
+      resolve(line.trim());
+    };
+    let buffer = '';
+    const onData = chunk => {
+      const text = chunk.toString('utf8');
+      buffer += text;
+      if (buffer.includes('\n') || buffer.includes('\r')) {
+        onLine(buffer.replace(/[\r\n].*$/s, ''));
+      }
+    };
+    input.resume();
+    input.on('data', onData);
+  });
+}
+
+function buildInteractiveConfigOptions(args, answers = {}) {
+  return {
+    workspace: args.workspaceAsked ? args.workspace : Boolean(answers.workspace),
+    profile: args.profile || answers.profile || null,
+    wikiRoot: args.wikiRoot || answers.wikiRoot || null,
+    branch: args.branch || null,
+  };
+}
+
+function defaultWikiRootForProfile(profile) {
+  if (profile === 'local') return '.llmwiki-local';
+  if (profile === 'team') return null;
+  return '~/.llmwiki';
+}
+
+async function promptInteractiveConfig(args, input = process.stdin, output = process.stdout) {
+  if (!input.isTTY || !output.isTTY) return args;
+
+  const workspace = args.workspaceAsked
+    ? args.workspace
+    : await promptSingleSelection('LLM Wiki Scope', [
+      { label: 'project', value: false, description: 'single repo' },
+      { label: 'workspace', value: true, description: 'multi repo root' },
+    ], input, output);
+
+  const profile = args.profile || await promptSingleSelection('LLM Wiki Profile', [
+    { label: 'personal', value: 'personal', description: 'personal knowledge' },
+    { label: 'team', value: 'team', description: 'company/team shared wiki' },
+    { label: 'local', value: 'local', description: 'local only, no push/pull' },
+  ], input, output);
+
+  const defaultRoot = defaultWikiRootForProfile(profile);
+  let wikiRoot = args.wikiRoot || await promptLine('wikiRoot', defaultRoot || '', input, output);
+  if (!wikiRoot && defaultRoot) wikiRoot = null;
+
+  if (profile === 'team') {
+    while (!wikiRoot) {
+      wikiRoot = await promptLine('team profile requires wikiRoot', '', input, output);
+    }
+  }
+
+  return {
+    ...args,
+    ...buildInteractiveConfigOptions(args, { workspace, profile, wikiRoot }),
+  };
+}
+
+function ensureGitProject(projectRoot, isWorkspace) {
+  if (!isWorkspace && !fs.existsSync(path.join(projectRoot, '.git'))) {
+    console.error('错误：当前目录不是 git 仓库根目录');
+    process.exit(1);
+  }
+}
+
+function ensureArrayHook(settings, eventName) {
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks[eventName]) settings.hooks[eventName] = [];
+}
+
+function upsertCommandHook(hookList, command, options = {}) {
+  const matchTexts = options.matchTexts || [options.matchText || 'llmwiki', 'LLM Wiki'];
+  for (const entry of hookList) {
+    for (const hook of entry.hooks || []) {
+      if (hook.command && matchTexts.some(text => hook.command.includes(text))) {
+        hook.command = command;
+        if (options.timeout) hook.timeout = options.timeout;
+        return 'updated';
+      }
+    }
+  }
+
+  const hook = {
+    type: 'command',
+    command,
+  };
+  if (options.timeout) hook.timeout = options.timeout;
+
+  hookList.push({
+    matcher: options.matcher || '',
+    hooks: [hook],
+  });
+  return 'installed';
+}
+
+function removeCommandHooks(hookList, matchTexts = ['llmwiki', 'LLM Wiki']) {
+  let removed = false;
+  for (let i = hookList.length - 1; i >= 0; i -= 1) {
+    const entry = hookList[i];
+    const nextHooks = (entry.hooks || []).filter(hook => {
+      const shouldRemove = hook.command && matchTexts.some(text => hook.command.includes(text));
+      if (shouldRemove) removed = true;
+      return !shouldRemove;
+    });
+    if (nextHooks.length) {
+      entry.hooks = nextHooks;
+    } else {
+      hookList.splice(i, 1);
+    }
+  }
+  return removed;
+}
+
+function buildAgentContextBlock() {
+  return [
+    LLMWIKI_CONTEXT_BLOCK_START,
+    '# LLM Wiki',
+    '',
+    '本项目已接入 LLM Wiki。默认只使用 `.llmwiki.json` 做项目归属和归档路由判断。',
+    '',
+    '- 普通对话、启动和 clear 后不要自动读取全局 wiki 页面。',
+    '- 用户明确要求召回/归档，或任务明显需要历史项目知识时，再按需召回。',
+    '- 召回时先运行 `llmwiki classify` 判断当前项目归属。',
+    '- 优先读取当前 archiveProjects 对应页面；公共 patterns/tools/concepts 只在关键词命中后读取。',
+    '- 归档时更新对应 wiki 页面，并维护索引和日志。',
+    LLMWIKI_CONTEXT_BLOCK_END,
+  ].join('\n');
+}
+
+function upsertContextBlock(filePath) {
+  const block = buildAgentContextBlock();
+  let content = '';
+  if (fs.existsSync(filePath)) {
+    content = fs.readFileSync(filePath, 'utf8').trimEnd();
+  }
+
+  const pattern = new RegExp(`${LLMWIKI_CONTEXT_BLOCK_START}[\\s\\S]*?${LLMWIKI_CONTEXT_BLOCK_END}`);
+  const nextContent = pattern.test(content)
+    ? `${content.replace(pattern, block)}\n`
+    : `${content ? `${content}\n\n` : ''}${block}\n`;
+
+  fs.writeFileSync(filePath, nextContent);
+}
+
+function installClaudeCode(projectRoot) {
+  const claudeDir = path.join(projectRoot, '.claude');
+  const settingsPath = path.join(claudeDir, 'settings.json');
+  const claudePath = path.join(projectRoot, 'CLAUDE.md');
+  fs.mkdirSync(claudeDir, { recursive: true });
+
+  let settings = {};
+  if (fs.existsSync(settingsPath)) {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  }
+
+  ensureArrayHook(settings, 'Stop');
+  if (settings.hooks.UserPromptSubmit) {
+    removeCommandHooks(settings.hooks.UserPromptSubmit, ['llmwiki', 'LLM Wiki', 'yahallmwiki', 'Yaha Wiki']);
+  }
+  const stopStatus = upsertCommandHook(settings.hooks.Stop, STOP_HOOK_COMMAND);
+  upsertContextBlock(claudePath);
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, '\t') + '\n');
+  console.log(`✓ Claude Code hook/context 已${stopStatus === 'updated' ? '更新' : '导入'}: .claude/settings.json, CLAUDE.md`);
+}
+
+function installCodex(projectRoot) {
+  const result = installCodexGlobalHooks();
+  console.log('✓ Codex 接入已标记: .llmwiki.json');
+  if (result.status === 'installed') {
+    console.log(`✓ Codex 全局 hook 已写入: ${result.hooksPath}`);
+  } else if (result.status === 'updated') {
+    console.log(`✓ Codex 全局 hook 已更新: ${result.hooksPath}`);
+  } else if (result.status === 'unchanged') {
+    console.log(`✓ Codex 全局 hook 已存在: ${result.hooksPath}`);
+  } else {
+    console.log(`⚠ Codex 全局 hook 未写入: ${result.reason}`);
+  }
+  console.log('  Codex hook 只注入项目归属元数据；需要召回时再按需读取 wiki。');
+}
+
+function resolveCodexHome() {
+  return process.env.CODEX_HOME
+    ? path.resolve(process.env.CODEX_HOME)
+    : path.join(os.homedir(), '.codex');
+}
+
+function buildCodexHookCommand() {
+  return `"${process.execPath}" "${path.join(__dirname, 'codex-hook.js')}"`;
+}
+
+function ensureCodexEventHook(settings, eventName, hookCommand, options = {}) {
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks[eventName]) settings.hooks[eventName] = [];
+
+  let changed = false;
+  for (const entry of settings.hooks[eventName]) {
+    for (const hook of entry.hooks || []) {
+      if (hook.command && hook.command.includes('codex-hook.js')) {
+        if (hook.command !== hookCommand) {
+          hook.command = hookCommand;
+          changed = true;
+        }
+        return changed ? 'updated' : 'unchanged';
+      }
+    }
+  }
+
+  const entry = {
+    hooks: [
+      {
+        type: 'command',
+        command: hookCommand,
+      },
+    ],
+  };
+  if (options.matcher) entry.matcher = options.matcher;
+  settings.hooks[eventName].push(entry);
+  return 'installed';
+}
+
+function removeCodexEventHook(settings, eventName) {
+  if (!settings.hooks || !settings.hooks[eventName]) return false;
+  return removeCommandHooks(settings.hooks[eventName], ['codex-hook.js']);
+}
+
+function installCodexGlobalHooks() {
+  const codexHome = resolveCodexHome();
+  const hooksPath = path.join(codexHome, 'hooks.json');
+  const hookCommand = buildCodexHookCommand();
+  let settings = {};
+
+  try {
+    fs.mkdirSync(codexHome, { recursive: true });
+    if (fs.existsSync(hooksPath)) {
+      settings = JSON.parse(fs.readFileSync(hooksPath, 'utf8'));
+    }
+
+    const sessionStatus = ensureCodexEventHook(settings, 'SessionStart', hookCommand, {
+      matcher: 'startup|resume|clear',
+    });
+    const promptRemoved = removeCodexEventHook(settings, 'UserPromptSubmit');
+
+    if (sessionStatus === 'unchanged' && !promptRemoved) {
+      return { status: 'unchanged', hooksPath };
+    }
+
+    fs.writeFileSync(hooksPath, JSON.stringify(settings, null, 2) + '\n');
+    return {
+      status: sessionStatus === 'installed' ? 'installed' : 'updated',
+      hooksPath,
+    };
+  } catch (error) {
+    return {
+      status: 'failed',
+      hooksPath,
+      reason: error.message,
+    };
+  }
+}
+
+function installGemini(projectRoot) {
+  const geminiPath = path.join(projectRoot, 'GEMINI.md');
+  upsertContextBlock(geminiPath);
+  console.log('✓ Gemini context 已导入: GEMINI.md');
+}
+
+function expandAgent(agent) {
+  return agent === 'all'
+    ? AGENT_OPTIONS.filter(option => option.id !== 'all').map(option => option.id)
+    : [agent];
+}
+
+function installAgent(projectRoot, agent) {
+  if (agent === 'claude-code') {
+    installClaudeCode(projectRoot);
+  } else if (agent === 'codex') {
+    installCodex(projectRoot);
+  } else if (agent === 'gemini') {
+    installGemini(projectRoot);
+  } else {
+    console.error(`错误：不支持的 agent: ${agent}`);
+    showInitHelp();
+    process.exit(1);
+  }
+}
+
+function installAgents(projectRoot, agents) {
+  for (const agent of agents) {
+    installAgent(projectRoot, agent);
+  }
+}
+
+async function main() {
+  const projectRoot = process.cwd();
+  let args = parseArgs(process.argv.slice(2));
+
+  if (args.help) {
+    showInitHelp();
+    return;
+  }
+
+  let wikiConfigWritten = false;
+  const writeWikiConfig = () => {
+    const configOptions = {
+      profile: args.profile || (args.workspace && args.wikiRoot ? 'team' : undefined),
+      wikiRoot: args.wikiRoot || undefined,
+      branch: args.branch || undefined,
+    };
+
+    if (args.workspace) {
+      const { configPath, config } = writeWorkspaceConfig(projectRoot, configOptions);
+      console.log(`✓ workspace 配置已写入 ${path.relative(projectRoot, configPath)}`);
+      console.log(`  - workspace: ${config.name}`);
+      console.log(`  - profile: ${config.profile}`);
+      console.log(`  - wikiRoot: ${config.wikiRoot}`);
+      console.log(`  - sync: ${config.sync.type}${config.sync.branch ? ` ${config.sync.branch}` : ''}`);
+      console.log(`  - projects: ${Object.keys(config.projectRoots).join(', ') || '(none detected)'}`);
+      wikiConfigWritten = true;
+      return;
+    }
+
+    const { configPath, config } = writeProjectConfig(projectRoot, configOptions);
+    console.log(`✓ project 配置已写入 ${path.relative(projectRoot, configPath)}`);
+    console.log(`  - project: ${config.name}`);
+    console.log(`  - profile: ${config.profile}`);
+    console.log(`  - wikiRoot: ${config.wikiRoot}`);
+    console.log(`  - sync: ${config.sync.type}${config.sync.branch ? ` ${config.sync.branch}` : ''}`);
+    wikiConfigWritten = true;
+  };
+
+  if (!args.agent) {
+    const selectedAgents = await promptAgentSelection();
+    if (selectedAgents && selectedAgents.length) {
+      args = await promptInteractiveConfig(args);
+      ensureGitProject(projectRoot, args.workspace);
+      if (args.workspace && !args.profile && !args.wikiRoot) {
+        throw new Error('workspace init requires --profile or --wiki-root');
+      }
+      if (!wikiConfigWritten) writeWikiConfig();
+      installAgents(projectRoot, selectedAgents);
+      return;
+    }
+
+    console.log('请选择 agent 后再导入对应接入：');
+    console.log('  llmwiki init --agent claude-code');
+    console.log('  llmwiki init --agent codex');
+    console.log('  llmwiki init --agent gemini');
+    console.log('  llmwiki init --agent all');
+    return;
+  }
+
+  ensureGitProject(projectRoot, args.workspace);
+  if (args.workspace && !args.profile && !args.wikiRoot) {
+    throw new Error('workspace init requires --profile or --wiki-root');
+  }
+
+  if (args.workspace) {
+    writeWikiConfig();
+  }
+  if (!wikiConfigWritten) writeWikiConfig();
+  installAgents(projectRoot, expandAgent(args.agent));
+}
+
+if (require.main === module) {
+  main().catch(error => {
+    console.error(error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  applySelectionKey,
+  buildInteractiveConfigOptions,
+  createSelectionState,
+  keyFromChunk,
+  keysFromChunk,
+  installCodexGlobalHooks,
+  main,
+};

package/skill/llmwiki-connector/.skill-meta.json

@@ -0,0 +1,5 @@
+{
+  "name": "llmwiki-connector",
+  "version": "0.1.0",
+  "description": "连接 LLM Wiki 与当前项目，提供知识召回、归档能力"
+}