oh-my-customcode 0.1.4 → 0.2.1

package/dist/cli/index.js

@@ -12095,34 +12095,18 @@ async function countDirectories(dirPath) {
   const entries = await fs.readdir(dirPath, { withFileTypes: true });
   return entries.filter((e) => e.isDirectory()).length;
 }
-async function countAgentsInTypeDir(typePath) {
+async function countAgents(agentsDir) {
   let count = 0;
   try {
-    const entries = await fs.readdir(typePath, { withFileTypes: true });
+    const entries = await fs.readdir(agentsDir, { withFileTypes: true });
     for (const entry of entries) {
-      if (!entry.isDirectory())
-        continue;
-      const agentMdPath = path.join(typePath, entry.name, "AGENT.md");
-      if (await pathExists(agentMdPath)) {
+      if (entry.isFile() && entry.name.endsWith(".md")) {
         count++;
       }
     }
   } catch {}
   return count;
 }
-async function countAgents(agentsDir) {
-  let count = 0;
-  try {
-    const typeEntries = await fs.readdir(agentsDir, { withFileTypes: true });
-    for (const typeEntry of typeEntries) {
-      if (!typeEntry.isDirectory())
-        continue;
-      const typePath = path.join(agentsDir, typeEntry.name);
-      count += await countAgentsInTypeDir(typePath);
-    }
-  } catch {}
-  return count;
-}
 async function checkClaudeMd(targetDir) {
   const claudeMdPath = path.join(targetDir, "CLAUDE.md");
   const exists2 = await pathExists(claudeMdPath);
@@ -12161,7 +12145,7 @@ async function checkRules(targetDir) {
   };
 }
 async function checkAgents(targetDir) {
-  const agentsDir = path.join(targetDir, "agents");
+  const agentsDir = path.join(targetDir, ".claude", "agents");
   const exists2 = await isDirectory(agentsDir);
   if (!exists2) {
     return {
@@ -12188,17 +12172,8 @@ async function checkAgents(targetDir) {
   };
 }
 async function checkSymlinks(targetDir) {
-  const agentsDir = path.join(targetDir, "agents");
-  const skillsDir = path.join(targetDir, "skills");
+  const skillsDir = path.join(targetDir, ".claude", "skills");
   const brokenSymlinks = [];
-  if (await isDirectory(agentsDir)) {
-    const agentSymlinks = await findRefsSymlinks(agentsDir);
-    for (const symlink of agentSymlinks) {
-      if (!await isValidSymlink(symlink)) {
-        brokenSymlinks.push(symlink);
-      }
-    }
-  }
   if (await isDirectory(skillsDir)) {
     const skillSymlinks = await findRefsSymlinks(skillsDir);
     for (const symlink of skillSymlinks) {
@@ -12259,7 +12234,7 @@ async function checkIndexFiles(targetDir) {
   };
 }
 async function checkSkills(targetDir) {
-  const skillsDir = path.join(targetDir, "skills");
+  const skillsDir = path.join(targetDir, ".claude", "skills");
   const exists2 = await isDirectory(skillsDir);
   if (!exists2) {
     return {
@@ -12285,6 +12260,105 @@ async function checkSkills(targetDir) {
     fixable: false
   };
 }
+async function checkGuides(targetDir) {
+  const guidesDir = path.join(targetDir, "guides");
+  const exists2 = await isDirectory(guidesDir);
+  if (!exists2) {
+    return {
+      name: "Guides",
+      status: "fail",
+      message: "guides/ directory not found",
+      fixable: true
+    };
+  }
+  const topicCount = await countDirectories(guidesDir);
+  if (topicCount === 0) {
+    return {
+      name: "Guides",
+      status: "warn",
+      message: "guides/ directory is empty (0 topics found)",
+      fixable: false
+    };
+  }
+  return {
+    name: "Guides",
+    status: "pass",
+    message: `Guides OK (${topicCount} topics)`,
+    fixable: false
+  };
+}
+async function checkHooks(targetDir) {
+  const hooksDir = path.join(targetDir, ".claude", "hooks");
+  const exists2 = await isDirectory(hooksDir);
+  if (!exists2) {
+    return {
+      name: "Hooks",
+      status: "fail",
+      message: ".claude/hooks/ directory not found",
+      fixable: true
+    };
+  }
+  const hookFiles = await findFiles(hooksDir, /\.(sh|json|yaml)$/);
+  if (hookFiles.length === 0) {
+    return {
+      name: "Hooks",
+      status: "warn",
+      message: ".claude/hooks/ directory is empty",
+      fixable: false
+    };
+  }
+  return {
+    name: "Hooks",
+    status: "pass",
+    message: `Hooks OK (${hookFiles.length} files)`,
+    fixable: false
+  };
+}
+async function checkPipelines(targetDir) {
+  const pipelinesDir = path.join(targetDir, "pipelines");
+  const exists2 = await isDirectory(pipelinesDir);
+  if (!exists2) {
+    return {
+      name: "Pipelines",
+      status: "fail",
+      message: "pipelines/ directory not found",
+      fixable: true
+    };
+  }
+  return {
+    name: "Pipelines",
+    status: "pass",
+    message: "Pipelines OK",
+    fixable: false
+  };
+}
+async function checkContexts(targetDir) {
+  const contextsDir = path.join(targetDir, ".claude", "contexts");
+  const exists2 = await isDirectory(contextsDir);
+  if (!exists2) {
+    return {
+      name: "Contexts",
+      status: "fail",
+      message: ".claude/contexts/ directory not found",
+      fixable: true
+    };
+  }
+  const contextFiles = await findFiles(contextsDir, /\.md$/);
+  if (contextFiles.length === 0) {
+    return {
+      name: "Contexts",
+      status: "warn",
+      message: ".claude/contexts/ directory is empty",
+      fixable: false
+    };
+  }
+  return {
+    name: "Contexts",
+    status: "pass",
+    message: `Contexts OK (${contextFiles.length} files)`,
+    fixable: false
+  };
+}
 async function fixBrokenSymlinks(_targetDir, brokenSymlinks) {
   let fixed = 0;
   for (const symlink of brokenSymlinks) {
@@ -12306,8 +12380,12 @@ async function createMissingDirectory(dirPath) {
 async function fixSingleIssue(check, targetDir) {
   const fixMap = {
     Rules: () => createMissingDirectory(path.join(targetDir, ".claude", "rules")),
-    Agents: () => createMissingDirectory(path.join(targetDir, "agents")),
-    Skills: () => createMissingDirectory(path.join(targetDir, "skills")),
+    Agents: () => createMissingDirectory(path.join(targetDir, ".claude", "agents")),
+    Skills: () => createMissingDirectory(path.join(targetDir, ".claude", "skills")),
+    Guides: () => createMissingDirectory(path.join(targetDir, "guides")),
+    Hooks: () => createMissingDirectory(path.join(targetDir, ".claude", "hooks")),
+    Pipelines: () => createMissingDirectory(path.join(targetDir, "pipelines")),
+    Contexts: () => createMissingDirectory(path.join(targetDir, ".claude", "contexts")),
     Symlinks: async () => {
       if (!check.details || check.details.length === 0)
         return false;
@@ -12360,7 +12438,11 @@ async function doctorCommand(options = {}) {
     checkAgents(targetDir),
     checkSkills(targetDir),
     checkSymlinks(targetDir),
-    checkIndexFiles(targetDir)
+    checkIndexFiles(targetDir),
+    checkGuides(targetDir),
+    checkHooks(targetDir),
+    checkPipelines(targetDir),
+    checkContexts(targetDir)
   ]);
   if (options.fix) {
     const hasFixableIssues = checks.some((c) => c.status === "fail" && c.fixable);
@@ -12830,37 +12912,20 @@ var DIRECTORY_STRUCTURE = [
   ".claude/rules",
   ".claude/hooks",
   ".claude/contexts",
-  "agents",
-  "agents/master",
-  "agents/orchestrator",
-  "agents/manager",
-  "agents/system",
-  "agents/sw-engineer",
-  "agents/sw-architect",
-  "agents/backend-engineer",
-  "agents/infra-engineer",
-  "agents/qa-engineer",
-  "agents/tutor",
-  "skills",
-  "skills/development",
-  "skills/backend",
-  "skills/infrastructure",
-  "skills/system",
-  "skills/orchestration",
+  ".claude/agents",
+  ".claude/skills",
   "guides",
   "pipelines",
   "pipelines/templates",
-  "pipelines/examples",
-  "commands"
+  "pipelines/examples"
 ];
 var COMPONENT_PATHS = {
   "claude-md": "",
   rules: ".claude/rules",
-  agents: "agents",
-  skills: "skills",
+  agents: ".claude/agents",
+  skills: ".claude/skills",
   guides: "guides",
   pipelines: "pipelines",
-  commands: "commands",
   hooks: ".claude/hooks",
   contexts: ".claude/contexts"
 };
@@ -12973,7 +13038,7 @@ async function createDirectoryStructure(targetDir) {
   }
 }
 function getAllComponents() {
-  return ["rules", "agents", "skills", "guides", "pipelines", "commands", "hooks", "contexts"];
+  return ["rules", "agents", "skills", "guides", "pipelines", "hooks", "contexts"];
 }
 async function installComponent(targetDir, component, options) {
   const templatePath = COMPONENT_PATHS[component];
@@ -13023,15 +13088,7 @@ async function backupExisting(sourcePath, backupDir) {
   return backupPath;
 }
 async function checkExistingPaths(targetDir) {
-  const pathsToCheck = [
-    "CLAUDE.md",
-    ".claude",
-    "agents",
-    "skills",
-    "guides",
-    "pipelines",
-    "commands"
-  ];
+  const pathsToCheck = ["CLAUDE.md", ".claude", "guides", "pipelines"];
   const existingPaths = [];
   for (const relativePath of pathsToCheck) {
     const fullPath = join3(targetDir, relativePath);
@@ -13192,14 +13249,26 @@ function parseYamlMetadata(content) {
   }
   return result;
 }
-function extractAgentTypeFromPath(agentPath, baseDir) {
-  const relativePath = relative(join5(baseDir, "agents"), agentPath);
-  const parts = relativePath.split("/").filter(Boolean);
-  parts.pop();
-  return parts.join("/") || "unknown";
+function extractAgentTypeFromFilename(filename) {
+  const name = basename2(filename, ".md");
+  const prefixMap = {
+    lang: "language",
+    be: "backend",
+    fe: "frontend",
+    tool: "tooling",
+    db: "database",
+    arch: "architect",
+    infra: "infrastructure",
+    qa: "qa",
+    mgr: "manager",
+    sys: "system",
+    tutor: "tutor"
+  };
+  const prefix = name.split("-")[0];
+  return prefixMap[prefix] || "unknown";
 }
 function extractSkillCategoryFromPath(skillPath, baseDir) {
-  const relativePath = relative(join5(baseDir, "skills"), skillPath);
+  const relativePath = relative(join5(baseDir, ".claude", "skills"), skillPath);
   const parts = relativePath.split("/").filter(Boolean);
   return parts[0] || "unknown";
 }
@@ -13213,28 +13282,67 @@ function extractRulePriorityFromFilename(filename) {
   const parts = name.split("-");
   return parts[0] || "unknown";
 }
+function shouldSkipLine(trimmed, inFrontmatter) {
+  if (inFrontmatter)
+    return true;
+  if (trimmed.startsWith("#"))
+    return true;
+  if (trimmed.startsWith("```"))
+    return true;
+  if (trimmed === "---")
+    return true;
+  return false;
+}
+function cleanMarkdownFormatting(text) {
+  return text.replace(/\*\*/g, "").replace(/\*/g, "");
+}
+function truncateText(text, maxLength) {
+  if (!maxLength || text.length <= maxLength)
+    return text;
+  return `${text.substring(0, maxLength)}...`;
+}
+function processDescription(text, options) {
+  const cleaned = options.cleanFormatting ? cleanMarkdownFormatting(text) : text;
+  return truncateText(cleaned, options.maxLength);
+}
+function extractFromBlockquote(trimmed, options) {
+  const text = trimmed.replace(/^>\s*/, "").trim();
+  return processDescription(text, options);
+}
+function* skipFrontmatter(lines) {
+  let inFrontmatter = false;
+  let lineIndex = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (lineIndex === 0 && trimmed === "---") {
+      inFrontmatter = true;
+      lineIndex++;
+      continue;
+    }
+    if (inFrontmatter && trimmed === "---") {
+      inFrontmatter = false;
+      lineIndex++;
+      continue;
+    }
+    if (!inFrontmatter) {
+      yield { trimmed, lineIndex };
+    }
+    lineIndex++;
+  }
+}
 function extractDescriptionFromMarkdown(content, options = {}) {
   const { maxLength, cleanFormatting = false } = options;
   const lines = content.split(`
 `);
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("#") || trimmed.startsWith("```") || trimmed.startsWith("---")) {
+  for (const { trimmed } of skipFrontmatter(lines)) {
+    if (shouldSkipLine(trimmed, false)) {
       continue;
     }
     if (trimmed.startsWith(">")) {
-      let description = trimmed.replace(/^>\s*/, "").trim();
-      if (cleanFormatting) {
-        description = description.replace(/\*\*/g, "").replace(/\*/g, "");
-      }
-      return description;
+      return extractFromBlockquote(trimmed, { cleanFormatting, maxLength });
     }
     if (trimmed) {
-      let description = trimmed;
-      if (maxLength && description.length > maxLength) {
-        description = `${description.substring(0, maxLength)}...`;
-      }
-      return description;
+      return processDescription(trimmed, { cleanFormatting, maxLength });
     }
   }
   return;
@@ -13259,22 +13367,21 @@ async function tryExtractMarkdownDescription(mdPath, options = {}) {
   }
 }
 async function getAgents(targetDir) {
-  const agentsDir = join5(targetDir, "agents");
+  const agentsDir = join5(targetDir, ".claude", "agents");
   if (!await fileExists(agentsDir))
     return [];
   try {
-    const agentMdFiles = await listFiles(agentsDir, { recursive: true, pattern: "AGENT.md" });
+    const agentMdFiles = await listFiles(agentsDir, { recursive: false, pattern: "*.md" });
     const agents = await Promise.all(agentMdFiles.map(async (agentMdPath) => {
-      const agentDir = dirname2(agentMdPath);
-      const indexYamlPath = join5(agentDir, "index.yaml");
-      const { description: yamlDesc, version } = await tryReadIndexYamlMetadata(indexYamlPath);
-      const description = yamlDesc ?? await tryExtractMarkdownDescription(agentMdPath);
+      const filename = basename2(agentMdPath);
+      const name = basename2(filename, ".md");
+      const description = await tryExtractMarkdownDescription(agentMdPath);
       return {
-        name: basename2(agentDir),
-        type: extractAgentTypeFromPath(agentDir, targetDir),
-        path: relative(targetDir, agentDir),
+        name,
+        type: extractAgentTypeFromFilename(filename),
+        path: relative(targetDir, agentMdPath),
         description,
-        version
+        version: undefined
       };
     }));
     return agents.sort((a, b) => a.name.localeCompare(b.name));
@@ -13283,7 +13390,7 @@ async function getAgents(targetDir) {
   }
 }
 async function getSkills(targetDir) {
-  const skillsDir = join5(targetDir, "skills");
+  const skillsDir = join5(targetDir, ".claude", "skills");
   if (!await fileExists(skillsDir))
     return [];
   try {
@@ -13393,11 +13500,71 @@ ${type} (${components.length}):`);
 function formatAsJson(components) {
   console.log(JSON.stringify(components, null, 2));
 }
+async function getHooks(targetDir) {
+  const hooksDir = join5(targetDir, ".claude", "hooks");
+  if (!await fileExists(hooksDir))
+    return [];
+  try {
+    const hookFiles = await listFiles(hooksDir, { recursive: true, pattern: "*.sh" });
+    const hookConfigs = await listFiles(hooksDir, { recursive: true, pattern: "*.json" });
+    const hookYamls = await listFiles(hooksDir, { recursive: true, pattern: "*.yaml" });
+    const allFiles = [...hookFiles, ...hookConfigs, ...hookYamls];
+    return allFiles.map((hookPath) => ({
+      name: basename2(hookPath),
+      type: "hook",
+      path: relative(targetDir, hookPath)
+    })).sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return [];
+  }
+}
+async function getContexts(targetDir) {
+  const contextsDir = join5(targetDir, ".claude", "contexts");
+  if (!await fileExists(contextsDir))
+    return [];
+  try {
+    const mdFiles = await listFiles(contextsDir, { recursive: false, pattern: "*.md" });
+    const yamlFiles = await listFiles(contextsDir, { recursive: false, pattern: "*.yaml" });
+    const allFiles = [...mdFiles, ...yamlFiles];
+    const contexts = await Promise.all(allFiles.map(async (ctxPath) => {
+      const ext = ctxPath.endsWith(".md") ? ".md" : ".yaml";
+      const description = ext === ".md" ? await tryExtractMarkdownDescription(ctxPath, { maxLength: 100 }) : undefined;
+      return {
+        name: basename2(ctxPath, ext),
+        type: "context",
+        path: relative(targetDir, ctxPath),
+        description
+      };
+    }));
+    return contexts.sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return [];
+  }
+}
+async function getPipelines(targetDir) {
+  const pipelinesDir = join5(targetDir, "pipelines");
+  if (!await fileExists(pipelinesDir))
+    return [];
+  try {
+    const pipelineFiles = await listFiles(pipelinesDir, { recursive: true, pattern: "*.yaml" });
+    return pipelineFiles.map((pipePath) => ({
+      name: basename2(pipePath, ".yaml"),
+      type: "pipeline",
+      category: relative(join5(targetDir, "pipelines"), dirname2(pipePath)) || "root",
+      path: relative(targetDir, pipePath)
+    })).sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return [];
+  }
+}
 var COMPONENT_GETTERS = {
   agents: getAgents,
   skills: getSkills,
   guides: getGuides,
-  rules: getRules
+  rules: getRules,
+  hooks: getHooks,
+  contexts: getContexts,
+  pipelines: getPipelines
 };
 function displayComponents(components, type, format) {
   if (format === "json") {
@@ -13409,19 +13576,25 @@ function displayComponents(components, type, format) {
   }
 }
 async function handleListAll(targetDir, format) {
-  const [agents, skills, guides, rules] = await Promise.all([
+  const [agents, skills, guides, rules, hooks, contexts, pipelines] = await Promise.all([
     getAgents(targetDir),
     getSkills(targetDir),
     getGuides(targetDir),
-    getRules(targetDir)
+    getRules(targetDir),
+    getHooks(targetDir),
+    getContexts(targetDir),
+    getPipelines(targetDir)
   ]);
   if (format !== "json") {
     displayComponents(agents, "agents", format);
     displayComponents(skills, "skills", format);
     displayComponents(guides, "guides", format);
     displayComponents(rules, "rules", format);
+    displayComponents(hooks, "hooks", format);
+    displayComponents(contexts, "contexts", format);
+    displayComponents(pipelines, "pipelines", format);
   }
-  return [...agents, ...skills, ...guides, ...rules];
+  return [...agents, ...skills, ...guides, ...rules, ...hooks, ...contexts, ...pipelines];
 }
 async function listCommand(type = "all", options = {}) {
   const targetDir = process.cwd();

package/dist/index.js

@@ -1,20 +1,4 @@
 import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/core/config.ts
@@ -422,37 +406,20 @@ var DIRECTORY_STRUCTURE = [
   ".claude/rules",
   ".claude/hooks",
   ".claude/contexts",
-  "agents",
-  "agents/master",
-  "agents/orchestrator",
-  "agents/manager",
-  "agents/system",
-  "agents/sw-engineer",
-  "agents/sw-architect",
-  "agents/backend-engineer",
-  "agents/infra-engineer",
-  "agents/qa-engineer",
-  "agents/tutor",
-  "skills",
-  "skills/development",
-  "skills/backend",
-  "skills/infrastructure",
-  "skills/system",
-  "skills/orchestration",
+  ".claude/agents",
+  ".claude/skills",
   "guides",
   "pipelines",
   "pipelines/templates",
-  "pipelines/examples",
-  "commands"
+  "pipelines/examples"
 ];
 var COMPONENT_PATHS = {
   "claude-md": "",
   rules: ".claude/rules",
-  agents: "agents",
-  skills: "skills",
+  agents: ".claude/agents",
+  skills: ".claude/skills",
   guides: "guides",
   pipelines: "pipelines",
-  commands: "commands",
   hooks: ".claude/hooks",
   contexts: ".claude/contexts"
 };
@@ -592,7 +559,7 @@ async function getTemplateManifest() {
   };
 }
 function getAllComponents() {
-  return ["rules", "agents", "skills", "guides", "pipelines", "commands", "hooks", "contexts"];
+  return ["rules", "agents", "skills", "guides", "pipelines", "hooks", "contexts"];
 }
 async function installComponent(targetDir, component, options) {
   const templatePath = COMPONENT_PATHS[component];
@@ -642,15 +609,7 @@ async function backupExisting(sourcePath, backupDir) {
   return backupPath;
 }
 async function checkExistingPaths(targetDir) {
-  const pathsToCheck = [
-    "CLAUDE.md",
-    ".claude",
-    "agents",
-    "skills",
-    "guides",
-    "pipelines",
-    "commands"
-  ];
+  const pathsToCheck = ["CLAUDE.md", ".claude", "guides", "pipelines"];
   const existingPaths = [];
   for (const relativePath of pathsToCheck) {
     const fullPath = join3(targetDir, relativePath);
@@ -805,7 +764,7 @@ async function preserveCustomizations(targetDir, customizations) {
   return preserved;
 }
 function getAllUpdateComponents() {
-  return ["rules", "agents", "skills", "guides", "pipelines", "commands", "hooks", "contexts"];
+  return ["rules", "agents", "skills", "guides", "pipelines", "hooks", "contexts"];
 }
 async function getLatestVersion() {
   const manifestPath = resolveTemplatePath("manifest.json");
@@ -850,11 +809,10 @@ async function updateComponent(targetDir, component, customizations, options) {
 function getComponentPath(component) {
   const paths = {
     rules: ".claude/rules",
-    agents: "agents",
-    skills: "skills",
+    agents: ".claude/agents",
+    skills: ".claude/skills",
     guides: "guides",
     pipelines: "pipelines",
-    commands: "commands",
     hooks: ".claude/hooks",
     contexts: ".claude/contexts"
   };
@@ -865,7 +823,7 @@ async function backupInstallation(targetDir) {
   const backupDir = join4(targetDir, `.omcustom-backup-${timestamp}`);
   const fs = await import("node:fs/promises");
   await ensureDirectory(backupDir);
-  const dirsToBackup = [".claude", "agents", "skills", "guides", "pipelines", "commands"];
+  const dirsToBackup = [".claude", "guides", "pipelines"];
   for (const dir of dirsToBackup) {
     const srcPath = join4(targetDir, dir);
     if (await fileExists(srcPath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-customcode",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {