@fugui200/llmwiki 0.1.2-beta.0

package/scripts/classify-project.js

@@ -0,0 +1,403 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_FILE = '.llmwiki.json';
+const DEFAULT_WIKI_ROOT = '~/.llmwiki';
+const LOCAL_WIKI_ROOT = '.llmwiki-local';
+const DEFAULT_PROFILE = 'personal';
+const DEFAULT_SYNC_BRANCH = 'main';
+
+function normalizePath(filePath) {
+  return filePath.replaceAll(path.sep, '/');
+}
+
+function normalizeProjectName(name) {
+  if (name === '.llmwiki') return 'llmwiki';
+  if (name.startsWith('.') && name.length > 1) return name.slice(1);
+  return name;
+}
+
+function projectNameFromPackage(root) {
+  const packagePath = path.join(root, 'package.json');
+  if (!fs.existsSync(packagePath)) return null;
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    const name = typeof pkg.name === 'string' ? pkg.name.split('/').pop() : null;
+    return name ? normalizeProjectName(name) : null;
+  } catch {
+    return null;
+  }
+}
+
+function defaultNameFromRoot(root) {
+  const absoluteRoot = path.resolve(root);
+  return projectNameFromPackage(absoluteRoot) || normalizeProjectName(path.basename(absoluteRoot));
+}
+
+function discoverProjectRoots(workspaceRoot) {
+  const out = {};
+  if (!fs.existsSync(workspaceRoot)) return out;
+
+  for (const entry of fs.readdirSync(workspaceRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith('.')) continue;
+
+    const child = path.join(workspaceRoot, entry.name);
+    if (fs.existsSync(path.join(child, '.git'))) {
+      out[entry.name] = entry.name;
+    }
+  }
+
+  return Object.fromEntries(Object.entries(out).sort(([a], [b]) => a.localeCompare(b)));
+}
+
+function normalizeProfile(profile) {
+  const value = profile || DEFAULT_PROFILE;
+  if (['personal', 'team', 'local'].includes(value)) return value;
+  throw new Error(`unsupported profile: ${value}`);
+}
+
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+
+function createSyncConfig(profile, options = {}) {
+  if (options.sync) return options.sync;
+  if (profile === 'local') return { type: 'none' };
+  return {
+    type: 'git',
+    branch: options.branch || DEFAULT_SYNC_BRANCH,
+  };
+}
+
+function createWikiRoot(profile, options = {}) {
+  const hasWikiRoot = hasOwn(options, 'wikiRoot') && options.wikiRoot;
+  if (profile === 'team' && !hasWikiRoot) {
+    throw new Error('team profile requires --wiki-root');
+  }
+  if (hasWikiRoot) return options.wikiRoot;
+  if (profile === 'local') return LOCAL_WIKI_ROOT;
+  return DEFAULT_WIKI_ROOT;
+}
+
+function createWorkspaceConfig(workspaceRoot, options = {}) {
+  const name = options.name || defaultNameFromRoot(workspaceRoot);
+  const profile = normalizeProfile(options.profile);
+  return {
+    version: 1,
+    type: 'workspace',
+    name,
+    profile,
+    wikiRoot: createWikiRoot(profile, options),
+    sync: createSyncConfig(profile, options),
+    projectRoots: options.projectRoots || discoverProjectRoots(workspaceRoot),
+    projectAliases: options.projectAliases || {},
+    defaultProject: options.defaultProject || name,
+  };
+}
+
+function createProjectConfig(projectRoot, options = {}) {
+  const name = options.name || defaultNameFromRoot(projectRoot);
+  const profile = normalizeProfile(options.profile);
+  return {
+    version: 1,
+    type: 'project',
+    name,
+    profile,
+    wikiRoot: createWikiRoot(profile, options),
+    sync: createSyncConfig(profile, options),
+  };
+}
+
+function expandHome(filePath) {
+  const home = process.env.HOME || '';
+  if (filePath === '~' || filePath === '$HOME') return home;
+  if (filePath && filePath.startsWith('~/')) {
+    return path.join(home, filePath.slice(2));
+  }
+  if (filePath && filePath.startsWith('$HOME/')) {
+    return path.join(home, filePath.slice('$HOME/'.length));
+  }
+  return filePath;
+}
+
+function resolveWikiRoot(config, configDir = process.cwd()) {
+  const rawRoot = createWikiRoot(normalizeProfile(config.profile), config);
+  const expanded = expandHome(rawRoot);
+  return path.isAbsolute(expanded)
+    ? path.resolve(expanded)
+    : path.resolve(configDir, expanded);
+}
+
+function findConfig(startDir = process.cwd()) {
+  const match = findEffectiveConfig(startDir);
+  return match ? match.path : null;
+}
+
+function readConfigMatch(configPath) {
+  const config = loadConfig(configPath);
+  return {
+    path: configPath,
+    dir: path.dirname(configPath),
+    config,
+  };
+}
+
+function isStandaloneProjectConfig(config) {
+  return config && config.type === 'project' && config.scope === 'standalone';
+}
+
+function findConfigChain(startDir = process.cwd()) {
+  let current = path.resolve(startDir);
+  const matches = [];
+  while (true) {
+    const candidate = path.join(current, CONFIG_FILE);
+    if (fs.existsSync(candidate)) {
+      matches.push(readConfigMatch(candidate));
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) return matches;
+    current = parent;
+  }
+}
+
+function loadConfig(configPath) {
+  return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+}
+
+function findEffectiveConfig(startDir = process.cwd()) {
+  const chain = findConfigChain(startDir);
+  if (!chain.length) return null;
+
+  const nearest = chain[0];
+  if (isStandaloneProjectConfig(nearest.config)) {
+    return nearest;
+  }
+
+  return chain.find(match => match.config.type === 'workspace') || nearest;
+}
+
+function loadConfigIfExists(configPath) {
+  if (!fs.existsSync(configPath)) return {};
+  return loadConfig(configPath);
+}
+
+function writeWorkspaceConfig(workspaceRoot, options = {}) {
+  const configPath = path.join(workspaceRoot, CONFIG_FILE);
+  const existing = loadConfigIfExists(configPath);
+  const config = {
+    ...existing,
+    ...createWorkspaceConfig(workspaceRoot, { ...existing, ...options }),
+    type: 'workspace',
+  };
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+  return { configPath, config };
+}
+
+function writeProjectConfig(projectRoot, options = {}) {
+  const configPath = path.join(projectRoot, CONFIG_FILE);
+  const existing = loadConfigIfExists(configPath);
+  const config = {
+    ...existing,
+    ...createProjectConfig(projectRoot, { ...existing, ...options }),
+    type: 'project',
+  };
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+  return { configPath, config };
+}
+
+function pathMatchesProject(targetPath, workspaceRoot, projectRoot) {
+  const absoluteTarget = path.resolve(workspaceRoot, targetPath);
+  const absoluteProject = path.resolve(workspaceRoot, projectRoot);
+  const relative = path.relative(absoluteProject, absoluteTarget);
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function directoryForGitLookup(inputPath) {
+  if (fs.existsSync(inputPath)) {
+    const stat = fs.statSync(inputPath);
+    return stat.isDirectory() ? inputPath : path.dirname(inputPath);
+  }
+
+  return path.extname(inputPath) ? path.dirname(inputPath) : inputPath;
+}
+
+function findGitProjectRoot(startPath, boundaryDir) {
+  let current = path.resolve(directoryForGitLookup(startPath));
+  const boundary = path.resolve(boundaryDir);
+
+  while (true) {
+    const relativeToBoundary = path.relative(boundary, current);
+    if (relativeToBoundary.startsWith('..') || path.isAbsolute(relativeToBoundary)) {
+      return null;
+    }
+
+    if (current !== boundary && fs.existsSync(path.join(current, '.git'))) {
+      return current;
+    }
+
+    if (current === boundary) return null;
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+function projectNameFromRoot(projectRoot) {
+  return defaultNameFromRoot(projectRoot);
+}
+
+function classifyWorkspace(config, configDir, options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const paths = options.paths && options.paths.length ? options.paths : [cwd];
+  const matched = new Set();
+
+  for (const inputPath of paths) {
+    const absoluteInput = path.isAbsolute(inputPath)
+      ? inputPath
+      : path.resolve(cwd, inputPath);
+    const relativeToWorkspace = normalizePath(path.relative(configDir, absoluteInput));
+    let inputMatched = false;
+
+    for (const [projectName, projectRoot] of Object.entries(config.projectRoots || {})) {
+      if (pathMatchesProject(relativeToWorkspace, configDir, projectRoot)) {
+        matched.add(projectName);
+        inputMatched = true;
+      }
+    }
+
+    if (!inputMatched) {
+      const gitProjectRoot = findGitProjectRoot(absoluteInput, configDir);
+      if (gitProjectRoot) {
+        matched.add(projectNameFromRoot(gitProjectRoot));
+      }
+    }
+  }
+
+  if (matched.size === 0) {
+    const defaultProject = config.defaultProject || config.name;
+    const archiveProject = resolveArchiveProject(config, defaultProject);
+    return {
+      workspace: config.name,
+      matchedProjects: [defaultProject],
+      archiveProjects: [archiveProject],
+      archiveType: 'workspace',
+      suggestedPath: `wiki/projects/${archiveProject}/`,
+    };
+  }
+
+  const matchedProjects = [...matched].sort((a, b) => a.localeCompare(b));
+  const archiveProjects = uniqueSorted(matchedProjects.map(project => resolveArchiveProject(config, project)));
+  if (archiveProjects.length === 1) {
+    return {
+      workspace: config.name,
+      matchedProjects,
+      archiveProjects,
+      archiveType: 'project',
+      suggestedPath: `wiki/projects/${archiveProjects[0]}/`,
+    };
+  }
+
+  return {
+    workspace: config.name,
+    matchedProjects,
+    archiveProjects,
+    archiveType: 'synthesis',
+    suggestedPath: `wiki/synthesis/${archiveProjects.join('-') || config.name}-<topic>.md`,
+  };
+}
+
+function uniqueSorted(values) {
+  return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+
+function resolveArchiveProject(config, projectName) {
+  const aliases = config.projectAliases || {};
+  return aliases[projectName] || projectName;
+}
+
+function classifyProject(config) {
+  const projectName = config.name;
+  return {
+    workspace: null,
+    matchedProjects: [projectName],
+    archiveProjects: [projectName],
+    archiveType: 'project',
+    suggestedPath: `wiki/projects/${projectName}/`,
+  };
+}
+
+function classifyConfig(config, configDir, options = {}) {
+  if (config.type === 'workspace') {
+    return classifyWorkspace(config, configDir, options);
+  }
+
+  if (config.type === 'project') {
+    return classifyProject(config, configDir, options);
+  }
+
+  return {
+    workspace: null,
+    matchedProjects: [],
+    archiveProjects: [],
+    archiveType: 'unknown-config',
+    suggestedPath: null,
+  };
+}
+
+function classifyFromCwd(options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const match = findEffectiveConfig(cwd);
+  if (!match) {
+    return {
+      workspace: null,
+      matchedProjects: [],
+      archiveProjects: [],
+      archiveType: 'unconfigured',
+      suggestedPath: null,
+    };
+  }
+
+  return classifyConfig(match.config, match.dir, {
+    cwd,
+    paths: options.paths || [],
+  });
+}
+
+function main() {
+  const result = classifyFromCwd({ paths: process.argv.slice(2) });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  CONFIG_FILE,
+  DEFAULT_PROFILE,
+  DEFAULT_SYNC_BRANCH,
+  DEFAULT_WIKI_ROOT,
+  classifyConfig,
+  classifyFromCwd,
+  classifyProject,
+  classifyWorkspace,
+  createProjectConfig,
+  createWorkspaceConfig,
+  defaultNameFromRoot,
+  discoverProjectRoots,
+  findConfigChain,
+  findEffectiveConfig,
+  findGitProjectRoot,
+  findConfig,
+  loadConfigIfExists,
+  loadConfig,
+  resolveWikiRoot,
+  writeProjectConfig,
+  writeWorkspaceConfig,
+};

package/scripts/codex-hook.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const {
+  CONFIG_FILE,
+  classifyConfig,
+  findConfig,
+  loadConfig,
+  resolveWikiRoot,
+} = require('./classify-project');
+
+function safeObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function readStdin() {
+  return new Promise(resolve => {
+    const chunks = [];
+    process.stdin.on('data', chunk => chunks.push(Buffer.from(chunk)));
+    process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf8').trim()));
+    process.stdin.resume();
+  });
+}
+
+async function readPayload() {
+  const raw = await readStdin();
+  if (!raw) return {};
+  try {
+    return safeObject(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+}
+
+function readHookEventName(payload) {
+  const raw = String(payload.hook_event_name || payload.hookEventName || payload.event || payload.name || '').trim();
+  return raw || null;
+}
+
+function resolveCwd(payload) {
+  const cwd = String(payload.cwd || payload.project_path || payload.projectPath || '').trim();
+  return cwd ? path.resolve(cwd) : process.cwd();
+}
+
+function formatJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+
+function readLegacyProjectTargets(classification) {
+  const archiveProjects = new Set(classification.archiveProjects || []);
+  return (classification.matchedProjects || [])
+    .filter(project => !archiveProjects.has(project))
+    .map(project => `wiki/projects/${project}/`);
+}
+
+function buildAdditionalContext(cwd) {
+  const configPath = findConfig(cwd);
+  if (!configPath) return null;
+
+  const config = loadConfig(configPath);
+  const configDir = path.dirname(configPath);
+  const classification = classifyConfig(config, configDir, { cwd });
+  const wikiRoot = resolveWikiRoot(config, configDir);
+  const legacyTargets = readLegacyProjectTargets(classification);
+
+  const sections = [
+    '[LLM Wiki]',
+    `- config: ${CONFIG_FILE}`,
+    `- wikiRoot: ${wikiRoot}`,
+    `- profile: ${config.profile || 'personal'}`,
+    `- sync: ${config.sync && config.sync.type === 'none' ? 'none' : `git ${(config.sync && config.sync.branch) || 'main'}`}`,
+    `- matchedProjects: ${classification.matchedProjects.join(', ') || '(none)'}`,
+    `- archiveProjects: ${(classification.archiveProjects || []).join(', ') || '(none)'}`,
+    `- archiveTarget: ${classification.suggestedPath || '(none)'}`,
+    '',
+    'Use this as routing metadata only. Do not read or load global LLM Wiki pages at startup, after /clear, or for ordinary prompts.',
+    'Search/read wiki pages only when the user asks to recall/archive knowledge, or when the current task clearly needs prior project context.',
+    'When recall is needed, prefer current archiveProjects first; use shared patterns/tools/concepts only after keyword matching.',
+  ];
+
+  if (legacyTargets.length) {
+    sections.push(
+      '',
+      `Alias note: before writing archiveTarget, also check existing legacy project pages under ${legacyTargets.join(', ')} so earlier child-repo knowledge is not orphaned.`,
+    );
+  }
+
+  sections.push('', '## classification', formatJson(classification));
+  return sections.join('\n');
+}
+
+async function main() {
+  const payload = await readPayload();
+  const hookEventName = readHookEventName(payload);
+
+  if (hookEventName !== 'SessionStart') {
+    process.stdout.write('{}\n');
+    return;
+  }
+
+  const additionalContext = buildAdditionalContext(resolveCwd(payload));
+  if (!additionalContext) {
+    process.stdout.write('{}\n');
+    return;
+  }
+
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName,
+      additionalContext,
+    },
+  }) + '\n');
+}
+
+if (require.main === module) {
+  main().catch(error => {
+    process.stderr.write(`[llmwiki codex hook] ${error.message}\n`);
+    process.stdout.write('{}\n');
+  });
+}
+
+module.exports = {
+  buildAdditionalContext,
+  readLegacyProjectTargets,
+  resolveCwd,
+};