claudecode-omc 5.5.2 → 5.6.1

package/src/cli/plan.js

@@ -0,0 +1,220 @@
+/* eslint-disable no-console */
+const fs = require('fs');
+const fsp = require('fs/promises');
+const path = require('path');
+const { getProjectRoot, getSourceArtifactDir, getSourceMetadataDir } = require('../config/paths');
+const { buildSourceCatalog, buildInstallPlan, deriveSourceActivation } = require('../catalog/source-catalog');
+const { updateSource, readConfig } = require('../config/sources');
+
+function findUnsyncedArtifactTypes(sourceName, artifactTypes, root) {
+  return (artifactTypes || []).filter((artifactType) => {
+    const dir = getSourceArtifactDir(sourceName, artifactType, root);
+    if (!fs.existsSync(dir)) return true;
+    if (!fs.statSync(dir).isDirectory()) return false;
+    return fs.readdirSync(dir).length === 0;
+  });
+}
+
+async function readSelectionFile(selectionFile) {
+  const raw = await fsp.readFile(selectionFile, 'utf8');
+  const data = JSON.parse(raw);
+  return data && typeof data === 'object' ? data : {};
+}
+
+function extractAllowlistFromSelection(planResult, selectionData = {}) {
+  const allowlist = {};
+  const selectedArtifacts = planResult.actions.filter(action => action.type === 'install-artifact');
+  const warnings = [];
+
+  for (const action of selectedArtifacts) {
+    const requested = selectionData[action.artifactType];
+    if (!requested) continue;
+
+    const requestedNames = [...new Set(Array.isArray(requested) ? requested : [])];
+    if (requestedNames.length === 0) continue;
+
+    // Only validate against itemNames when the catalog actually expanded them.
+    // Manifest-driven surfaces (e.g. plugin.json) carry only counts, so trust
+    // the user's selection and let setup's filterItemsByAllowlist enforce
+    // membership against the real on-disk artifact list.
+    if (Array.isArray(action.itemNames) && action.itemNames.length > 0) {
+      const allowedNames = new Set(action.itemNames);
+      const unknown = requestedNames.filter(name => !allowedNames.has(name));
+      if (unknown.length > 0) {
+        throw new Error(`Unknown ${action.artifactType} selections: ${unknown.join(', ')}`);
+      }
+    } else {
+      warnings.push(`${action.artifactType}: ${requestedNames.length} selections accepted without catalog validation (manifest-driven surface).`);
+    }
+
+    allowlist[action.artifactType] = requestedNames.sort();
+  }
+
+  for (const warning of warnings) {
+    console.warn(`  warn: ${warning}`);
+  }
+
+  return Object.keys(allowlist).length > 0 ? allowlist : undefined;
+}
+
+async function writePlanAudit(sourceName, root, planResult, activation) {
+  const metadataDir = getSourceMetadataDir(sourceName, root);
+  await fsp.mkdir(metadataDir, { recursive: true });
+  const audit = {
+    appliedAt: new Date().toISOString(),
+    plan: {
+      sourceName: planResult.sourceName,
+      kind: planResult.kind,
+      profile: planResult.profile,
+      installMode: planResult.installMode,
+      actions: planResult.actions,
+      warnings: planResult.warnings,
+    },
+    activation,
+  };
+  await fsp.writeFile(path.join(metadataDir, 'last-plan-apply.json'), JSON.stringify(audit, null, 2) + '\n', 'utf8');
+}
+
+async function plan(args, flags = {}) {
+  const cmd = args[0] || 'install';
+
+  switch (cmd) {
+    case 'install': {
+      const sourceName = args[1];
+      if (!sourceName) {
+        throw new Error('Usage: omc-manage plan install <source> [--profile claude-runtime] [--json]');
+      }
+
+      const profile = flags.profile || 'claude-runtime';
+      const catalog = await buildSourceCatalog(sourceName, getProjectRoot());
+      const planResult = buildInstallPlan(catalog, profile);
+
+      if (flags.json) {
+        console.log(JSON.stringify(planResult, null, 2));
+        return;
+      }
+
+      console.log(`Install Plan: ${sourceName}`);
+      console.log('='.repeat(40));
+      console.log(`kind: ${planResult.kind}`);
+      console.log(`installMode: ${planResult.installMode}`);
+      console.log(`profile: ${planResult.profile}`);
+      console.log('');
+
+      console.log('Actions:');
+      for (const action of planResult.actions) {
+        if (action.type === 'install-artifact') {
+          console.log(`  install ${action.artifactType} via ${action.adapter} (${action.count} items)`);
+          if (action.itemNames && action.itemNames.length > 0) {
+            console.log(`    curatable: ${action.itemNames.length} names available`);
+          }
+        } else {
+          console.log(`  retain ${action.surface} as reference via ${action.adapter || 'n/a'} (${action.count} items)`);
+        }
+      }
+
+      console.log('');
+      console.log(`Selected surfaces: ${planResult.selectedSurfaces.length}`);
+      console.log(`Skipped surfaces: ${planResult.skippedSurfaces.length}`);
+
+      if (planResult.warnings.length > 0) {
+        console.log('');
+        console.log('Warnings:');
+        for (const warning of planResult.warnings) {
+          console.log(`  - ${warning}`);
+        }
+      }
+      return;
+    }
+
+    case 'apply': {
+      const sourceName = args[1];
+      if (!sourceName) {
+        throw new Error('Usage: omc-manage plan apply <source> [--profile claude-runtime] [--dry-run] [--json]');
+      }
+
+      const root = getProjectRoot();
+      const profile = flags.profile || 'claude-runtime';
+      const catalog = await buildSourceCatalog(sourceName, root);
+      const planResult = buildInstallPlan(catalog, profile);
+      const selectionData = flags.selectionFile ? await readSelectionFile(flags.selectionFile) : {};
+      const allowlist = extractAllowlistFromSelection(planResult, selectionData);
+      const currentSource = readConfig().sources[sourceName] || {};
+      const activation = {
+        ...deriveSourceActivation(planResult, currentSource),
+        allowlist,
+      };
+
+      if (flags.json) {
+        console.log(JSON.stringify({ plan: planResult, activation }, null, 2));
+        return;
+      }
+
+      console.log(`Apply Plan: ${sourceName}`);
+      console.log('='.repeat(40));
+      console.log(`kind: ${planResult.kind}`);
+      console.log(`current installMode: ${planResult.installMode}`);
+      console.log(`target profile: ${planResult.profile}`);
+      console.log(`next installMode: ${activation.installMode}`);
+      console.log(`next role: ${activation.role || 'installable'}`);
+      console.log(`next artifacts: ${activation.artifacts.join(', ') || '(none)'}`);
+      if (activation.allowlist) {
+        console.log(`next allowlist: ${Object.entries(activation.allowlist).map(([type, names]) => `${type}(${names.length})`).join(', ')}`);
+      }
+
+      // Warn when activation includes artifact types whose source dir is
+      // missing or empty — typically because the surface was discovered via a
+      // manifest (plugin.json/agent.yaml) but never pulled by `source sync`.
+      // setup will silently no-op those types; surface that here so the user
+      // can re-sync or narrow the artifacts list.
+      if (activation.installMode === 'auto' && activation.artifacts.length > 0) {
+        const unsynced = findUnsyncedArtifactTypes(sourceName, activation.artifacts, root);
+        if (unsynced.length > 0) {
+          console.warn('');
+          console.warn(`  warn: ${unsynced.length} artifact type(s) declared but not synced: ${unsynced.join(', ')}`);
+          console.warn(`  warn: run "omc-manage source sync ${sourceName}" or remove them from --artifacts`);
+        }
+      }
+
+      if (flags.dryRun) {
+        console.log('');
+        console.log('[dry-run] No source config updated.');
+        return;
+      }
+
+      const updatedSource = await updateSource(sourceName, (current) => ({
+        ...current,
+        installMode: activation.installMode,
+        role: activation.role || undefined,
+        artifacts: activation.artifacts,
+        allowlist: activation.allowlist,
+        appliedProfile: activation.appliedProfile,
+        appliedAt: new Date().toISOString(),
+      }));
+
+      await writePlanAudit(sourceName, root, planResult, {
+        installMode: updatedSource.installMode,
+        role: updatedSource.role || null,
+        artifacts: updatedSource.artifacts,
+        allowlist: updatedSource.allowlist,
+        appliedProfile: updatedSource.appliedProfile || profile,
+      });
+
+      console.log('');
+      console.log('Applied to source config.');
+      console.log(`  installMode: ${updatedSource.installMode}`);
+      console.log(`  role: ${updatedSource.role || 'installable'}`);
+      console.log(`  artifacts: ${(updatedSource.artifacts || []).join(', ')}`);
+      if (updatedSource.allowlist) {
+        console.log(`  allowlist: ${Object.entries(updatedSource.allowlist).map(([type, names]) => `${type}(${names.length})`).join(', ')}`);
+      }
+      console.log(`  audit: ${path.join(getSourceMetadataDir(sourceName, root), 'last-plan-apply.json')}`);
+      return;
+    }
+
+    default:
+      throw new Error(`Unknown subcommand: ${cmd}. Use: install or apply`);
+  }
+}
+
+module.exports = { plan };

package/src/cli/setup.js

@@ -4,7 +4,7 @@ const fsp = require('fs/promises');
 const path = require('path');
 const os = require('os');
 const { getProjectRoot, getSourceArtifactDir, getInstallTarget, getMergeConfigPath, getReportDir } = require('../config/paths');
-const { readConfig } = require('../config/sources');
+const { readConfig, filterItemsByAllowlist } = require('../config/sources');
 const { getArtifactTypeNames, ARTIFACT_TYPES } = require('../config/artifact-types');
 const { detectConflicts, resolveConflicts, applyResolutions, generateReport } = require('../merge/base-merger');
 const { loadSkillsFromSource } = require('../merge/skill-merger');
@@ -18,6 +18,22 @@ const { evaluateSkillQuality } = require('../utils/quality');
 const { copyDirRecursive } = require('./source');
 
 const OMC_VERSION_PATH = path.join(os.homedir(), '.claude', '.omc-version.json');
+const OMC_CONFIG_PATH = path.join(os.homedir(), '.claude', '.omc-config.json');
+const OMC_INSTALL_MANIFEST_PATH = path.join(os.homedir(), '.claude', '.omc-install-manifest.json');
+const LEGACY_HOOK_PATHS = [
+  'hooks.json',
+  'hooks-cursor.json',
+  'run-hook.cmd',
+  'session-start',
+  'session-start.mjs',
+  'keyword-detector.mjs',
+  'persistent-mode.mjs',
+  'post-tool-use-failure.mjs',
+  'post-tool-use.mjs',
+  'pre-tool-use.mjs',
+  'stop-continuation.mjs',
+  'lib',
+];
 
 function getPackageVersion(root) {
   try {
@@ -41,6 +57,119 @@ async function writeInstallMetadata(root) {
   await fsp.writeFile(OMC_VERSION_PATH, JSON.stringify(metadata, null, 2) + '\n', 'utf8');
 }
 
+async function readJsonFile(filePath, fallback) {
+  try {
+    return JSON.parse(await fsp.readFile(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function uniq(values) {
+  return [...new Set(values)];
+}
+
+function getManagedMetadataPaths(scope) {
+  const baseDir = scope === 'project'
+    ? path.join(process.cwd(), '.claude')
+    : path.join(os.homedir(), '.claude');
+
+  return {
+    configPath: path.join(baseDir, '.omc-config.json'),
+    manifestPath: path.join(baseDir, '.omc-install-manifest.json'),
+  };
+}
+
+function existingRelativePaths(installTarget, candidates) {
+  return uniq(candidates).filter(relativePath => fs.existsSync(path.join(installTarget, relativePath)));
+}
+
+function inferLegacyManagedPaths(artifactType, installTarget, desiredPaths, extra = {}) {
+  if (!fs.existsSync(installTarget) || !fs.statSync(installTarget).isDirectory()) {
+    return [];
+  }
+
+  switch (artifactType) {
+    case 'skills': {
+      const candidates = [...desiredPaths, ...(extra.excludedNames || [])];
+      return existingRelativePaths(installTarget, candidates);
+    }
+    case 'agents': {
+      const candidates = [];
+      for (const relativePath of desiredPaths) {
+        candidates.push(relativePath);
+        candidates.push(`${relativePath}.md`);
+        if (relativePath.endsWith('.md')) {
+          candidates.push(relativePath.slice(0, -3));
+        }
+      }
+      return existingRelativePaths(installTarget, candidates);
+    }
+    case 'commands': {
+      const candidates = [...desiredPaths];
+      const entries = fs.readdirSync(installTarget);
+      for (const entry of entries) {
+        if (entry.startsWith('oh-my-claudecode:') && entry.endsWith('.md')) {
+          candidates.push(entry);
+        }
+      }
+      return existingRelativePaths(installTarget, candidates);
+    }
+    case 'hooks': {
+      return existingRelativePaths(installTarget, [...desiredPaths, ...LEGACY_HOOK_PATHS]);
+    }
+    case 'hud':
+      return existingRelativePaths(installTarget, desiredPaths);
+    default:
+      return [];
+  }
+}
+
+async function pruneManagedPaths(installTarget, previousPaths, desiredPaths, flags) {
+  if (!fs.existsSync(installTarget) || !fs.statSync(installTarget).isDirectory()) {
+    return 0;
+  }
+
+  const desiredSet = new Set(desiredPaths);
+  const toRemove = uniq(previousPaths)
+    .filter(relativePath => !desiredSet.has(relativePath))
+    .sort((a, b) => b.split(path.sep).length - a.split(path.sep).length);
+
+  if (toRemove.length === 0) return 0;
+
+  if (flags.dryRun) {
+    for (const relativePath of toRemove) {
+      console.log(`    would prune ${relativePath}`);
+    }
+    return toRemove.length;
+  }
+
+  for (const relativePath of toRemove) {
+    await fsp.rm(path.join(installTarget, relativePath), { recursive: true, force: true });
+  }
+
+  return toRemove.length;
+}
+
+async function writeOmcConfig(root, scope) {
+  if (scope !== 'user') return;
+
+  const now = new Date().toISOString();
+  const version = getPackageVersion(root);
+  const existing = await readJsonFile(OMC_CONFIG_PATH, {});
+  const next = {
+    ...existing,
+    configuredAt: existing.configuredAt || now,
+    updateRepository: 'materialofair/claudecode-omc',
+    updateBranch: 'main',
+    setupCompleted: now,
+    setupVersion: version,
+  };
+
+  await fsp.mkdir(path.dirname(OMC_CONFIG_PATH), { recursive: true });
+  await fsp.writeFile(OMC_CONFIG_PATH, JSON.stringify(next, null, 2) + '\n', 'utf8');
+}
+
 async function copyDirectory(src, dest, options = {}) {
   if (!fs.existsSync(src)) return 0;
   if (!options.dryRun) await fsp.mkdir(dest, { recursive: true });
@@ -81,12 +210,13 @@ function collectSourcesForType(artifactType, orderedSources, root) {
     // Skip reference-only sources (e.g. anthropic-skills) — they provide
     // evaluation standards, not installable artifacts.
     if (src.role === 'reference') continue;
+    if (src.installMode && src.installMode !== 'auto') continue;
     const declaredArtifacts = src.artifacts || [];
     if (!declaredArtifacts.includes(artifactType)) continue;
 
     const dir = getSourceArtifactDir(name, artifactType, root);
     if (fs.existsSync(dir)) {
-      sourcesForType.push({ name, dir, priority: src.priority });
+      sourcesForType.push({ name, dir, priority: src.priority, config: src });
     }
   }
 
@@ -102,8 +232,8 @@ async function installNameBasedArtifacts(artifactType, sources, mergeConfig, ins
   if (!loader) return { count: 0, total: 0 };
 
   const loaded = [];
-  for (const { name, dir } of sources) {
-    const items = loader(dir, name);
+  for (const { name, dir, config } of sources) {
+    const items = filterItemsByAllowlist(config, artifactType, loader(dir, name));
     if (items.length > 0) {
       loaded.push({ name, items });
     }
@@ -131,7 +261,13 @@ async function installNameBasedArtifacts(artifactType, sources, mergeConfig, ins
     for (const item of merged.sort((a, b) => a.name.localeCompare(b.name))) {
       console.log(`    ${item.name} (${item.sourceName})`);
     }
-    return { count: 0, total: merged.length, conflicts: conflicts.length };
+    return {
+      count: 0,
+      total: merged.length,
+      conflicts: conflicts.length,
+      managedPaths: merged.map(item => item.name),
+      excludedNames: excludeList,
+    };
   }
 
   await fsp.mkdir(installTarget, { recursive: true });
@@ -142,15 +278,24 @@ async function installNameBasedArtifacts(artifactType, sources, mergeConfig, ins
       const dest = path.join(installTarget, item.name);
       fileCount += await copyDirectory(item.path, dest, flags);
     } else {
-      // Single file copy
-      const dest = path.join(installTarget, item.name.includes('/') ? item.name : item.name);
+      // Single file copy. Loaders strip `.md` from item.name for matching/allowlist purposes;
+      // re-attach the source extension on disk so Claude Code's `*.md` loader picks them up.
+      const sourceExt = path.extname(item.path);
+      const destName = sourceExt && !item.name.endsWith(sourceExt) ? `${item.name}${sourceExt}` : item.name;
+      const dest = path.join(installTarget, destName);
       await fsp.mkdir(path.dirname(dest), { recursive: true });
       await fsp.copyFile(item.path, dest);
       fileCount += 1;
     }
   }
 
-  return { count: fileCount, total: merged.length, conflicts: conflicts.length };
+  return {
+    count: fileCount,
+    total: merged.length,
+    conflicts: conflicts.length,
+    managedPaths: merged.map(item => item.name),
+    excludedNames: excludeList,
+  };
 }
 
 async function installHooks(sources, installTarget, flags) {
@@ -182,6 +327,21 @@ async function installHooks(sources, installTarget, flags) {
     }
   }
 
+  const managedPaths = [...(result.managedPaths || []), 'hooks.json'];
+  if (sources.some(({ dir }) => hasHookLib(dir))) {
+    managedPaths.push('lib');
+  }
+  if (sources.some(({ dir }) => fs.existsSync(path.join(dir, 'hooks-cursor.json')))) {
+    managedPaths.push('hooks-cursor.json');
+  }
+  if (sources.some(({ dir }) => fs.existsSync(path.join(dir, 'run-hook.cmd')))) {
+    managedPaths.push('run-hook.cmd');
+  }
+  if (sources.some(({ dir }) => fs.existsSync(path.join(dir, 'session-start')))) {
+    managedPaths.push('session-start');
+  }
+
+  result.managedPaths = uniq(managedPaths);
   return result;
 }
 
@@ -201,7 +361,7 @@ async function installSectionDocument(artifactType, sources, installTarget, flag
     for (const s of sections) {
       console.log(`    section from: ${s.sourceName} (${s.content.length} chars)`);
     }
-    return { count: 0, total: sections.length };
+    return { count: 0, total: sections.length, managedPaths: [path.basename(installTarget)] };
   }
 
   let finalContent;
@@ -223,7 +383,7 @@ async function installSectionDocument(artifactType, sources, installTarget, flag
   await fsp.mkdir(path.dirname(installTarget), { recursive: true });
   await fsp.writeFile(installTarget, finalContent, 'utf8');
 
-  return { count: 1, total: sections.length };
+  return { count: 1, total: sections.length, managedPaths: [path.basename(installTarget)] };
 }
 
 async function installSettings(sources, installTarget, flags) {
@@ -241,7 +401,7 @@ async function installSettings(sources, installTarget, flags) {
     for (const f of fragments) {
       console.log(`    fragment from: ${f.sourceName} (${Object.keys(f.fragment).join(', ')})`);
     }
-    return { count: 0, total: fragments.length };
+    return { count: 0, total: fragments.length, managedPaths: [path.basename(installTarget)] };
   }
 
   let existing = {};
@@ -255,13 +415,14 @@ async function installSettings(sources, installTarget, flags) {
   await fsp.mkdir(path.dirname(installTarget), { recursive: true });
   await fsp.writeFile(installTarget, JSON.stringify(merged, null, 2) + '\n', 'utf8');
 
-  return { count: 1, total: fragments.length };
+  return { count: 1, total: fragments.length, managedPaths: [path.basename(installTarget)] };
 }
 
 async function setup(args, flags = {}) {
   const root = getProjectRoot();
   const config = readConfig();
   const scope = flags.scope || 'user';
+  const { manifestPath } = getManagedMetadataPaths(scope);
   const typeFilter = flags.type
     ? [...new Set(flags.type.split(',').map(type => (type === 'claude-md' ? 'guidelines' : type)))]
     : null;
@@ -285,6 +446,12 @@ async function setup(args, flags = {}) {
 
   const allTypes = getArtifactTypeNames().filter(type => type !== 'claude-md');
   const typesToInstall = typeFilter || allTypes;
+  const previousManifest = await readJsonFile(manifestPath, { artifacts: {} });
+  const nextManifest = {
+    updatedAt: new Date().toISOString(),
+    scope,
+    artifacts: {},
+  };
   let step = 0;
   const totalSteps = typesToInstall.length;
 
@@ -333,6 +500,31 @@ async function setup(args, flags = {}) {
       console.log(`    installed ${result.count} files (${result.total} items)`);
     }
 
+    if (typeConfig.format !== 'single-file' && typeConfig.format !== 'json') {
+      const previousPaths = previousManifest.artifacts?.[artifactType]?.paths;
+      const managedPaths = uniq(result.managedPaths || []);
+      const bootstrapPaths = previousPaths || inferLegacyManagedPaths(
+        artifactType,
+        installTarget,
+        managedPaths,
+        result,
+      );
+      const pruned = await pruneManagedPaths(installTarget, bootstrapPaths, managedPaths, flags);
+      if (pruned > 0) {
+        console.log(flags.dryRun ? `    would prune ${pruned} stale entries` : `    pruned ${pruned} stale entries`);
+      }
+
+      nextManifest.artifacts[artifactType] = {
+        target: installTarget,
+        paths: managedPaths,
+      };
+    } else {
+      nextManifest.artifacts[artifactType] = {
+        target: installTarget,
+        paths: result.managedPaths || [path.basename(installTarget)],
+      };
+    }
+
     if (result.conflicts > 0) {
       console.log(`    resolved ${result.conflicts} conflicts`);
     }
@@ -340,6 +532,11 @@ async function setup(args, flags = {}) {
 
   if (!flags.dryRun && scope === 'user') {
     await writeInstallMetadata(root);
+    await writeOmcConfig(root, scope);
+    await fsp.writeFile(manifestPath, JSON.stringify(nextManifest, null, 2) + '\n', 'utf8');
+  } else if (!flags.dryRun && scope === 'project') {
+    await fsp.mkdir(path.dirname(manifestPath), { recursive: true });
+    await fsp.writeFile(manifestPath, JSON.stringify(nextManifest, null, 2) + '\n', 'utf8');
   }
 
   console.log('\nDone.');