claudecode-omc 5.6.1 → 5.6.2

package/bundled/manifest.json

@@ -1,5 +1,5 @@
 {
-  "bundledAt": "2026-04-29T02:22:02Z",
+  "bundledAt": "2026-04-30T02:34:50Z",
   "sources": {
     "anthropic-skills": { "artifacts": 2 },
     "ecc": { "artifacts": 131 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudecode-omc",
-  "version": "5.6.1",
+  "version": "5.6.2",
   "description": "Claude Code harness — best-practice skills, agents, hooks, and configs from multiple sources",
   "bin": {
     "omc-manage": "bin/omc-manage.js"
@@ -15,6 +15,7 @@
     "README.md"
   ],
   "scripts": {
+    "test": "node --test",
     "setup": "node bin/omc-manage.js setup",
     "doctor": "node bin/omc-manage.js doctor",
     "guidelines:optimize": "node bin/omc-manage.js guidelines optimize",

package/src/cli/artifact.js

@@ -1,70 +1,10 @@
 /* eslint-disable no-console */
 const fs = require('fs');
 const fsp = require('fs/promises');
-const path = require('path');
-const { getProjectRoot, getSourceArtifactDir, getMergeConfigPath, getReportDir } = require('../config/paths');
-const { readConfig, filterItemsByAllowlist } = require('../config/sources');
+const { getProjectRoot, getMergeConfigPath } = require('../config/paths');
 const { ARTIFACT_TYPES, getArtifactTypeNames } = require('../config/artifact-types');
 const { detectConflicts, resolveConflicts, applyResolutions, generateReport } = require('../merge/base-merger');
-const { loadSkillsFromSource } = require('../merge/skill-merger');
-const { loadAgentsFromSource } = require('../merge/agent-merger');
-const { loadCommandsFromSource } = require('../merge/command-merger');
-const { loadHookFilesFromSource } = require('../merge/hook-merger');
-const { loadFilesFromSource } = require('../merge/file-merger');
-const { loadClaudeMd } = require('../merge/claude-md-merger');
-
-function loadSectionDocumentFromSource(sourceDir) {
-  const content = loadClaudeMd(sourceDir);
-  if (!content) return [];
-  return [{
-    name: 'CLAUDE.md',
-    path: sourceDir,
-    metadata: {
-      description: `${content.length} chars of prompt guidelines`,
-    },
-  }];
-}
-
-function getLoader(artifactType) {
-  switch (artifactType) {
-    case 'skills': return loadSkillsFromSource;
-    case 'agents': return loadAgentsFromSource;
-    case 'commands': return loadCommandsFromSource;
-    case 'hooks': return loadHookFilesFromSource;
-    case 'guidelines': return loadSectionDocumentFromSource;
-    case 'claude-md': return loadSectionDocumentFromSource;
-    case 'hud': return loadFilesFromSource;
-    default: return null;
-  }
-}
-
-function loadSourcesForType(artifactType, root) {
-  const config = readConfig();
-  const sources = [];
-  const ordered = Object.entries(config.sources)
-    .sort(([, a], [, b]) => a.priority - b.priority);
-
-  const loader = getLoader(artifactType);
-  if (!loader) return sources;
-
-  for (const [name, src] of ordered) {
-    if (src.role === 'reference') continue;
-    if (src.installMode && src.installMode !== 'auto') continue;
-    if (!(src.artifacts || []).includes(artifactType)) continue;
-    const dir = getSourceArtifactDir(name, artifactType, root);
-    if (!fs.existsSync(dir)) continue;
-    const items = filterItemsByAllowlist(src, artifactType, loader(dir, name));
-    if (items.length > 0) {
-      sources.push({ name, items });
-    }
-  }
-
-  if (sources.length === 0 && artifactType === 'claude-md') {
-    return loadSourcesForType('guidelines', root);
-  }
-
-  return sources;
-}
+const { loadSourcesForType } = require('../merge/artifact-source-loader');
 
 async function artifact(args, flags = {}) {
   const cmd = args[0] || 'list';

package/src/cli/setup.js

@@ -3,23 +3,17 @@ const fs = require('fs');
 const fsp = require('fs/promises');
 const path = require('path');
 const os = require('os');
-const { getProjectRoot, getSourceArtifactDir, getInstallTarget, getMergeConfigPath, getReportDir } = require('../config/paths');
+const { getProjectRoot, getScopedInstallTarget, getMergeConfigPath } = require('../config/paths');
 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');
-const { loadAgentsFromSource } = require('../merge/agent-merger');
-const { loadCommandsFromSource } = require('../merge/command-merger');
-const { loadHookFilesFromSource, loadHooksConfig, mergeHooksConfigs, hasHookLib } = require('../merge/hook-merger');
+const { detectConflicts, resolveConflicts, applyResolutions } = require('../merge/base-merger');
+const { loadHooksConfig, mergeHooksConfigs, hasHookLib } = require('../merge/hook-merger');
 const { loadClaudeMd, mergeIntoExisting, assembleSections } = require('../merge/claude-md-merger');
 const { loadSettingsFragment, mergeSettingsFragments } = require('../merge/settings-merger');
-const { loadFilesFromSource } = require('../merge/file-merger');
-const { evaluateSkillQuality } = require('../utils/quality');
-const { copyDirRecursive } = require('./source');
+const { collectSourceDirsForType, getArtifactLoader } = require('../merge/artifact-source-loader');
 
 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',
@@ -125,6 +119,18 @@ function inferLegacyManagedPaths(artifactType, installTarget, desiredPaths, extr
   }
 }
 
+function normalizePreviousManagedPaths(artifactType, previousPaths) {
+  if (!Array.isArray(previousPaths)) return previousPaths;
+
+  if (artifactType !== 'agents' && artifactType !== 'commands') {
+    return previousPaths;
+  }
+
+  return previousPaths.map((relativePath) => (
+    path.extname(relativePath) ? relativePath : `${relativePath}.md`
+  ));
+}
+
 async function pruneManagedPaths(installTarget, previousPaths, desiredPaths, flags) {
   if (!fs.existsSync(installTarget) || !fs.statSync(installTarget).isDirectory()) {
     return 0;
@@ -192,43 +198,19 @@ async function copyDirectory(src, dest, options = {}) {
   return count;
 }
 
-function getLoader(artifactType) {
-  switch (artifactType) {
-    case 'skills': return loadSkillsFromSource;
-    case 'agents': return loadAgentsFromSource;
-    case 'commands': return loadCommandsFromSource;
-    case 'hooks': return loadHookFilesFromSource;
-    case 'hud': return loadFilesFromSource;
-    default: return null;
-  }
-}
-
-function collectSourcesForType(artifactType, orderedSources, root) {
-  const sourcesForType = [];
-
-  for (const [name, src] of orderedSources) {
-    // 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, config: src });
-    }
-  }
-
-  if (sourcesForType.length === 0 && artifactType === 'claude-md') {
-    return collectSourcesForType('guidelines', orderedSources, root);
+function getManagedPathForItem(artifactType, item) {
+  if (artifactType === 'skills' || item.isDirectory) {
+    return item.name;
   }
 
-  return sourcesForType;
+  // Loaders keep logical names extensionless for conflict checks; manifests
+  // must track the real path written to disk.
+  const sourceExt = path.extname(item.path);
+  return sourceExt && !item.name.endsWith(sourceExt) ? `${item.name}${sourceExt}` : item.name;
 }
 
 async function installNameBasedArtifacts(artifactType, sources, mergeConfig, installTarget, flags) {
-  const loader = getLoader(artifactType);
+  const loader = getArtifactLoader(artifactType);
   if (!loader) return { count: 0, total: 0 };
 
   const loaded = [];
@@ -257,6 +239,8 @@ async function installNameBasedArtifacts(artifactType, sources, mergeConfig, ins
     }
   }
 
+  const managedPaths = merged.map(item => getManagedPathForItem(artifactType, item));
+
   if (flags.dryRun) {
     for (const item of merged.sort((a, b) => a.name.localeCompare(b.name))) {
       console.log(`    ${item.name} (${item.sourceName})`);
@@ -265,7 +249,7 @@ async function installNameBasedArtifacts(artifactType, sources, mergeConfig, ins
       count: 0,
       total: merged.length,
       conflicts: conflicts.length,
-      managedPaths: merged.map(item => item.name),
+      managedPaths,
       excludedNames: excludeList,
     };
   }
@@ -275,14 +259,10 @@ async function installNameBasedArtifacts(artifactType, sources, mergeConfig, ins
 
   for (const item of merged) {
     if (artifactType === 'skills' || item.isDirectory) {
-      const dest = path.join(installTarget, item.name);
+      const dest = path.join(installTarget, getManagedPathForItem(artifactType, item));
       fileCount += await copyDirectory(item.path, dest, flags);
     } else {
-      // 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);
+      const dest = path.join(installTarget, getManagedPathForItem(artifactType, item));
       await fsp.mkdir(path.dirname(dest), { recursive: true });
       await fsp.copyFile(item.path, dest);
       fileCount += 1;
@@ -293,7 +273,7 @@ async function installNameBasedArtifacts(artifactType, sources, mergeConfig, ins
     count: fileCount,
     total: merged.length,
     conflicts: conflicts.length,
-    managedPaths: merged.map(item => item.name),
+    managedPaths,
     excludedNames: excludeList,
   };
 }
@@ -440,10 +420,6 @@ async function setup(args, flags = {}) {
     try { mergeConfig = JSON.parse(fs.readFileSync(mergeConfigPath, 'utf8')); } catch {}
   }
 
-  // Get ordered sources (by priority)
-  const orderedSources = Object.entries(config.sources)
-    .sort(([, a], [, b]) => a.priority - b.priority);
-
   const allTypes = getArtifactTypeNames().filter(type => type !== 'claude-md');
   const typesToInstall = typeFilter || allTypes;
   const previousManifest = await readJsonFile(manifestPath, { artifacts: {} });
@@ -463,11 +439,9 @@ async function setup(args, flags = {}) {
       continue;
     }
 
-    const sourcesForType = collectSourcesForType(artifactType, orderedSources, root);
+    const sourcesForType = collectSourceDirsForType(artifactType, root, config);
 
-    const installTarget = (artifactType === 'skills' && scope === 'project')
-      ? path.join(process.cwd(), '.claude', 'skills')
-      : typeConfig.installTarget;
+    const installTarget = getScopedInstallTarget(artifactType, scope, process.cwd());
 
     console.log(`[${step}/${totalSteps}] ${typeConfig.label} (${sourcesForType.length} sources)`);
 
@@ -501,7 +475,10 @@ async function setup(args, flags = {}) {
     }
 
     if (typeConfig.format !== 'single-file' && typeConfig.format !== 'json') {
-      const previousPaths = previousManifest.artifacts?.[artifactType]?.paths;
+      const previousPaths = normalizePreviousManagedPaths(
+        artifactType,
+        previousManifest.artifacts?.[artifactType]?.paths,
+      );
       const managedPaths = uniq(result.managedPaths || []);
       const bootstrapPaths = previousPaths || inferLegacyManagedPaths(
         artifactType,

package/src/cli/source.js

@@ -74,8 +74,8 @@ async function syncRemoteSource(sourceName, sourceConfig, root) {
       const srcPath = path.join(tmpDir, srcSubdir);
       const destPath = getSyncTargetDir(sourceName, artifactType, root);
 
+      await fsp.rm(destPath, { recursive: true, force: true });
       if (fs.existsSync(srcPath)) {
-        await fsp.rm(destPath, { recursive: true, force: true });
         if (fs.statSync(srcPath).isDirectory()) {
           await copyDirRecursive(srcPath, destPath);
         } else {

package/src/config/paths.js

@@ -213,6 +213,23 @@ function getInstallTarget(artifactType) {
   return type.installTarget;
 }
 
+function getScopedInstallTarget(artifactType, scope = 'user', cwd = process.cwd()) {
+  if (scope !== 'project') {
+    return getInstallTarget(artifactType);
+  }
+
+  if (artifactType === 'guidelines' || artifactType === 'claude-md') {
+    return path.join(cwd, '.claude', 'CLAUDE.md');
+  }
+  if (artifactType === 'settings') {
+    return path.join(cwd, '.claude', 'settings.json');
+  }
+
+  const type = ARTIFACT_TYPES[artifactType];
+  if (!type) throw new Error(`Unknown artifact type: ${artifactType}`);
+  return path.join(cwd, '.claude', type.sourceSubdir);
+}
+
 // Backward-compatible aliases
 function getLocalSkillsDir(root) {
   return getSourceArtifactDir('local', 'skills', root);
@@ -257,6 +274,7 @@ module.exports = {
   getSyncTargetDir,
   getSyncTempDir,
   getInstallTarget,
+  getScopedInstallTarget,
   USER_DATA_DIR,
   // Backward-compatible
   getLocalSkillsDir,

package/src/merge/artifact-source-loader.js

@@ -0,0 +1,92 @@
+const fs = require('fs');
+const { getProjectRoot, getSourceArtifactDir } = require('../config/paths');
+const { readConfig, filterItemsByAllowlist } = require('../config/sources');
+const { loadSkillsFromSource } = require('./skill-merger');
+const { loadAgentsFromSource } = require('./agent-merger');
+const { loadCommandsFromSource } = require('./command-merger');
+const { loadHookFilesFromSource } = require('./hook-merger');
+const { loadFilesFromSource } = require('./file-merger');
+const { loadClaudeMd } = require('./claude-md-merger');
+
+function loadSectionDocumentFromSource(sourceDir) {
+  const content = loadClaudeMd(sourceDir);
+  if (!content) return [];
+  return [{
+    name: 'CLAUDE.md',
+    path: sourceDir,
+    metadata: {
+      description: `${content.length} chars of prompt guidelines`,
+    },
+  }];
+}
+
+function getArtifactLoader(artifactType, options = {}) {
+  switch (artifactType) {
+    case 'skills': return loadSkillsFromSource;
+    case 'agents': return loadAgentsFromSource;
+    case 'commands': return loadCommandsFromSource;
+    case 'hooks': return loadHookFilesFromSource;
+    case 'hud': return loadFilesFromSource;
+    case 'guidelines':
+    case 'claude-md':
+      return options.includeSectionDocuments ? loadSectionDocumentFromSource : null;
+    default: return null;
+  }
+}
+
+function getOrderedInstallableSources(config) {
+  return Object.entries(config.sources || {})
+    .sort(([, a], [, b]) => a.priority - b.priority)
+    .filter(([, src]) => src.role !== 'reference')
+    .filter(([, src]) => !src.installMode || src.installMode === 'auto');
+}
+
+function collectSourceDirsForType(artifactType, root = getProjectRoot(), config = readConfig()) {
+  const sourcesForType = [];
+
+  for (const [name, src] of getOrderedInstallableSources(config)) {
+    if (!(src.artifacts || []).includes(artifactType)) continue;
+
+    const dir = getSourceArtifactDir(name, artifactType, root);
+    if (fs.existsSync(dir)) {
+      sourcesForType.push({ name, dir, priority: src.priority, config: src });
+    }
+  }
+
+  if (sourcesForType.length === 0 && artifactType === 'claude-md') {
+    return collectSourceDirsForType('guidelines', root, config);
+  }
+
+  return sourcesForType;
+}
+
+function loadSourcesForType(artifactType, root = getProjectRoot(), options = {}) {
+  const config = options.config || readConfig();
+  const loader = getArtifactLoader(artifactType, { includeSectionDocuments: true });
+  if (!loader) return [];
+
+  const sources = [];
+  for (const source of collectSourceDirsForType(artifactType, root, config)) {
+    const items = filterItemsByAllowlist(
+      source.config,
+      artifactType,
+      loader(source.dir, source.name),
+    );
+    if (items.length > 0) {
+      sources.push({ name: source.name, items });
+    }
+  }
+
+  if (sources.length === 0 && artifactType === 'claude-md') {
+    return loadSourcesForType('guidelines', root, options);
+  }
+
+  return sources;
+}
+
+module.exports = {
+  collectSourceDirsForType,
+  getArtifactLoader,
+  loadSectionDocumentFromSource,
+  loadSourcesForType,
+};