hypomnema 1.0.0

package/scripts/init.mjs

@@ -0,0 +1,515 @@
+#!/usr/bin/env node
+/**
+ * Hypomnema init script
+ *
+ * Sets up a new wiki directory, installs hooks, and merges settings.json.
+ * Called by /hypo:init after collecting wizard answers.
+ *
+ * Usage:
+ *   node scripts/init.mjs [options]
+ *
+ * Options:
+ *   --hypo-dir=<path>      Hypomnema root directory (default: resolves via HYPO_DIR env / hypo-config.md scan / ~/hypomnema)
+ *   --no-hooks             Skip hook installation
+ *   --codex                Also install Codex hooks (~/.codex/hooks/)
+ *   --git-remote=<url>     Git remote URL
+ *   --no-git-init          Skip git initialization
+ *   --from-remote=<url>    Clone existing Hypomnema wiki from remote and install hooks
+ *   --dry-run              Show what would be done without making changes
+ *   --help, -h             Show this help message
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync, readdirSync } from 'fs';
+import { join, basename } from 'path';
+import { homedir } from 'os';
+import { execSync, spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { expandHome, resolveHypoRoot } from './lib/hypo-root.mjs';
+
+const HOME     = homedir();
+const SCRIPT_DIR = fileURLToPath(new URL('.', import.meta.url));
+const PKG_ROOT   = join(SCRIPT_DIR, '..');
+const HOOKS_SRC  = join(PKG_ROOT, 'hooks');
+const TEMPLATES  = join(PKG_ROOT, 'templates');
+
+// ── arg parsing ──────────────────────────────────────────────────────────────
+
+function parseArgs(argv) {
+  const args = {
+    hypoDir:     resolveHypoRoot(),
+    hooks:       true,
+    codex:       false,
+    gitRemote:   null,
+    gitInit:     true,
+    dryRun:      false,
+    fromRemote:  null,
+    shellSetup:  true,
+    shellConfig: null,
+  };
+  for (const arg of argv.slice(2)) {
+    if (arg === '--help' || arg === '-h') {
+      console.log(`Usage: node scripts/init.mjs [options]
+
+Options:
+  --hypo-dir=<path>      Hypomnema root directory (default: resolves via HYPO_DIR env / hypo-config.md scan / ~/hypomnema)
+  --no-hooks             Skip hook installation
+  --codex                Also install Codex hooks (~/.codex/hooks/)
+  --git-remote=<url>     Git remote URL
+  --no-git-init          Skip git initialization
+  --from-remote=<url>    Clone existing Hypomnema wiki from remote and install hooks
+  --no-shell             Skip shell function setup (~/.zshrc / ~/.bashrc)
+  --shell-config=<path>  Shell config file path (default: auto-detect)
+  --dry-run              Show what would be done without making changes
+  --help, -h             Show this help message`);
+      process.exit(0);
+    }
+    else if (arg.startsWith('--hypo-dir='))      args.hypoDir    = expandHome(arg.slice(11));
+    else if (arg === '--no-hooks')                args.hooks      = false;
+    else if (arg === '--codex')                   args.codex      = true;
+    else if (arg.startsWith('--git-remote='))     args.gitRemote  = arg.slice(13);
+    else if (arg === '--no-git-init')             args.gitInit    = false;
+    else if (arg.startsWith('--from-remote=')) {
+      const url = arg.slice(14).trim();
+      if (!url) { console.error('Error: --from-remote requires a non-empty URL'); process.exit(1); }
+      args.fromRemote = url;
+    }
+    else if (arg === '--dry-run')                 args.dryRun     = true;
+    else if (arg === '--no-shell')                args.shellSetup = false;
+    else if (arg.startsWith('--shell-config='))   args.shellConfig = expandHome(arg.slice(15));
+  }
+  return args;
+}
+
+// ── result tracking ──────────────────────────────────────────────────────────
+
+const results = { created: [], skipped: [], merged: [], errors: [] };
+
+function log(action, path) { results[action].push(path); }
+
+// ── directory structure ──────────────────────────────────────────────────────
+
+const HYPO_DIRS = ['pages', 'projects', 'sources', 'journal/daily', 'journal/weekly', 'journal/monthly'];
+
+function ensureDir(dir, dryRun) {
+  if (existsSync(dir)) return;
+  if (!dryRun) mkdirSync(dir, { recursive: true });
+  log('created', dir);
+}
+
+// ── template copy ────────────────────────────────────────────────────────────
+
+function copyTemplate(srcName, destPath, dryRun, transform) {
+  const src = join(TEMPLATES, srcName);
+  if (!existsSync(src)) { log('errors', `template missing: ${srcName}`); return; }
+  if (existsSync(destPath)) { log('skipped', destPath); return; }
+  if (!dryRun) {
+    let content = readFileSync(src, 'utf-8');
+    content = content.replace(/YYYY-MM-DD/g, new Date().toISOString().slice(0, 10));
+    if (transform) content = transform(content);
+    writeFileSync(destPath, content);
+  }
+  log('created', destPath);
+}
+
+// ── hypo-config.md ───────────────────────────────────────────────────────────
+
+function writeHypoConfig(hypoDir, dryRun) {
+  const dest = join(hypoDir, 'hypo-config.md');
+  if (existsSync(dest)) { log('skipped', dest); return; }
+  const today = new Date().toISOString().slice(0, 10);
+  const src   = join(TEMPLATES, 'hypo-config.md');
+  const base  = existsSync(src) ? readFileSync(src, 'utf-8') : '';
+  const content = base.replace(/YYYY-MM-DD/g, today);
+  if (!dryRun) writeFileSync(dest, content);
+  log('created', dest);
+}
+
+// ── .hypoignore ──────────────────────────────────────────────────────────────
+
+function writeWikiignore(hypoDir, dryRun) {
+  const dest = join(hypoDir, '.hypoignore');
+  if (existsSync(dest)) { log('skipped', dest); return; }
+  const src  = join(TEMPLATES, '.hypoignore');
+  const content = existsSync(src) ? readFileSync(src, 'utf-8') : '';
+  if (!dryRun) writeFileSync(dest, content);
+  log('created', dest);
+}
+
+// ── hook installation ────────────────────────────────────────────────────────
+
+function loadHookMap() {
+  let cfg;
+  try {
+    cfg = JSON.parse(readFileSync(join(PKG_ROOT, 'hooks', 'hooks.json'), 'utf-8'));
+  } catch {
+    console.error(`Error: cannot read hooks/hooks.json from package root: ${PKG_ROOT}`);
+    process.exit(1);
+  }
+  if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) {
+    console.error('Error: hooks/hooks.json must be a JSON object');
+    process.exit(1);
+  }
+  if (!cfg.hooks || typeof cfg.hooks !== 'object' || Array.isArray(cfg.hooks)) {
+    console.error('Error: hooks/hooks.json must contain a "hooks" object');
+    process.exit(1);
+  }
+  function _extractCommandFileName(command) {
+    if (typeof command !== 'string') return null;
+    const matches = [...command.matchAll(/(?:^|[\/\\])([^\/\\\s"'`]+\.mjs)(?=$|[\s"'`])/g)];
+    if (matches.length > 0) return matches[matches.length - 1][1];
+    const bare = command.match(/(?:^|\s)([^\/\\\s"'`]+\.mjs)(?=$|[\s"'`])/);
+    return bare ? bare[1] : null;
+  }
+
+  function _isHookFileName(file) {
+    return typeof file === 'string' && /^[^/\\\s]+\.mjs$/.test(file.trim());
+  }
+
+  function _isHookGroup(group) {
+    return group &&
+      typeof group === 'object' &&
+      !Array.isArray(group) &&
+      Array.isArray(group.hooks) &&
+      group.hooks.length > 0 &&
+      group.hooks.every(hook =>
+        hook &&
+        typeof hook === 'object' &&
+        !Array.isArray(hook) &&
+        hook.type === 'command' &&
+        _extractCommandFileName(hook.command)
+      );
+  }
+
+  // Extract .mjs file names from both old format (string[]) and new format (hook-group object[])
+  function _extractFileNames(groups) {
+    return groups.flatMap(group => {
+      if (typeof group === 'string') return [group.trim()];
+      return group.hooks.map(hook => _extractCommandFileName(hook.command));
+    });
+  }
+
+  for (const [event, groups] of Object.entries(cfg.hooks)) {
+    const valid = Array.isArray(groups) &&
+      groups.length > 0 &&
+      groups.every(group => _isHookFileName(group) || _isHookGroup(group)) &&
+      _extractFileNames(groups).length > 0;
+    if (!valid) {
+      console.error(`Error: hooks/hooks.json "hooks.${event}" must be a non-empty array of .mjs file names or Claude hook groups`);
+      process.exit(1);
+    }
+  }
+  if (cfg.shared !== undefined && (!Array.isArray(cfg.shared) || !cfg.shared.every(f => _isHookFileName(f)))) {
+    console.error('Error: hooks/hooks.json "shared" must be an array of .mjs file names');
+    process.exit(1);
+  }
+  return Object.fromEntries(Object.entries(cfg.hooks).map(([event, groups]) => [event, _extractFileNames(groups)]));
+}
+
+function installHooks(targetDir, dryRun) {
+  if (!existsSync(HOOKS_SRC)) { log('errors', `hooks source missing: ${HOOKS_SRC}`); return; }
+  if (!dryRun) mkdirSync(targetDir, { recursive: true });
+  for (const file of readdirSync(HOOKS_SRC)) {
+    if (!file.endsWith('.mjs')) continue;
+    const dest = join(targetDir, file);
+    if (existsSync(dest)) { log('skipped', dest); continue; }
+    if (!dryRun) copyFileSync(join(HOOKS_SRC, file), dest);
+    log('created', dest);
+  }
+}
+
+function mergeSettingsJson(settingsPath, hooksDir, dryRun, hookMap) {
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try { settings = JSON.parse(readFileSync(settingsPath, 'utf-8')); } catch {
+      log('errors', `settings.json is not valid JSON — fix or back it up before re-running: ${settingsPath}`);
+      return;
+    }
+  }
+  if (!settings.hooks) settings.hooks = {};
+
+  let changed = false;
+  for (const [event, files] of Object.entries(hookMap)) {
+    if (!Array.isArray(settings.hooks[event])) settings.hooks[event] = [];
+    for (const file of files) {
+      const cmd = `node ${hooksDir.replace(HOME, '$HOME')}/${file}`;
+      const already = settings.hooks[event]
+        .flatMap(g => g.hooks || [])
+        .some(h => h.command === cmd);
+      if (already) continue;
+      settings.hooks[event].push({ hooks: [{ type: 'command', command: cmd }] });
+      log('merged', `${event}: ${file}`);
+      changed = true;
+    }
+  }
+
+  if (changed && !dryRun) {
+    mkdirSync(join(settingsPath, '..'), { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  }
+}
+
+// ── pkg git hook ────────────────────────────────────────────────────────────
+
+const PKG_GIT_HOOK_CONTENT = `#!/bin/sh
+# Auto-sync hooks/ to ~/.claude/hooks/ when hook files change.
+REPO_ROOT="$(git rev-parse --show-toplevel)"
+changed=$(git diff --name-only HEAD~1 HEAD 2>/dev/null | grep '^hooks/')
+if [ -z "$changed" ]; then
+  exit 0
+fi
+echo "[post-commit] hooks/ changed — syncing to ~/.claude/hooks/ ..."
+node "$REPO_ROOT/scripts/upgrade.mjs" --apply
+`;
+
+function writePkgJson(dryRun) {
+  const dest = join(HOME, '.claude', 'hypo-pkg.json');
+  if (!dryRun) {
+    mkdirSync(join(HOME, '.claude'), { recursive: true });
+    writeFileSync(dest, JSON.stringify({ pkgRoot: PKG_ROOT }, null, 2) + '\n');
+    log('created', dest);
+  }
+}
+
+function installPkgGitHook(dryRun) {
+  const gitDir = join(PKG_ROOT, '.git');
+  if (!existsSync(gitDir)) return;
+  const hooksDir = join(gitDir, 'hooks');
+  const hookPath = join(hooksDir, 'post-commit');
+  if (existsSync(hookPath)) { log('skipped', hookPath); return; }
+  if (!dryRun) {
+    mkdirSync(hooksDir, { recursive: true });
+    writeFileSync(hookPath, PKG_GIT_HOOK_CONTENT, { mode: 0o755 });
+  }
+  log('created', hookPath);
+}
+
+// ── shell function setup ─────────────────────────────────────────────────────
+
+const SHELL_MARKER_START = '# hypo-managed:shell-setup:start';
+const SHELL_MARKER_END   = '# hypo-managed:shell-setup:end';
+
+function shellFunctionBlock() {
+  return `${SHELL_MARKER_START}
+function claude() {
+  echo "{\\"cwd\\":\\"$(pwd)\\"}" | node "$HOME/.claude/hooks/hypo-session-start.mjs" > /dev/null 2>&1
+  command claude "$@"
+}
+${SHELL_MARKER_END}`;
+}
+
+function detectShellConfig(customPath) {
+  if (customPath) return customPath;
+  const shell = process.env.SHELL || '';
+  if (shell.includes('zsh'))  return join(HOME, '.zshrc');
+  if (shell.includes('bash')) return join(HOME, '.bashrc');
+  // fallback: prefer .zshrc if it exists, else .bashrc
+  const zshrc = join(HOME, '.zshrc');
+  return existsSync(zshrc) ? zshrc : join(HOME, '.bashrc');
+}
+
+function installShellFunction(shellConfigPath, dryRun) {
+  const block = shellFunctionBlock();
+
+  if (!existsSync(shellConfigPath)) {
+    if (!dryRun) writeFileSync(shellConfigPath, block + '\n');
+    log('created', `${shellConfigPath} (shell function)`);
+    return;
+  }
+
+  const content = readFileSync(shellConfigPath, 'utf-8');
+  const startIdx = content.indexOf(SHELL_MARKER_START);
+  const endIdx   = content.indexOf(SHELL_MARKER_END);
+
+  if (startIdx !== -1 && endIdx !== -1) {
+    // Block exists — check if already up to date
+    const existing = content.slice(startIdx, endIdx + SHELL_MARKER_END.length);
+    if (existing === block) { log('skipped', `${shellConfigPath} (shell function up to date)`); return; }
+    // Replace stale block
+    const updated = content.slice(0, startIdx) + block + content.slice(endIdx + SHELL_MARKER_END.length);
+    if (!dryRun) writeFileSync(shellConfigPath, updated);
+    log('merged', `${shellConfigPath} (shell function updated)`);
+    return;
+  }
+
+  // No block — remove any legacy wiki-session-start function first, then append
+  const legacyPattern = /\n?# Wiki session context[^\n]*\nfunction claude\(\) \{[\s\S]+?\n\}\n?/g;
+  const cleaned = content.replace(legacyPattern, '\n');
+  const appended = cleaned.trimEnd() + '\n\n' + block + '\n';
+  if (!dryRun) writeFileSync(shellConfigPath, appended);
+  log('created', `${shellConfigPath} (shell function)`);
+}
+
+// ── from-remote clone ────────────────────────────────────────────────────────
+
+function cloneFromRemote(url, hypoDir, dryRun) {
+  if (existsSync(hypoDir)) {
+    log('errors', `--from-remote: target directory already exists: ${hypoDir}. Remove it or choose a different --hypo-dir.`);
+    return false;
+  }
+  console.log(`Cloning ${url} → ${hypoDir} ...`);
+  if (!dryRun) {
+    const r = spawnSync('git', ['clone', url, hypoDir], { stdio: 'inherit' });
+    if (r.error || r.status !== 0) {
+      log('errors', `git clone failed: ${url}`);
+      return false;
+    }
+    if (!existsSync(join(hypoDir, 'hypo-config.md'))) {
+      spawnSync('rm', ['-rf', hypoDir]);
+      log('errors', `--from-remote: cloned repo is not a Hypomnema wiki (hypo-config.md missing). Removed ${hypoDir}.`);
+      return false;
+    }
+  }
+  log('created', hypoDir);
+  return true;
+}
+
+// ── git setup ────────────────────────────────────────────────────────────────
+
+function git(hypoDir, args, opts = {}) {
+  return spawnSync('git', ['-C', hypoDir, ...args], { encoding: 'utf-8', ...opts });
+}
+
+function gitSetup(hypoDir, remote, dryRun) {
+  const isGit = existsSync(join(hypoDir, '.git'));
+  if (!isGit) {
+    if (!dryRun) {
+      const r = spawnSync('git', ['init', hypoDir], { stdio: 'ignore' });
+      if (r.error || r.status !== 0) {
+        log('errors', `git init failed in ${hypoDir}`);
+        return;
+      }
+    }
+    log('created', join(hypoDir, '.git'));
+  }
+  if (remote) {
+    const existing = git(hypoDir, ['remote', 'get-url', 'origin']);
+    if (existing.status === 0) {
+      const url = existing.stdout.trim();
+      if (url !== remote) log('skipped', `remote origin already set to ${url}`);
+    } else {
+      if (!dryRun) git(hypoDir, ['remote', 'add', 'origin', remote], { stdio: 'ignore' });
+      log('merged', `git remote origin → ${remote}`);
+    }
+  }
+}
+
+// ── first commit + push ──────────────────────────────────────────────────────
+
+function firstCommit(hypoDir, remote, dryRun) {
+  const logR = git(hypoDir, ['log', '--oneline', '-1']);
+  if (logR.status === 0 && logR.stdout.trim()) {
+    log('skipped', 'first commit (repo already has commits)');
+    return;
+  }
+  const today = new Date().toISOString().slice(0, 10);
+  if (!dryRun) {
+    git(hypoDir, ['add', '-A'], { stdio: 'ignore' });
+    const commitR = git(hypoDir, ['commit', '-m', `chore: init hypomnema (${today})`]);
+    if (commitR.status !== 0) { log('errors', 'first commit failed'); return; }
+    if (remote) {
+      const actualOrigin = git(hypoDir, ['remote', 'get-url', 'origin']);
+      const pushTarget = actualOrigin.status === 0 ? actualOrigin.stdout.trim() : remote;
+      const pushR = git(hypoDir, ['push', '-u', 'origin', 'HEAD']);
+      if (pushR.status !== 0) log('errors', `git push failed: ${(pushR.stderr || '').trim()}`);
+      else log('merged', `pushed to ${pushTarget}`);
+    }
+  }
+  log('created', `first commit (${today})`);
+}
+
+// ── main ─────────────────────────────────────────────────────────────────────
+
+const args = parseArgs(process.argv);
+
+// Validate hooks.json before any file writes so a bad package leaves no partial state
+const HOOK_MAP = (args.hooks || args.codex) ? loadHookMap() : null;
+
+if (args.fromRemote) {
+  // ── from-remote path: clone → read config → install hooks ──────────────────
+  const cloned = cloneFromRemote(args.fromRemote, args.hypoDir, args.dryRun);
+  if (!cloned) {
+    console.error(results.errors.join('\n'));
+    process.exit(1);
+  }
+} else {
+  // ── normal path: create structure + templates ───────────────────────────────
+  // 1. wiki directory structure
+  ensureDir(args.hypoDir, args.dryRun);
+  for (const d of HYPO_DIRS) ensureDir(join(args.hypoDir, d), args.dryRun);
+
+  // 2. template files
+  copyTemplate('index.md',          join(args.hypoDir, 'index.md'),          args.dryRun);
+  copyTemplate('hot.md',            join(args.hypoDir, 'hot.md'),            args.dryRun);
+  copyTemplate('log.md',            join(args.hypoDir, 'log.md'),            args.dryRun);
+  copyTemplate('SCHEMA.md',         join(args.hypoDir, 'SCHEMA.md'),         args.dryRun);
+  copyTemplate('hypo-guide.md',     join(args.hypoDir, 'hypo-guide.md'),     args.dryRun);
+  copyTemplate('Home.md',           join(args.hypoDir, 'Home.md'),           args.dryRun);
+  copyTemplate('Overview.md',       join(args.hypoDir, 'Overview.md'),       args.dryRun);
+  copyTemplate('hypo-help.md',      join(args.hypoDir, 'hypo-help.md'),      args.dryRun);
+  copyTemplate('hypo-automation.md',join(args.hypoDir, 'hypo-automation.md'),args.dryRun);
+  copyTemplate('session-state.md',  join(args.hypoDir, 'session-state.md'),  args.dryRun);
+  copyTemplate(join('pages', '_index.md'), join(args.hypoDir, 'pages', '_index.md'), args.dryRun);
+
+  // projects/_template structure
+  ensureDir(join(args.hypoDir, 'projects', '_template'), args.dryRun);
+  ensureDir(join(args.hypoDir, 'projects', '_template', 'decisions'), args.dryRun);
+  ensureDir(join(args.hypoDir, 'projects', '_template', 'session-log'), args.dryRun);
+  copyTemplate(join('projects', '_template', 'hot.md'),          join(args.hypoDir, 'projects', '_template', 'hot.md'),          args.dryRun);
+  copyTemplate(join('projects', '_template', 'index.md'),        join(args.hypoDir, 'projects', '_template', 'index.md'),        args.dryRun);
+  copyTemplate(join('projects', '_template', 'prd.md'),          join(args.hypoDir, 'projects', '_template', 'prd.md'),          args.dryRun);
+  copyTemplate(join('projects', '_template', 'session-state.md'),join(args.hypoDir, 'projects', '_template', 'session-state.md'),args.dryRun);
+
+  // 3. hypo-config.md + .hypoignore
+  writeHypoConfig(args.hypoDir, args.dryRun);
+  writeWikiignore(args.hypoDir, args.dryRun);
+}
+
+// 4. hooks
+
+if (args.hooks) {
+  const claudeHooks = join(HOME, '.claude', 'hooks');
+  installHooks(claudeHooks, args.dryRun);
+  mergeSettingsJson(join(HOME, '.claude', 'settings.json'), claudeHooks, args.dryRun, HOOK_MAP);
+  writePkgJson(args.dryRun);
+}
+
+// 5. shell function (claude wrapper)
+if (args.shellSetup) {
+  const shellConfigPath = detectShellConfig(args.shellConfig);
+  installShellFunction(shellConfigPath, args.dryRun);
+}
+
+// 6. codex hooks (optional)
+if (args.codex) {
+  const codexHooks = join(HOME, '.codex', 'hooks');
+  installHooks(codexHooks, args.dryRun);
+  mergeSettingsJson(join(HOME, '.codex', 'settings.json'), codexHooks, args.dryRun, HOOK_MAP);
+}
+
+// 7. git setup (skip when cloned from remote — already has .git + remote)
+if (args.gitInit && !args.fromRemote) {
+  gitSetup(args.hypoDir, args.gitRemote, args.dryRun);
+}
+
+// 8. pkg repo git hook (auto-sync hooks/ → ~/.claude/hooks/ on commit)
+if (args.hooks) {
+  installPkgGitHook(args.dryRun);
+}
+
+// 9. first commit + push (skip when cloned from remote — already has commits)
+if (args.gitInit && !args.fromRemote) {
+  firstCommit(args.hypoDir, args.gitRemote, args.dryRun);
+}
+
+// ── report ───────────────────────────────────────────────────────────────────
+
+const lines = [];
+if (results.created.length)  lines.push(`✓ Created (${results.created.length}):\n${results.created.map(p => `  ${p}`).join('\n')}`);
+if (results.skipped.length)  lines.push(`⊘ Skipped / already exists (${results.skipped.length}):\n${results.skipped.map(p => `  ${p}`).join('\n')}`);
+if (results.merged.length)   lines.push(`↪ Merged into settings.json:\n${results.merged.map(p => `  ${p}`).join('\n')}`);
+if (results.errors.length)   lines.push(`✗ Errors:\n${results.errors.map(p => `  ${p}`).join('\n')}`);
+
+if (args.dryRun) lines.unshift('[DRY RUN — no changes made]');
+
+console.log(lines.join('\n\n'));
+if (results.errors.length) process.exit(1);

package/scripts/lib/frontmatter.mjs

@@ -0,0 +1,11 @@
+export function parseFrontmatter(content) {
+  const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return null;
+  const fm = {};
+  for (const line of m[1].split(/\r?\n/)) {
+    const idx = line.indexOf(':');
+    if (idx < 0) continue;
+    fm[line.slice(0, idx).trim()] = line.slice(idx + 1).trim().replace(/\s*#.*$/, '').replace(/^["']|["']$/g, '');
+  }
+  return fm;
+}

package/scripts/lib/hypo-ignore.mjs

@@ -0,0 +1,54 @@
+import { existsSync, readFileSync } from 'fs';
+import { join, relative, basename } from 'path';
+
+export function loadHypoIgnore(hypoDir) {
+  const ignorePath = join(hypoDir, '.hypoignore');
+  if (!existsSync(ignorePath)) return [];
+  return readFileSync(ignorePath, 'utf-8')
+    .split('\n')
+    .map(l => l.trim())
+    .filter(l => l && !l.startsWith('#'));
+}
+
+function globToRegex(glob) {
+  return new RegExp('^' +
+    glob
+      .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+      .replace(/\*\*/g, '\x00')   // placeholder before single-* replacement
+      .replace(/\*/g, '[^/]*')
+      .replace(/\?/g, '[^/]')
+      .replace(/\x00/g, '.*')     // restore ** → .*
+  + '$');
+}
+
+export function isIgnored(filePath, hypoDir, patterns) {
+  const rel = relative(hypoDir, filePath).replace(/\\/g, '/');
+  const base = basename(filePath);
+
+  for (const pattern of patterns) {
+    const isDir = pattern.endsWith('/');
+    if (isDir) {
+      const dir = pattern.slice(0, -1);
+      const isAnchored = dir.includes('/');
+      if (isAnchored) {
+        // e.g. pages/journal/ — anchored to wiki root, match prefix
+        const re = globToRegex(dir);
+        const parts = rel.split('/');
+        for (let i = dir.split('/').length; i <= parts.length; i++) {
+          if (re.test(parts.slice(0, i).join('/'))) return true;
+        }
+      } else {
+        // e.g. node_modules/ — unanchored, match any single component
+        const re = globToRegex(dir);
+        for (const part of rel.split('/')) {
+          if (re.test(part)) return true;
+        }
+      }
+      continue;
+    }
+    const hasSlash = pattern.includes('/');
+    const target = hasSlash ? rel : base;
+    if (globToRegex(pattern).test(target)) return true;
+  }
+  return false;
+}

package/scripts/lib/hypo-root.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * hypo-root.mjs — resolve the Hypomnema root directory
+ *
+ * Resolution order:
+ *   1. HYPO_DIR environment variable
+ *   2. Scan common locations for hypo-config.md marker
+ *   3. Default: ~/hypomnema
+ */
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const HOME = homedir();
+
+/**
+ * Expand leading ~/ to the user's home directory.
+ * @param {string} p
+ * @returns {string}
+ */
+export function expandHome(p) {
+  if (p === '~') return HOME;
+  if (p.startsWith('~/') || p.startsWith('~\\')) return join(HOME, p.slice(2));
+  return p;
+}
+
+/**
+ * Resolve the Hypomnema root directory.
+ * Checks HYPO_DIR env → hypo-config.md scan → ~/hypomnema default.
+ * @returns {string} absolute path to Hypomnema root
+ */
+export function resolveHypoRoot() {
+  if (process.env.HYPO_DIR) {
+    return expandHome(process.env.HYPO_DIR);
+  }
+
+  const candidates = [
+    join(HOME, 'hypomnema'),
+    join(HOME, 'wiki'),
+    join(HOME, 'notes'),
+    join(HOME, 'knowledge'),
+    join(HOME, 'Documents', 'hypomnema'),
+    join(HOME, 'Documents', 'wiki'),
+    join(HOME, 'Documents', 'notes'),
+  ];
+
+  for (const c of candidates) {
+    if (existsSync(join(c, 'hypo-config.md'))) return c;
+  }
+
+  return join(HOME, 'hypomnema');
+}