oh-my-claude-sisyphus 3.5.7 → 3.5.8

package/dist/hooks/skill-bridge.cjs

@@ -0,0 +1,349 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/learner/bridge.ts
+var bridge_exports = {};
+__export(bridge_exports, {
+  PROJECT_SKILLS_SUBDIR: () => PROJECT_SKILLS_SUBDIR,
+  SKILL_EXTENSION: () => SKILL_EXTENSION,
+  USER_SKILLS_DIR: () => USER_SKILLS_DIR,
+  findSkillFiles: () => findSkillFiles,
+  getInjectedSkillPaths: () => getInjectedSkillPaths,
+  markSkillsInjected: () => markSkillsInjected,
+  matchSkillsForInjection: () => matchSkillsForInjection,
+  parseSkillFile: () => parseSkillFile
+});
+module.exports = __toCommonJS(bridge_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_os = require("os");
+var USER_SKILLS_DIR = (0, import_path.join)((0, import_os.homedir)(), ".claude", "skills", "omc-learned");
+var PROJECT_SKILLS_SUBDIR = ".omc/skills";
+var SKILL_EXTENSION = ".md";
+var SESSION_TTL_MS = 60 * 60 * 1e3;
+var STATE_FILE = ".omc/state/skill-sessions.json";
+function getStateFilePath(projectRoot) {
+  return (0, import_path.join)(projectRoot, STATE_FILE);
+}
+function readSessionState(projectRoot) {
+  const stateFile = getStateFilePath(projectRoot);
+  try {
+    if ((0, import_fs.existsSync)(stateFile)) {
+      const content = (0, import_fs.readFileSync)(stateFile, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return { sessions: {} };
+}
+function writeSessionState(projectRoot, state) {
+  const stateFile = getStateFilePath(projectRoot);
+  try {
+    (0, import_fs.mkdirSync)((0, import_path.dirname)(stateFile), { recursive: true });
+    (0, import_fs.writeFileSync)(stateFile, JSON.stringify(state, null, 2), "utf-8");
+  } catch {
+  }
+}
+function getInjectedSkillPaths(sessionId, projectRoot) {
+  const state = readSessionState(projectRoot);
+  const session = state.sessions[sessionId];
+  if (!session) return [];
+  if (Date.now() - session.timestamp > SESSION_TTL_MS) {
+    return [];
+  }
+  return session.injectedPaths;
+}
+function markSkillsInjected(sessionId, paths, projectRoot) {
+  const state = readSessionState(projectRoot);
+  const now = Date.now();
+  for (const [id, session] of Object.entries(state.sessions)) {
+    if (now - session.timestamp > SESSION_TTL_MS) {
+      delete state.sessions[id];
+    }
+  }
+  const existing = state.sessions[sessionId]?.injectedPaths ?? [];
+  state.sessions[sessionId] = {
+    injectedPaths: [.../* @__PURE__ */ new Set([...existing, ...paths])],
+    timestamp: now
+  };
+  writeSessionState(projectRoot, state);
+}
+function findSkillFilesRecursive(dir, results) {
+  if (!(0, import_fs.existsSync)(dir)) return;
+  try {
+    const entries = (0, import_fs.readdirSync)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = (0, import_path.join)(dir, entry.name);
+      if (entry.isDirectory()) {
+        findSkillFilesRecursive(fullPath, results);
+      } else if (entry.isFile() && entry.name.endsWith(SKILL_EXTENSION)) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+}
+function safeRealpathSync(filePath) {
+  try {
+    return (0, import_fs.realpathSync)(filePath);
+  } catch {
+    return filePath;
+  }
+}
+function findSkillFiles(projectRoot) {
+  const candidates = [];
+  const seenRealPaths = /* @__PURE__ */ new Set();
+  const projectSkillsDir = (0, import_path.join)(projectRoot, PROJECT_SKILLS_SUBDIR);
+  const projectFiles = [];
+  findSkillFilesRecursive(projectSkillsDir, projectFiles);
+  for (const filePath of projectFiles) {
+    const realPath = safeRealpathSync(filePath);
+    if (seenRealPaths.has(realPath)) continue;
+    seenRealPaths.add(realPath);
+    candidates.push({
+      path: filePath,
+      realPath,
+      scope: "project"
+    });
+  }
+  const userFiles = [];
+  findSkillFilesRecursive(USER_SKILLS_DIR, userFiles);
+  for (const filePath of userFiles) {
+    const realPath = safeRealpathSync(filePath);
+    if (seenRealPaths.has(realPath)) continue;
+    seenRealPaths.add(realPath);
+    candidates.push({
+      path: filePath,
+      realPath,
+      scope: "user"
+    });
+  }
+  return candidates;
+}
+function parseSkillFile(content) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return {
+      metadata: {},
+      content: content.trim(),
+      valid: true,
+      errors: []
+    };
+  }
+  const yamlContent = match[1];
+  const body = match[2].trim();
+  const errors = [];
+  try {
+    const metadata = parseYamlMetadata(yamlContent);
+    return {
+      metadata,
+      content: body,
+      valid: true,
+      errors
+    };
+  } catch (e) {
+    return {
+      metadata: {},
+      content: body,
+      valid: false,
+      errors: [`YAML parse error: ${e}`]
+    };
+  }
+}
+function parseYamlMetadata(yamlContent) {
+  const lines = yamlContent.split("\n");
+  const metadata = {};
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+      i++;
+      continue;
+    }
+    const key = line.slice(0, colonIndex).trim();
+    const rawValue = line.slice(colonIndex + 1).trim();
+    switch (key) {
+      case "id":
+        metadata.id = parseStringValue(rawValue);
+        break;
+      case "name":
+        metadata.name = parseStringValue(rawValue);
+        break;
+      case "description":
+        metadata.description = parseStringValue(rawValue);
+        break;
+      case "model":
+        metadata.model = parseStringValue(rawValue);
+        break;
+      case "agent":
+        metadata.agent = parseStringValue(rawValue);
+        break;
+      case "matching":
+        metadata.matching = parseStringValue(rawValue);
+        break;
+      case "triggers":
+      case "tags": {
+        const { value, consumed } = parseArrayValue(rawValue, lines, i);
+        if (key === "triggers") {
+          metadata.triggers = Array.isArray(value) ? value : value ? [value] : [];
+        } else {
+          metadata.tags = Array.isArray(value) ? value : value ? [value] : [];
+        }
+        i += consumed - 1;
+        break;
+      }
+    }
+    i++;
+  }
+  return metadata;
+}
+function parseStringValue(value) {
+  if (!value) return "";
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function parseArrayValue(rawValue, lines, currentIndex) {
+  if (rawValue.startsWith("[")) {
+    const content = rawValue.slice(1, rawValue.lastIndexOf("]")).trim();
+    if (!content) return { value: [], consumed: 1 };
+    const items = content.split(",").map((s) => parseStringValue(s.trim())).filter(Boolean);
+    return { value: items, consumed: 1 };
+  }
+  if (!rawValue || rawValue === "") {
+    const items = [];
+    let consumed = 1;
+    for (let j = currentIndex + 1; j < lines.length; j++) {
+      const nextLine = lines[j];
+      const arrayMatch = nextLine.match(/^\s+-\s*(.*)$/);
+      if (arrayMatch) {
+        const itemValue = parseStringValue(arrayMatch[1].trim());
+        if (itemValue) items.push(itemValue);
+        consumed++;
+      } else if (nextLine.trim() === "") {
+        consumed++;
+      } else {
+        break;
+      }
+    }
+    if (items.length > 0) {
+      return { value: items, consumed };
+    }
+  }
+  return { value: parseStringValue(rawValue), consumed: 1 };
+}
+function levenshteinDistance(str1, str2) {
+  const m = str1.length;
+  const n = str2.length;
+  const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (str1[i - 1] === str2[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1];
+      } else {
+        dp[i][j] = 1 + Math.min(
+          dp[i - 1][j],
+          dp[i][j - 1],
+          dp[i - 1][j - 1]
+        );
+      }
+    }
+  }
+  return dp[m][n];
+}
+function fuzzyMatchTrigger(prompt, trigger) {
+  const words = prompt.split(/\s+/).filter((w) => w.length > 0);
+  for (const word of words) {
+    if (word === trigger) return 100;
+    if (word.includes(trigger) || trigger.includes(word)) {
+      return 80;
+    }
+  }
+  let bestScore = 0;
+  for (const word of words) {
+    const distance = levenshteinDistance(word, trigger);
+    const maxLen = Math.max(word.length, trigger.length);
+    const similarity = maxLen > 0 ? (maxLen - distance) / maxLen * 100 : 0;
+    bestScore = Math.max(bestScore, similarity);
+  }
+  return Math.round(bestScore);
+}
+function matchSkillsForInjection(prompt, projectRoot, sessionId, options = {}) {
+  const { fuzzyThreshold = 60, maxResults = 5 } = options;
+  const promptLower = prompt.toLowerCase();
+  const alreadyInjected = new Set(getInjectedSkillPaths(sessionId, projectRoot));
+  const candidates = findSkillFiles(projectRoot);
+  const matches = [];
+  for (const candidate of candidates) {
+    if (alreadyInjected.has(candidate.path)) continue;
+    try {
+      const content = (0, import_fs.readFileSync)(candidate.path, "utf-8");
+      const parsed = parseSkillFile(content);
+      if (!parsed) continue;
+      const triggers = parsed.metadata.triggers ?? [];
+      if (triggers.length === 0) continue;
+      const useFuzzy = parsed.metadata.matching === "fuzzy";
+      let totalScore = 0;
+      for (const trigger of triggers) {
+        const triggerLower = trigger.toLowerCase();
+        if (promptLower.includes(triggerLower)) {
+          totalScore += 10;
+          continue;
+        }
+        if (useFuzzy) {
+          const fuzzyScore = fuzzyMatchTrigger(promptLower, triggerLower);
+          if (fuzzyScore >= fuzzyThreshold) {
+            totalScore += Math.round(fuzzyScore / 10);
+          }
+        }
+      }
+      if (totalScore > 0) {
+        const name = parsed.metadata.name || (0, import_path.basename)(candidate.path, SKILL_EXTENSION);
+        matches.push({
+          path: candidate.path,
+          name,
+          content: parsed.content,
+          score: totalScore,
+          scope: candidate.scope,
+          triggers,
+          matching: parsed.metadata.matching
+        });
+      }
+    } catch {
+    }
+  }
+  matches.sort((a, b) => b.score - a.score);
+  return matches.slice(0, maxResults);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PROJECT_SKILLS_SUBDIR,
+  SKILL_EXTENSION,
+  USER_SKILLS_DIR,
+  findSkillFiles,
+  getInjectedSkillPaths,
+  markSkillsInjected,
+  matchSkillsForInjection,
+  parseSkillFile
+});

package/dist/installer/index.d.ts

@@ -31,7 +31,7 @@ export declare const VERSION_FILE: string;
  */
 export declare const CORE_COMMANDS: string[];
 /** Current version */
-export declare const VERSION = "3.4.0";
+export declare const VERSION = "3.5.8";
 /** Installation result */
 export interface InstallResult {
     success: boolean;

package/dist/installer/index.js

@@ -37,7 +37,7 @@ export const VERSION_FILE = join(CLAUDE_CONFIG_DIR, '.omc-version.json');
  */
 export const CORE_COMMANDS = [];
 /** Current version */
-export const VERSION = '3.4.0';
+export const VERSION = '3.5.8';
 /**
  * Check if the current Node.js version meets the minimum requirement
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-claude-sisyphus",
-  "version": "3.5.7",
+  "version": "3.5.8",
   "description": "Multi-agent orchestration system for Claude Code - Inspired by oh-my-opencode",
   "type": "module",
   "main": "dist/index.js",
@@ -30,7 +30,8 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node scripts/build-skill-bridge.mjs",
+    "build:bridge": "node scripts/build-skill-bridge.mjs",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
     "test": "vitest",
@@ -61,6 +62,7 @@
     "@typescript-eslint/eslint-plugin": "^8.18.2",
     "@typescript-eslint/parser": "^8.18.2",
     "@vitest/ui": "^4.0.17",
+    "esbuild": "^0.27.2",
     "eslint": "^9.17.0",
     "prettier": "^3.4.2",
     "tsx": "^4.19.2",

package/scripts/build-skill-bridge.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+/**
+ * Build script for skill-bridge.cjs bundle
+ * Bundles the TypeScript learner bridge module into a standalone CJS file
+ * that skill-injector.mjs can require()
+ */
+
+import * as esbuild from 'esbuild';
+import { mkdir } from 'fs/promises';
+import { dirname } from 'path';
+
+const outfile = 'dist/hooks/skill-bridge.cjs';
+
+// Ensure output directory exists
+await mkdir(dirname(outfile), { recursive: true });
+
+await esbuild.build({
+  entryPoints: ['src/hooks/learner/bridge.ts'],
+  bundle: true,
+  platform: 'node',
+  target: 'node18',
+  format: 'cjs',
+  outfile,
+  // Externalize Node.js built-ins (they're available at runtime)
+  external: [
+    'fs', 'path', 'os', 'util', 'stream', 'events',
+    'buffer', 'crypto', 'http', 'https', 'url',
+    'child_process', 'assert', 'module'
+  ],
+});
+
+console.log(`Built ${outfile}`);

package/scripts/skill-injector.mjs

@@ -4,34 +4,41 @@
  * Skill Injector Hook (UserPromptSubmit)
  * Injects relevant learned skills into context based on prompt triggers.
  *
- * STANDALONE SCRIPT - does not import from dist/
- * Follows pattern of keyword-detector.mjs and session-start.mjs
+ * STANDALONE SCRIPT - uses compiled bridge bundle from dist/hooks/skill-bridge.cjs
+ * Falls back to inline implementation if bundle not available (first run before build)
+ *
+ * Enhancement in v3.5: Now uses RECURSIVE discovery (skills in subdirectories included)
  */
 
 import { existsSync, readdirSync, readFileSync, realpathSync } from 'fs';
-import { join } from 'path';
+import { join, basename } from 'path';
 import { homedir } from 'os';
+import { createRequire } from 'module';
+
+// Try to load the compiled bridge bundle
+const require = createRequire(import.meta.url);
+let bridge = null;
+try {
+  bridge = require('../dist/hooks/skill-bridge.cjs');
+} catch {
+  // Bridge not available - use fallback (first run before build, or dist/ missing)
+}
 
-// Constants
+// Constants (used by fallback)
 const USER_SKILLS_DIR = join(homedir(), '.claude', 'skills', 'omc-learned');
 const PROJECT_SKILLS_SUBDIR = '.omc/skills';
 const SKILL_EXTENSION = '.md';
 const MAX_SKILLS_PER_SESSION = 5;
 
-// Session cache to avoid re-injecting same skills
-const injectedCache = new Map();
+// =============================================================================
+// Fallback Implementation (used when bridge bundle not available)
+// =============================================================================
 
-// Read all stdin
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks).toString('utf-8');
-}
+// In-memory cache (resets each process - known limitation, fixed by bridge)
+const injectedCacheFallback = new Map();
 
-// Parse YAML frontmatter from skill file
-function parseSkillFrontmatter(content) {
+// Parse YAML frontmatter from skill file (fallback)
+function parseSkillFrontmatterFallback(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
   if (!match) return null;
 
@@ -56,8 +63,8 @@ function parseSkillFrontmatter(content) {
   return { name, triggers, content: body };
 }
 
-// Find all skill files
-function findSkillFiles(directory) {
+// Find all skill files (fallback - NON-RECURSIVE for backward compat)
+function findSkillFilesFallback(directory) {
   const candidates = [];
   const seenPaths = new Set();
 
@@ -111,17 +118,17 @@ function findSkillFiles(directory) {
   return candidates;
 }
 
-// Find matching skills by trigger keywords
-function findMatchingSkills(prompt, directory, sessionId) {
+// Find matching skills (fallback)
+function findMatchingSkillsFallback(prompt, directory, sessionId) {
   const promptLower = prompt.toLowerCase();
-  const candidates = findSkillFiles(directory);
+  const candidates = findSkillFilesFallback(directory);
   const matches = [];
 
   // Get or create session cache
-  if (!injectedCache.has(sessionId)) {
-    injectedCache.set(sessionId, new Set());
+  if (!injectedCacheFallback.has(sessionId)) {
+    injectedCacheFallback.set(sessionId, new Set());
   }
-  const alreadyInjected = injectedCache.get(sessionId);
+  const alreadyInjected = injectedCacheFallback.get(sessionId);
 
   for (const candidate of candidates) {
     // Skip if already injected this session
@@ -129,7 +136,7 @@ function findMatchingSkills(prompt, directory, sessionId) {
 
     try {
       const content = readFileSync(candidate.path, 'utf-8');
-      const skill = parseSkillFrontmatter(content);
+      const skill = parseSkillFrontmatterFallback(content);
       if (!skill) continue;
 
       // Check if any trigger matches
@@ -146,7 +153,8 @@ function findMatchingSkills(prompt, directory, sessionId) {
           name: skill.name,
           content: skill.content,
           score,
-          scope: candidate.scope
+          scope: candidate.scope,
+          triggers: skill.triggers
         });
       }
     } catch {
@@ -166,6 +174,39 @@ function findMatchingSkills(prompt, directory, sessionId) {
   return selected;
 }
 
+// =============================================================================
+// Main Logic (uses bridge if available, fallback otherwise)
+// =============================================================================
+
+// Read all stdin
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf-8');
+}
+
+// Find matching skills - delegates to bridge or fallback
+function findMatchingSkills(prompt, directory, sessionId) {
+  if (bridge) {
+    // Use bridge (RECURSIVE discovery, persistent session cache)
+    const matches = bridge.matchSkillsForInjection(prompt, directory, sessionId, {
+      maxResults: MAX_SKILLS_PER_SESSION
+    });
+
+    // Mark as injected via bridge
+    if (matches.length > 0) {
+      bridge.markSkillsInjected(sessionId, matches.map(s => s.path), directory);
+    }
+
+    return matches;
+  }
+
+  // Fallback (NON-RECURSIVE, in-memory cache)
+  return findMatchingSkillsFallback(prompt, directory, sessionId);
+}
+
 // Format skills for injection
 function formatSkillsMessage(skills) {
   const lines = [
@@ -179,7 +220,17 @@ function formatSkillsMessage(skills) {
 
   for (const skill of skills) {
     lines.push(`### ${skill.name} (${skill.scope})`);
+
+    // Add metadata block for programmatic parsing
+    const metadata = {
+      path: skill.path,
+      triggers: skill.triggers,
+      score: skill.score,
+      scope: skill.scope
+    };
+    lines.push(`<skill-metadata>${JSON.stringify(metadata)}</skill-metadata>`);
     lines.push('');
+
     lines.push(skill.content);
     lines.push('');
     lines.push('---');