llm-wiki-kit 0.2.3 → 0.2.5

package/src/fs-utils.js

@@ -14,6 +14,7 @@ import {
 } from 'fs/promises';
 import { basename, dirname, join, parse, resolve } from 'path';
 import { PROJECT_MARKERS } from './constants.js';
+import { cacheHomeRelative, dataHomeRelative, isWindows } from './platform.js';
 import { normalizeForStorage } from './redaction.js';
 
 export function homeDir() {
@@ -21,13 +22,23 @@ export function homeDir() {
 }
 
 export function dataHome() {
+  if (isWindows() && process.env.LOCALAPPDATA) return process.env.LOCALAPPDATA;
   return process.env.XDG_DATA_HOME || join(homeDir(), '.local', 'share');
 }
 
 export function cacheHome() {
+  if (isWindows() && process.env.LOCALAPPDATA) return join(process.env.LOCALAPPDATA, 'llm-wiki-kit', 'cache');
   return process.env.XDG_CACHE_HOME || join(homeDir(), '.cache');
 }
 
+export function defaultDataHome(options = {}) {
+  return join(homeDir(), dataHomeRelative(options));
+}
+
+export function defaultCacheHome(options = {}) {
+  return join(homeDir(), cacheHomeRelative(options));
+}
+
 export function kitDataDir() {
   return join(dataHome(), 'llm-wiki-kit');
 }

package/src/hook.js

@@ -7,6 +7,7 @@ import { recordProject } from './projects.js';
 import { summarizeForStorage } from './redaction.js';
 import { buildEntryFromState, clearTurnState, rememberQuestion, rememberTool } from './state.js';
 import { updateNoticeContext } from './update-notice.js';
+import { removeLegacyOmxWikiSurfaces } from './legacy-omx-wiki.js';
 import { relative } from 'path';
 
 async function readStdinJson() {
@@ -104,6 +105,13 @@ async function autoUpdateManagedProject(projectRoot, eventName) {
   }
 }
 
+async function removeLegacyWikiSurfaces(projectRoot, eventName) {
+  if (eventName !== 'SessionStart' && eventName !== 'InstructionsLoaded') return;
+  const result = await removeLegacyOmxWikiSurfaces();
+  if (!result.changed) return;
+  await appendWikiLog(projectRoot, `removed legacy oh-my-codex wiki surfaces: ${result.removed.length}`);
+}
+
 export async function handleHook(provider, explicitEvent) {
   const payload = await readStdinJson();
   payload.__provider = provider;
@@ -113,6 +121,7 @@ export async function handleHook(provider, explicitEvent) {
   await bootstrapProject(projectRoot);
   await recordProject(projectRoot, 'hook').catch(() => {});
   await autoUpdateManagedProject(projectRoot, eventName).catch(() => {});
+  await removeLegacyWikiSurfaces(projectRoot, eventName).catch(() => {});
   await appendSessionEnvelope(projectRoot, eventName, payload).catch(() => {});
   if (eventName === 'SessionStart' || eventName === 'InstructionsLoaded' || eventName === 'UserPromptSubmit') {
     await recoverStaleTurnStates(projectRoot).catch(() => []);

package/src/install.js

@@ -1,53 +1,39 @@
-import { realpathSync } from 'fs';
 import { chmod, lstat, readlink, unlink } from 'fs/promises';
-import { spawnSync } from 'child_process';
 import { join, resolve } from 'path';
-import { CLAUDE_EVENTS, CODEX_EVENTS, KIT_NAME } from './constants.js';
+import { CODEX_EVENTS, KIT_NAME } from './constants.js';
+import { detectClaudeVersion, supportedClaudeEvents } from './claude-compat.js';
 import { backupFile, exists, homeDir, readJson, safeSymlink, writeJson } from './fs-utils.js';
 import { maintenanceSummary } from './maintenance.js';
+import {
+  commandForNodeScript,
+  commandMatchesRuntime,
+  commandPaths as findCommandPaths,
+  inspectCommandPath,
+  isWindows,
+  realpathOrOriginal,
+  samePath,
+  sameResolvedPath,
+} from './platform.js';
 import { inspectProjectState } from './project-state.js';
 import { bootstrapProject } from './project.js';
 import { recordProject } from './projects.js';
 import { binPath, detectInstallSource, packageRoot, runtimeVersion } from './version.js';
 
-function shellQuote(value) {
-  return `"${String(value).replace(/(["\\$`])/g, '\\$1')}"`;
+export function hookCommand(provider, eventName, options = {}) {
+  return commandForNodeScript(binPath, ['hook', provider, eventName], options);
 }
 
-export function hookCommand(provider, eventName) {
-  return `${shellQuote(process.execPath)} ${shellQuote(binPath)} hook ${provider} ${eventName}`;
-}
-
-function llmWikiCommandPaths() {
-  const result = spawnSync('sh', ['-lc', 'which -a llm-wiki 2>/dev/null || true'], {
-    encoding: 'utf8',
-  });
-  if (result.error) return [];
-  return [...new Set(result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean))];
-}
-
-function realpathOrOriginal(path) {
-  if (!path) return null;
-  try {
-    return realpathSync(path);
-  } catch {
-    return path;
-  }
-}
-
-function sameResolvedPath(left, right) {
-  const resolvedLeft = realpathOrOriginal(left);
-  const resolvedRight = realpathOrOriginal(right);
-  return Boolean(resolvedLeft && resolvedRight && resolvedLeft === resolvedRight);
+function isKitPath(path) {
+  return String(path || '').replace(/\\/g, '/').includes('/llm-wiki-kit/');
 }
 
-function samePath(left, right) {
-  if (!left || !right) return false;
-  return resolve(left) === resolve(right);
+function isKitHookEntry(entry) {
+  const serialized = normalizeHookPathText(JSON.stringify(entry || {}));
+  return serialized.includes(KIT_NAME) || serialized.includes(normalizeHookPathText(binPath)) || serialized.includes('/llm-wiki-kit/');
 }
 
-function isKitPath(path) {
-  return String(path || '').replace(/\\/g, '/').includes('/llm-wiki-kit/');
+function normalizeHookPathText(value) {
+  return String(value || '').replace(/\\\\/g, '/').replace(/\\/g, '/');
 }
 
 async function inspectLocalBin(localBinPath) {
@@ -79,7 +65,7 @@ async function inspectLocalBin(localBinPath) {
 }
 
 async function reconcileLocalBin(localBinPath) {
-  const commandPathsBefore = llmWikiCommandPaths();
+  const commandPathsBefore = await findCommandPaths('llm-wiki');
   const localBefore = await inspectLocalBin(localBinPath);
   const alternateRuntimeCommand = commandPathsBefore.some((path) => (
     !samePath(path, localBinPath) && sameResolvedPath(path, binPath)
@@ -108,7 +94,7 @@ async function reconcileLocalBin(localBinPath) {
     await safeSymlink(binPath, localBinPath);
   }
 
-  const commandPathsAfter = llmWikiCommandPaths();
+  const commandPathsAfter = await findCommandPaths('llm-wiki');
   const localAfter = await inspectLocalBin(localBinPath);
   return {
     ...localAfter,
@@ -120,6 +106,23 @@ async function reconcileLocalBin(localBinPath) {
   };
 }
 
+async function reconcileWindowsCommand() {
+  const commandPathsBefore = await findCommandPaths('llm-wiki', { platform: 'win32' });
+  const commandPath = commandPathsBefore[0] || null;
+  const command = await inspectCommandPath(commandPath, binPath, {
+    platform: 'win32',
+    installSource: detectInstallSource(),
+  });
+  return {
+    ...command,
+    action: command.matchesRuntime ? 'skipped-windows-npm-shim-available' : 'skipped-windows-no-local-shim',
+    alternateRuntimeCommand: command.matchesRuntime,
+    commandPathsBefore,
+    commandPathsAfter: commandPathsBefore,
+    commandPath,
+  };
+}
+
 function addHook(hooks, eventName, command, options = {}) {
   hooks[eventName] = Array.isArray(hooks[eventName]) ? hooks[eventName] : [];
   const already = hooks[eventName].some((entry) => (
@@ -136,6 +139,7 @@ function addHook(hooks, eventName, command, options = {}) {
       },
     ],
   };
+  if (options.commandWindows) entry.hooks[0].commandWindows = options.commandWindows;
   if (options.matcher) entry.matcher = options.matcher;
   hooks[eventName].push(entry);
   return true;
@@ -145,24 +149,60 @@ function removeKitHooks(hooks) {
   let changed = false;
   for (const [eventName, entries] of Object.entries(hooks || {})) {
     if (!Array.isArray(entries)) continue;
-    const next = entries.filter((entry) => {
-      const serialized = JSON.stringify(entry);
-      return !serialized.includes(KIT_NAME) && !serialized.includes(binPath);
-    });
+    const next = entries.filter((entry) => !isKitHookEntry(entry));
     if (next.length !== entries.length) {
-      hooks[eventName] = next;
+      if (next.length > 0) hooks[eventName] = next;
+      else delete hooks[eventName];
       changed = true;
     }
   }
   return changed;
 }
 
+function removeUnsupportedKitClaudeHooks(hooks, supportedEvents) {
+  const supported = new Set(supportedEvents);
+  const removed = [];
+  for (const [eventName, entries] of Object.entries(hooks || {})) {
+    if (supported.has(eventName) || !Array.isArray(entries)) continue;
+    const next = entries.filter((entry) => !isKitHookEntry(entry));
+    if (next.length !== entries.length) {
+      removed.push(eventName);
+      if (next.length > 0) hooks[eventName] = next;
+      else delete hooks[eventName];
+    }
+  }
+  return [...new Set(removed)];
+}
+
+function unsupportedKitClaudeEvents(hooks, supportedEvents) {
+  const supported = new Set(supportedEvents);
+  return Object.entries(hooks || {})
+    .filter(([eventName, entries]) => (
+      !supported.has(eventName) &&
+      Array.isArray(entries) &&
+      entries.some((entry) => isKitHookEntry(entry))
+    ))
+    .map(([eventName]) => eventName)
+    .sort();
+}
+
+function hookTextIncludes(text, value) {
+  return normalizeHookPathText(text).includes(normalizeHookPathText(value));
+}
+
+function hookEventIncludesBin(entries) {
+  return hookTextIncludes(JSON.stringify(entries || {}), binPath);
+}
+
 export async function install(options = {}) {
   const workspace = resolve(options.workspace || process.cwd());
   await chmod(binPath, 0o755).catch(() => {});
-  const localBin = join(homeDir(), '.local', 'bin');
-  const localBinPath = join(localBin, 'llm-wiki');
-  const localBinResult = await reconcileLocalBin(localBinPath);
+  const platform = options.platform || process.platform;
+  const localBin = isWindows({ platform }) ? null : join(homeDir(), '.local', 'bin');
+  const localBinPath = localBin ? join(localBin, 'llm-wiki') : null;
+  const localBinResult = isWindows({ platform })
+    ? await reconcileWindowsCommand()
+    : await reconcileLocalBin(localBinPath);
   if (!options.noProject) {
     await bootstrapProject(workspace, { profile: options.profile || 'standard', recordState: true });
     await recordProject(workspace, 'install');
@@ -182,7 +222,9 @@ export async function install(options = {}) {
     }
     for (const eventName of CODEX_EVENTS) {
       const matcher = eventName === 'SessionStart' ? 'startup|resume|clear' : undefined;
-      if (addHook(codex.hooks, eventName, hookCommand('codex', eventName), { matcher })) {
+      const command = hookCommand('codex', eventName, { platform });
+      const commandWindows = isWindows({ platform }) ? hookCommand('codex', eventName, { platform: 'win32' }) : undefined;
+      if (addHook(codex.hooks, eventName, command, { matcher, commandWindows })) {
         codexChanged = true;
         changed.push(`codex:${eventName}`);
       }
@@ -196,14 +238,21 @@ export async function install(options = {}) {
   if (options.claude !== false) {
     const claude = (await readJson(claudeSettingsPath, null)) || {};
     claude.hooks = claude.hooks || {};
+    const claudeDetection = detectClaudeVersion();
+    const claudeEvents = supportedClaudeEvents(claudeDetection);
     let claudeChanged = false;
     if (options.replaceHooks && removeKitHooks(claude.hooks)) {
       claudeChanged = true;
       changed.push('claude:replaced');
     }
-    for (const eventName of CLAUDE_EVENTS) {
+    const removedUnsupported = removeUnsupportedKitClaudeHooks(claude.hooks, claudeEvents);
+    if (removedUnsupported.length > 0) {
+      claudeChanged = true;
+      changed.push(...removedUnsupported.map((eventName) => `claude:removed-unsupported:${eventName}`));
+    }
+    for (const eventName of claudeEvents) {
       const matcher = eventName === 'SessionStart' ? 'startup|resume|clear' : undefined;
-      if (addHook(claude.hooks, eventName, hookCommand('claude', eventName), { matcher })) {
+      if (addHook(claude.hooks, eventName, hookCommand('claude', eventName, { platform }), { matcher })) {
         claudeChanged = true;
         changed.push(`claude:${eventName}`);
       }
@@ -256,30 +305,47 @@ export async function uninstall(options = {}) {
 
 export async function status(options = {}) {
   const workspace = resolve(options.workspace || process.cwd());
+  const platform = options.platform || process.platform;
   const codexHooksPath = join(homeDir(), '.codex', 'hooks.json');
   const claudeSettingsPath = join(homeDir(), '.claude', 'settings.json');
   const codex = await readJson(codexHooksPath, {});
   const claude = await readJson(claudeSettingsPath, {});
-  const codexInstalled = JSON.stringify(codex.hooks || {}).includes(binPath);
-  const claudeInstalled = JSON.stringify(claude.hooks || {}).includes(binPath);
-  const commandPaths = llmWikiCommandPaths();
-  const commandPath = commandPaths[0] || null;
+  const claudeDetection = detectClaudeVersion();
+  const claudeEvents = supportedClaudeEvents(claudeDetection);
+  const claudeMissingEvents = claudeEvents.filter((eventName) => !hookEventIncludesBin(claude.hooks?.[eventName] || []));
+  const claudeUnsupportedKitEvents = unsupportedKitClaudeEvents(claude.hooks || {}, claudeEvents);
+  const codexInstalled = hookEventIncludesBin(codex.hooks || {});
+  const claudeInstalled = claudeMissingEvents.length === 0 && claudeUnsupportedKitEvents.length === 0;
+  const discoveredCommandPaths = await findCommandPaths('llm-wiki', { platform });
+  const commandPath = discoveredCommandPaths[0] || null;
   const resolvedCommandPath = realpathOrOriginal(commandPath);
   const resolvedBinPath = realpathOrOriginal(binPath);
-  const localBinPath = join(homeDir(), '.local', 'bin', 'llm-wiki');
-  const localBin = await inspectLocalBin(localBinPath);
+  const localBinPath = isWindows({ platform }) ? null : join(homeDir(), '.local', 'bin', 'llm-wiki');
+  const localBin = localBinPath
+    ? await inspectLocalBin(localBinPath)
+    : await inspectCommandPath(commandPath, binPath, { platform, installSource: detectInstallSource() });
+  const commandMatches = await commandMatchesRuntime(commandPath, binPath, {
+    platform,
+    installSource: detectInstallSource(),
+  });
   return {
     workspace,
+    platform,
     runtimeVersion: runtimeVersion(),
     packageRoot,
     installSource: detectInstallSource(),
     binPath,
     commandPath,
-    commandPaths,
-    commandMatchesRuntime: Boolean(resolvedCommandPath && resolvedBinPath && resolvedCommandPath === resolvedBinPath),
+    commandPaths: discoveredCommandPaths,
+    commandMatchesRuntime: Boolean(commandMatches || (resolvedCommandPath && resolvedBinPath && resolvedCommandPath === resolvedBinPath)),
     localBin,
     codexInstalled,
     claudeInstalled,
+    claudeVersion: claudeDetection.version || 'unknown',
+    claudeModernHooks: claudeDetection.modern,
+    claudeSupportedEvents: claudeEvents,
+    claudeMissingEvents,
+    claudeUnsupportedKitEvents,
     hooksCurrent: codexInstalled && claudeInstalled,
     codexHooksPath,
     claudeSettingsPath,

package/src/legacy-omx-wiki.js

@@ -0,0 +1,222 @@
+import { mkdtemp, rm, readdir, writeFile } from 'fs/promises';
+import { spawnSync } from 'child_process';
+import { join, resolve } from 'path';
+import { tmpdir } from 'os';
+import { backupFile, exists, homeDir, readJson, readText, writeJson, writeText } from './fs-utils.js';
+
+const CODEX_CONFIG = '.codex/config.toml';
+const TOML_TABLE = /^\s*\[([^\]]+)\]\s*$/;
+
+function normalizeTomlHeader(header) {
+  return String(header || '').replace(/\s+/g, '').replace(/'/g, '"');
+}
+
+function isLegacyOmxWikiTable(header) {
+  const normalized = normalizeTomlHeader(header);
+  if (normalized === 'mcp_servers.omx_wiki') return true;
+  return normalized.includes('oh-my-codex') &&
+    normalized.includes('.mcp_servers.omx_wiki');
+}
+
+export function removeLegacyOmxWikiTomlTables(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  const output = [];
+  let changed = false;
+  let skipping = false;
+
+  for (const line of lines) {
+    const table = line.match(TOML_TABLE);
+    if (table) {
+      skipping = isLegacyOmxWikiTable(table[1]);
+      if (skipping) {
+        changed = true;
+        continue;
+      }
+    }
+    if (!skipping) output.push(line);
+  }
+
+  if (!changed) return { changed: false, text: String(text || '') };
+  return {
+    changed: true,
+    text: `${output.join('\n').replace(/\n{3,}/g, '\n\n').replace(/\s+$/g, '')}\n`,
+  };
+}
+
+function sourceRootsFromConfig(text) {
+  const roots = new Set();
+  const sourceRe = /^\s*source\s*=\s*["']([^"']*oh-my-codex[^"']*)["']\s*$/gm;
+  let match;
+  while ((match = sourceRe.exec(String(text || '')))) {
+    roots.add(match[1]);
+  }
+  return roots;
+}
+
+function configuredPackageRoots(home, configText) {
+  const roots = new Set([
+    '/usr/lib/node_modules/oh-my-codex',
+    '/usr/local/lib/node_modules/oh-my-codex',
+    join(home, '.local', 'lib', 'node_modules', 'oh-my-codex'),
+  ]);
+  for (const root of sourceRootsFromConfig(configText)) roots.add(root);
+  for (const root of String(process.env.LLM_WIKI_KIT_OMX_WIKI_ROOTS || '').split(':').filter(Boolean)) {
+    roots.add(root);
+  }
+  return roots;
+}
+
+function safeLegacyWikiSkillDir(path) {
+  const normalized = resolve(path).replace(/\\/g, '/');
+  return /(?:^|\/)oh-my-codex(?:\/|$)/.test(normalized) &&
+    /\/skills\/wiki$/.test(normalized);
+}
+
+function safeLegacyWikiMcpPath(path) {
+  const normalized = resolve(path).replace(/\\/g, '/');
+  return /(?:^|\/)oh-my-codex(?:\/|$)/.test(normalized) &&
+    /\/\.mcp\.json$/.test(normalized);
+}
+
+async function collectCachedSkillDirs(root, maxDepth = 8) {
+  const found = [];
+  async function walk(dir, depth) {
+    if (depth < 0) return;
+    let entries = [];
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const full = join(dir, entry.name);
+      const normalized = full.replace(/\\/g, '/');
+      if (entry.name === 'node_modules' || entry.name === '.git') continue;
+      if (entry.name === 'wiki' && normalized.includes('/oh-my-codex/') && normalized.includes('/skills/wiki')) {
+        found.push(full);
+        continue;
+      }
+      await walk(full, depth - 1);
+    }
+  }
+  await walk(root, maxDepth);
+  return found;
+}
+
+async function legacyWikiSkillDirs(home, configText) {
+  const dirs = new Set();
+  for (const root of configuredPackageRoots(home, configText)) {
+    dirs.add(join(root, 'skills', 'wiki'));
+    dirs.add(join(root, 'plugins', 'oh-my-codex', 'skills', 'wiki'));
+  }
+  for (const root of [
+    join(home, '.codex', 'plugins', 'cache'),
+    join(home, '.codex', '.tmp'),
+  ]) {
+    for (const dir of await collectCachedSkillDirs(root)) dirs.add(dir);
+  }
+  return [...dirs].filter(safeLegacyWikiSkillDir);
+}
+
+async function removeSkillDir(dir) {
+  if (!(await exists(dir))) return false;
+  try {
+    await rm(dir, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (!['EACCES', 'EPERM'].includes(error?.code)) throw error;
+  }
+  if (process.env.LLM_WIKI_KIT_OMX_WIKI_SUDO === '0') return false;
+  const result = spawnSync('sudo', ['-n', 'rm', '-rf', dir], {
+    encoding: 'utf8',
+    timeout: 5000,
+  });
+  return result.status === 0 && !(await exists(dir));
+}
+
+async function removePluginMcpEntry(path) {
+  const json = await readJson(path, null);
+  if (!json?.mcpServers?.omx_wiki) return false;
+  delete json.mcpServers.omx_wiki;
+  try {
+    await writeJson(path, json);
+  } catch (error) {
+    if (!['EACCES', 'EPERM'].includes(error?.code) || !safeLegacyWikiMcpPath(path)) throw error;
+    if (process.env.LLM_WIKI_KIT_OMX_WIKI_SUDO === '0') return false;
+    const tempDir = await mkdtemp(join(tmpdir(), 'llm-wiki-kit-mcp-'));
+    const tempPath = join(tempDir, '.mcp.json');
+    await writeFile(tempPath, `${JSON.stringify(json, null, 2)}\n`, 'utf8');
+    const result = spawnSync('sudo', ['-n', 'cp', tempPath, path], {
+      encoding: 'utf8',
+      timeout: 5000,
+    });
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    if (result.status !== 0) return false;
+  }
+  return true;
+}
+
+async function removeWritablePluginMcpEntries(home, configText) {
+  const changed = [];
+  const candidates = new Set();
+  for (const root of configuredPackageRoots(home, configText)) {
+    candidates.add(join(root, 'plugins', 'oh-my-codex', '.mcp.json'));
+  }
+  for (const root of [
+    join(home, '.codex', 'plugins', 'cache'),
+    join(home, '.codex', '.tmp'),
+  ]) {
+    const dirs = await collectCachedSkillDirs(root);
+    for (const dir of dirs) {
+      candidates.add(resolve(dir, '..', '..', '.mcp.json'));
+    }
+  }
+  for (const candidate of candidates) {
+    try {
+      if (await removePluginMcpEntry(candidate)) changed.push(candidate);
+    } catch {
+      // Root-owned package manifests may be read-only to the hook user. The
+      // active Codex config cleanup is the enforcement point in that case.
+    }
+  }
+  return changed;
+}
+
+export async function removeLegacyOmxWikiSurfaces(options = {}) {
+  if (process.env.LLM_WIKI_KIT_OMX_WIKI_GUARD === '0') {
+    return { changed: false, removed: [], configChanged: false };
+  }
+
+  const home = options.home || homeDir();
+  const configPath = options.configPath || join(home, CODEX_CONFIG);
+  const originalConfig = await readText(configPath, null);
+  const removed = [];
+  let configText = originalConfig || '';
+  let configChanged = false;
+
+  if (originalConfig !== null) {
+    const cleaned = removeLegacyOmxWikiTomlTables(originalConfig);
+    if (cleaned.changed) {
+      await backupFile(configPath, 'codex-config-before-omx-wiki-removal.toml');
+      await writeText(configPath, cleaned.text);
+      configText = cleaned.text;
+      configChanged = true;
+      removed.push('codex-config:omx_wiki');
+    }
+  }
+
+  for (const dir of await legacyWikiSkillDirs(home, configText)) {
+    if (await removeSkillDir(dir)) removed.push(`skill:${dir}`);
+  }
+
+  for (const path of await removeWritablePluginMcpEntries(home, configText)) {
+    removed.push(`mcp:${path}`);
+  }
+
+  return {
+    changed: removed.length > 0,
+    removed,
+    configChanged,
+  };
+}