claudecode-omc 4.9.4 → 5.0.0

package/src/config/paths.js

@@ -0,0 +1,142 @@
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+const { ARTIFACT_TYPES } = require('./artifact-types');
+
+const USER_DATA_DIR = path.join(os.homedir(), '.omc-manage');
+
+function getProjectRoot() {
+  return path.resolve(__dirname, '..', '..');
+}
+
+/**
+ * Detect if running from an npm-installed package (no .git dir, has bundled/)
+ */
+function isDistributionMode() {
+  const root = getProjectRoot();
+  return !fs.existsSync(path.join(root, '.git'))
+    && fs.existsSync(path.join(root, 'bundled', 'upstream'));
+}
+
+/**
+ * Get the directory for a source's artifact type.
+ *
+ * Resolution order:
+ *   Dev mode:
+ *     local  → <repo>/.local/<type>
+ *     other  → <repo>/.upstream/<source>/<type>
+ *
+ *   Distribution mode:
+ *     local  → ~/.omc-manage/local/<type>
+ *     other  → ~/.omc-manage/upstream/<source>/<type>  (if synced)
+ *              → <pkg>/bundled/upstream/<source>/<type> (fallback)
+ */
+function getSourceArtifactDir(sourceName, artifactType, root) {
+  root = root || getProjectRoot();
+
+  if (isDistributionMode()) {
+    if (sourceName === 'local') {
+      return path.join(USER_DATA_DIR, 'local', artifactType);
+    }
+    // Check user-synced first, then fall back to bundled
+    const synced = path.join(USER_DATA_DIR, 'upstream', sourceName, artifactType);
+    if (fs.existsSync(synced)) {
+      return synced;
+    }
+    return path.join(root, 'bundled', 'upstream', sourceName, artifactType);
+  }
+
+  // Dev mode
+  if (sourceName === 'local') {
+    return path.join(root, '.local', artifactType);
+  }
+  return path.join(root, '.upstream', sourceName, artifactType);
+}
+
+/**
+ * Get the write target for source sync.
+ * In distribution mode, synced data goes to ~/.omc-manage/upstream/
+ * In dev mode, it goes to <repo>/.upstream/
+ */
+function getSyncTargetDir(sourceName, artifactType, root) {
+  root = root || getProjectRoot();
+
+  if (isDistributionMode()) {
+    return path.join(USER_DATA_DIR, 'upstream', sourceName, artifactType);
+  }
+  return path.join(root, '.upstream', sourceName, artifactType);
+}
+
+/**
+ * Get the temp directory for sync operations.
+ * In distribution mode, use ~/.omc-manage/tmp/
+ * In dev mode, use <repo>/.tmp-sync-{source}
+ */
+function getSyncTempDir(sourceName, root) {
+  root = root || getProjectRoot();
+
+  if (isDistributionMode()) {
+    return path.join(USER_DATA_DIR, 'tmp', 'sync-' + sourceName);
+  }
+  return path.join(root, '.tmp-sync-' + sourceName);
+}
+
+// Generic: get install target for an artifact type
+function getInstallTarget(artifactType) {
+  const type = ARTIFACT_TYPES[artifactType];
+  if (!type) throw new Error(`Unknown artifact type: ${artifactType}`);
+  return type.installTarget;
+}
+
+// Backward-compatible aliases
+function getLocalSkillsDir(root) {
+  return getSourceArtifactDir('local', 'skills', root);
+}
+
+function getUpstreamSkillsDir(root) {
+  return getSourceArtifactDir('oh-my-claudecode', 'skills', root);
+}
+
+function getUserSkillsDir() {
+  return ARTIFACT_TYPES.skills.installTarget;
+}
+
+function getProjectSkillsDir(cwd) {
+  return path.join(cwd || process.cwd(), '.claude', 'skills');
+}
+
+function getSkillsDir(scope, cwd) {
+  if (scope === 'project') {
+    return getProjectSkillsDir(cwd);
+  }
+  return getUserSkillsDir();
+}
+
+function getMergeConfigPath(root) {
+  return path.join(root || getProjectRoot(), 'templates', 'merge-config.json');
+}
+
+function getReportDir(root) {
+  if (isDistributionMode()) {
+    return path.join(USER_DATA_DIR, 'reports');
+  }
+  return path.join(root || getProjectRoot(), '.omc-manage');
+}
+
+module.exports = {
+  getProjectRoot,
+  isDistributionMode,
+  getSourceArtifactDir,
+  getSyncTargetDir,
+  getSyncTempDir,
+  getInstallTarget,
+  USER_DATA_DIR,
+  // Backward-compatible
+  getLocalSkillsDir,
+  getUpstreamSkillsDir,
+  getUserSkillsDir,
+  getProjectSkillsDir,
+  getSkillsDir,
+  getMergeConfigPath,
+  getReportDir,
+};

package/src/config/sources.js

@@ -0,0 +1,129 @@
+const fs = require('fs');
+const fsp = require('fs/promises');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.omc-manage');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'sources.json');
+
+function getDefaultConfig() {
+  return {
+    active: 'local',
+    sources: {
+      local: {
+        path: '.local',
+        priority: 1,
+        artifacts: ['skills', 'agents', 'hooks', 'commands', 'claude-md', 'settings', 'hud'],
+      },
+      'oh-my-claudecode': {
+        remote: 'https://github.com/Yeachan-Heo/oh-my-claudecode.git',
+        ref: 'main',
+        priority: 2,
+        artifacts: ['skills', 'agents', 'hooks'],
+        mapping: {
+          skills: 'skills',
+          agents: 'agents',
+          hooks: 'hooks',
+        },
+      },
+      superpowers: {
+        remote: 'https://github.com/obra/superpowers.git',
+        ref: 'main',
+        priority: 3,
+        artifacts: ['skills', 'agents', 'hooks', 'commands'],
+        mapping: {
+          skills: 'skills',
+          agents: 'agents',
+          hooks: 'hooks',
+          commands: 'commands',
+        },
+      },
+    },
+    lastSync: null,
+    syncHistory: [],
+  };
+}
+
+function readConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return getDefaultConfig();
+  }
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+  } catch {
+    return getDefaultConfig();
+  }
+}
+
+async function writeConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    await fsp.mkdir(CONFIG_DIR, { recursive: true });
+  }
+  await fsp.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}
+
+function getActiveSource() {
+  return readConfig().active;
+}
+
+async function setActiveSource(source) {
+  const config = readConfig();
+  config.active = source;
+  await writeConfig(config);
+}
+
+async function recordSync(success, details = {}) {
+  const config = readConfig();
+  const record = {
+    timestamp: new Date().toISOString(),
+    success,
+    ...details,
+  };
+  config.syncHistory.push(record);
+  if (success) {
+    config.lastSync = record.timestamp;
+  }
+  if (config.syncHistory.length > 50) {
+    config.syncHistory = config.syncHistory.slice(-50);
+  }
+  await writeConfig(config);
+}
+
+async function addSource(name, remote, options = {}) {
+  const config = readConfig();
+  if (config.sources[name]) {
+    throw new Error(`Source "${name}" already exists`);
+  }
+  config.sources[name] = {
+    remote,
+    ref: options.ref || 'main',
+    priority: options.priority || Object.keys(config.sources).length + 1,
+    artifacts: options.artifacts || ['skills'],
+    mapping: options.mapping || {},
+  };
+  await writeConfig(config);
+}
+
+async function removeSource(name) {
+  const config = readConfig();
+  if (!config.sources[name]) {
+    throw new Error(`Source "${name}" not found`);
+  }
+  if (name === 'local') {
+    throw new Error('Cannot remove the local source');
+  }
+  delete config.sources[name];
+  await writeConfig(config);
+}
+
+module.exports = {
+  readConfig,
+  writeConfig,
+  getActiveSource,
+  setActiveSource,
+  recordSync,
+  addSource,
+  removeSource,
+  CONFIG_DIR,
+  CONFIG_PATH,
+};

package/src/merge/agent-merger.js

@@ -0,0 +1,47 @@
+/* eslint-disable no-console */
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse agent metadata from .md frontmatter
+ */
+function parseAgentMetadata(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return { name: path.basename(filePath, '.md') };
+
+  const metadata = {};
+  match[1].split('\n').forEach((line) => {
+    const colonIndex = line.indexOf(':');
+    if (colonIndex === -1) return;
+    metadata[line.slice(0, colonIndex).trim()] = line.slice(colonIndex + 1).trim();
+  });
+  return metadata;
+}
+
+/**
+ * Load agents from a source directory
+ */
+function loadAgentsFromSource(sourceDir, sourceName) {
+  if (!fs.existsSync(sourceDir)) return [];
+
+  const entries = fs.readdirSync(sourceDir);
+  const items = [];
+
+  for (const entry of entries) {
+    if (!entry.endsWith('.md')) continue;
+    const filePath = path.join(sourceDir, entry);
+    if (!fs.statSync(filePath).isFile()) continue;
+
+    const metadata = parseAgentMetadata(filePath);
+    items.push({
+      name: path.basename(entry, '.md'),
+      path: filePath,
+      metadata,
+    });
+  }
+
+  return items;
+}
+
+module.exports = { parseAgentMetadata, loadAgentsFromSource };

package/src/merge/base-merger.js

@@ -0,0 +1,257 @@
+/* eslint-disable no-console */
+
+/**
+ * Base Merger Module
+ *
+ * Shared conflict detection and resolution logic for all artifact types.
+ */
+
+/**
+ * Calculate Jaccard similarity between two descriptions
+ */
+function calculateDescriptionSimilarity(desc1, desc2) {
+  if (!desc1 || !desc2) return 0;
+
+  const words1 = new Set(desc1.toLowerCase().split(/\s+/).filter(w => w.length > 2));
+  const words2 = new Set(desc2.toLowerCase().split(/\s+/).filter(w => w.length > 2));
+
+  if (words1.size === 0 || words2.size === 0) return 0;
+
+  const intersection = new Set([...words1].filter(x => words2.has(x)));
+  const union = new Set([...words1, ...words2]);
+
+  return intersection.size / union.size;
+}
+
+/**
+ * Compare semantic versions
+ */
+function compareVersions(v1, v2) {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+
+    if (p1 > p2) return 1;
+    if (p1 < p2) return -1;
+  }
+
+  return 0;
+}
+
+/**
+ * Detect conflicts between multiple artifact sources
+ */
+function detectConflicts(sourcesArray) {
+  const byName = new Map();
+  const allItems = [];
+  const conflicts = [];
+
+  for (const source of sourcesArray) {
+    // Support both `items` (new API) and `skills` (backward-compatible alias)
+    const entries = source.items || source.skills || [];
+    for (const item of entries) {
+      const enriched = { ...item, sourceName: source.name };
+      allItems.push(enriched);
+
+      if (!byName.has(item.name)) {
+        byName.set(item.name, []);
+      }
+      byName.get(item.name).push(enriched);
+    }
+  }
+
+  // Exact name conflicts
+  for (const [name, versions] of byName.entries()) {
+    if (versions.length > 1) {
+      conflicts.push({ type: 'exact_name', name, versions });
+    }
+  }
+
+  // Description similarity conflicts (optional, skip if no descriptions)
+  for (let i = 0; i < allItems.length; i++) {
+    for (let j = i + 1; j < allItems.length; j++) {
+      const a = allItems[i];
+      const b = allItems[j];
+      if (a.name === b.name) continue;
+
+      const desc1 = a.metadata?.description || '';
+      const desc2 = b.metadata?.description || '';
+      if (!desc1 || !desc2) continue;
+
+      const similarity = calculateDescriptionSimilarity(desc1, desc2);
+      if (similarity > 0.8) {
+        conflicts.push({
+          type: 'similar_description',
+          name: `${a.name} vs ${b.name}`,
+          versions: [a, b],
+          similarity,
+        });
+      }
+    }
+  }
+
+  return conflicts;
+}
+
+/**
+ * Resolve conflicts using 4-tier strategy:
+ * 1. User config preferences
+ * 2. SemVer (highest version wins)
+ * 3. Local priority (local > upstream)
+ * 4. Namespace (keep both with prefixes)
+ */
+function resolveConflicts(conflicts, config = {}) {
+  const resolutions = [];
+
+  for (const conflict of conflicts) {
+    const { name, versions, type, similarity } = conflict;
+
+    if (type === 'similar_description') {
+      resolutions.push({
+        name, type: 'similar_description', resolution: 'warning',
+        similarity, versions,
+        message: `Similar functionality detected (${(similarity * 100).toFixed(1)}% match)`,
+      });
+      continue;
+    }
+
+    // Tier 1: User config preference
+    if (config.preferences && config.preferences[name]) {
+      const preferredSource = config.preferences[name];
+      const preferred = versions.find(v => v.sourceName === preferredSource);
+      if (preferred) {
+        resolutions.push({
+          name, type: 'exact_name', resolution: 'user-preference',
+          winner: preferred, rejected: versions.filter(v => v !== preferred),
+        });
+        continue;
+      }
+    }
+
+    // Tier 2: SemVer comparison
+    const withVersions = versions.filter(v => v.metadata?.version);
+    if (withVersions.length === versions.length && versions.length > 1) {
+      const sorted = [...versions].sort((a, b) =>
+        compareVersions(b.metadata.version, a.metadata.version)
+      );
+      if (compareVersions(sorted[0].metadata.version, sorted[1].metadata.version) > 0) {
+        resolutions.push({
+          name, type: 'exact_name', resolution: 'semver',
+          winner: sorted[0], rejected: sorted.slice(1),
+        });
+        continue;
+      }
+    }
+
+    // Tier 3: Local priority
+    const localVersion = versions.find(v => v.sourceName === 'local');
+    if (localVersion) {
+      resolutions.push({
+        name, type: 'exact_name', resolution: 'local-priority',
+        winner: localVersion, rejected: versions.filter(v => v !== localVersion),
+      });
+      continue;
+    }
+
+    // Tier 3b: Priority by source order (lower priority number wins)
+    // Just pick the first version (sources are ordered by priority)
+    resolutions.push({
+      name, type: 'exact_name', resolution: 'source-priority',
+      winner: versions[0], rejected: versions.slice(1),
+    });
+  }
+
+  return resolutions;
+}
+
+/**
+ * Apply resolutions and create merged item list
+ */
+function applyResolutions(sourcesArray, resolutions) {
+  const merged = new Map();
+  const conflictNames = new Set();
+
+  for (const resolution of resolutions) {
+    if (resolution.type === 'exact_name') {
+      conflictNames.add(resolution.name);
+    }
+  }
+
+  for (const source of sourcesArray) {
+    // Support both `items` (new API) and `skills` (backward-compatible alias)
+    const entries = source.items || source.skills || [];
+    for (const item of entries) {
+      if (!conflictNames.has(item.name)) {
+        merged.set(item.name, { ...item, sourceName: source.name });
+      }
+    }
+  }
+
+  for (const resolution of resolutions) {
+    if (resolution.type === 'similar_description') continue;
+    if (resolution.resolution === 'namespace') {
+      for (const ns of resolution.namespaced) {
+        merged.set(ns.namespacedName, ns);
+      }
+    } else if (resolution.winner) {
+      merged.set(resolution.name, resolution.winner);
+    }
+  }
+
+  return Array.from(merged.values());
+}
+
+/**
+ * Generate merge report
+ */
+function generateReport(artifactType, conflicts, resolutions) {
+  const report = {
+    timestamp: new Date().toISOString(),
+    artifactType,
+    summary: {
+      total_conflicts: conflicts.length,
+      exact_name_conflicts: conflicts.filter(c => c.type === 'exact_name').length,
+      similar_description_warnings: conflicts.filter(c => c.type === 'similar_description').length,
+      resolutions: {},
+    },
+    conflicts: [],
+  };
+
+  for (const resolution of resolutions) {
+    report.summary.resolutions[resolution.resolution] =
+      (report.summary.resolutions[resolution.resolution] || 0) + 1;
+
+    const conflictData = {
+      name: resolution.name,
+      type: resolution.type,
+      resolution: resolution.resolution,
+    };
+
+    if (resolution.similarity !== undefined) {
+      conflictData.similarity = resolution.similarity;
+      conflictData.message = resolution.message;
+    }
+    if (resolution.winner) {
+      conflictData.winner = { source: resolution.winner.sourceName };
+    }
+    if (resolution.rejected) {
+      conflictData.rejected = resolution.rejected.map(r => ({ source: r.sourceName }));
+    }
+
+    report.conflicts.push(conflictData);
+  }
+
+  return report;
+}
+
+module.exports = {
+  calculateDescriptionSimilarity,
+  compareVersions,
+  detectConflicts,
+  resolveConflicts,
+  applyResolutions,
+  generateReport,
+};

package/src/merge/claude-md-merger.js

@@ -0,0 +1,55 @@
+/* eslint-disable no-console */
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Load CLAUDE.md content from a source directory
+ */
+function loadClaudeMd(sourceDir) {
+  const candidates = [
+    path.join(sourceDir, 'CLAUDE.md'),
+    path.join(sourceDir, 'claude.md'),
+  ];
+  for (const p of candidates) {
+    if (fs.existsSync(p)) {
+      return fs.readFileSync(p, 'utf8');
+    }
+  }
+  return null;
+}
+
+/**
+ * Assemble sections from multiple sources into a single CLAUDE.md
+ */
+function assembleSections(sections) {
+  return sections.map(s => s.content).join('\n\n').trimEnd() + '\n';
+}
+
+/**
+ * Merge new sections into an existing CLAUDE.md
+ * Wraps each source block in OMC markers to allow idempotent updates
+ */
+function mergeIntoExisting(existing, sections) {
+  let result = existing;
+
+  for (const { sourceName, content } of sections) {
+    const startMarker = `<!-- OMC:${sourceName}:START -->`;
+    const endMarker = `<!-- OMC:${sourceName}:END -->`;
+    const block = `${startMarker}\n${content.trimEnd()}\n${endMarker}`;
+
+    const startIdx = result.indexOf(startMarker);
+    const endIdx = result.indexOf(endMarker);
+
+    if (startIdx !== -1 && endIdx !== -1) {
+      // Replace existing block
+      result = result.slice(0, startIdx) + block + result.slice(endIdx + endMarker.length);
+    } else {
+      // Append new block
+      result = result.trimEnd() + '\n\n' + block + '\n';
+    }
+  }
+
+  return result;
+}
+
+module.exports = { loadClaudeMd, assembleSections, mergeIntoExisting };

package/src/merge/command-merger.js

@@ -0,0 +1,35 @@
+/* eslint-disable no-console */
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Load commands from a source directory (recursive .md files)
+ */
+function loadCommandsFromSource(sourceDir, sourceName) {
+  if (!fs.existsSync(sourceDir)) return [];
+
+  const items = [];
+
+  function walk(dir, prefix) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath, prefix ? `${prefix}/${entry.name}` : entry.name);
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        const baseName = path.basename(entry.name, '.md');
+        const name = prefix ? `${prefix}/${baseName}` : baseName;
+        items.push({
+          name,
+          path: fullPath,
+          metadata: {},
+        });
+      }
+    }
+  }
+
+  walk(sourceDir, '');
+  return items;
+}
+
+module.exports = { loadCommandsFromSource };

package/src/merge/file-merger.js

@@ -0,0 +1,35 @@
+/* eslint-disable no-console */
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Load files from a source directory
+ */
+function loadFilesFromSource(sourceDir, sourceName) {
+  if (!fs.existsSync(sourceDir)) return [];
+
+  const items = [];
+  const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(sourceDir, entry.name);
+    if (entry.isFile()) {
+      items.push({
+        name: entry.name,
+        path: fullPath,
+        metadata: { name: entry.name },
+      });
+    } else if (entry.isDirectory()) {
+      items.push({
+        name: entry.name,
+        path: fullPath,
+        isDirectory: true,
+        metadata: { name: entry.name },
+      });
+    }
+  }
+
+  return items;
+}
+
+module.exports = { loadFilesFromSource };