oh-my-customcode 0.9.3 → 0.10.0

package/dist/index.js

@@ -5,7 +5,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 import { join as join2 } from "node:path";
 
 // src/utils/fs.ts
-import { dirname, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 async function fileExists(path) {
   const fs = await import("node:fs/promises");
@@ -70,6 +70,25 @@ async function handleFile(srcPath, destPath, options, fs) {
     await fs.utimes(destPath, stats.atime, stats.mtime);
   }
 }
+function shouldSkipPath(destPath, destRoot, skipPaths) {
+  if (!skipPaths || skipPaths.length === 0) {
+    return false;
+  }
+  const relativePath = relative(destRoot, destPath);
+  for (const skipPath of skipPaths) {
+    if (skipPath.endsWith("/")) {
+      const dirPath = skipPath.slice(0, -1);
+      if (relativePath === dirPath || relativePath.startsWith(dirPath + sep)) {
+        return true;
+      }
+    } else {
+      if (relativePath === skipPath) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 async function copyDirectory(src, dest, options = {}) {
   const fs = await import("node:fs/promises");
   const path = await import("node:path");
@@ -81,6 +100,9 @@ async function copyDirectory(src, dest, options = {}) {
     }
     const srcPath = path.join(src, entry.name);
     const destPath = path.join(dest, entry.name);
+    if (shouldSkipPath(destPath, dest, options.skipPaths)) {
+      continue;
+    }
     if (entry.isSymbolicLink()) {
       await handleSymlink(srcPath, destPath, options, fs);
     } else if (entry.isDirectory()) {
@@ -100,6 +122,15 @@ async function writeJsonFile(path, data) {
   const content = JSON.stringify(data, null, 2);
   await fs.writeFile(path, content, "utf-8");
 }
+async function readTextFile(path) {
+  const fs = await import("node:fs/promises");
+  return fs.readFile(path, "utf-8");
+}
+async function writeTextFile(path, content) {
+  const fs = await import("node:fs/promises");
+  await ensureDirectory(dirname(path));
+  await fs.writeFile(path, content, "utf-8");
+}
 function getPackageRoot() {
   const currentFile = fileURLToPath(import.meta.url);
   const currentDir = dirname(currentFile);
@@ -333,7 +364,9 @@ function getDefaultConfig() {
       enabled: false,
       checkIntervalHours: 24,
       autoApplyMinor: false
-    }
+    },
+    preserveFiles: [],
+    customComponents: []
   };
 }
 function getDefaultPreferences() {
@@ -375,6 +408,13 @@ async function saveConfig(targetDir, config) {
   await writeJsonFile(configPath, config);
   debug("config.saved", { path: configPath });
 }
+function deduplicateCustomComponents(components) {
+  const seen = new Map;
+  for (const c of components) {
+    seen.set(c.path, c);
+  }
+  return [...seen.values()];
+}
 function mergeConfig(defaults, overrides) {
   return {
     ...defaults,
@@ -388,7 +428,12 @@ function mergeConfig(defaults, overrides) {
     agents: {
       ...defaults.agents,
       ...overrides.agents
-    }
+    },
+    preserveFiles: overrides.preserveFiles ? [...new Set([...defaults.preserveFiles || [], ...overrides.preserveFiles])] : defaults.preserveFiles,
+    customComponents: overrides.customComponents ? deduplicateCustomComponents([
+      ...defaults.customComponents || [],
+      ...overrides.customComponents
+    ]) : defaults.customComponents
   };
 }
 function migrateConfig(config) {
@@ -839,6 +884,124 @@ async function detectProvider(options = {}) {
 }
 // src/core/updater.ts
 import { join as join5 } from "node:path";
+
+// src/core/entry-merger.ts
+var MANAGED_START = "<!-- omcustom:start -->";
+var MANAGED_END = "<!-- omcustom:end -->";
+function isCodeBlockDelimiter(line) {
+  const trimmed = line.trim();
+  return trimmed.startsWith("```") || trimmed.startsWith("~~~");
+}
+function handleManagedStart(currentLines, sections) {
+  if (currentLines.length > 0) {
+    sections.push({
+      type: "custom",
+      content: currentLines.join(`
+`)
+    });
+  }
+  return {
+    currentSection: { type: "managed", content: "" },
+    currentLines: []
+  };
+}
+function handleManagedEnd(currentSection, currentLines, sections) {
+  if (currentSection && currentSection.type === "managed") {
+    currentSection.content = currentLines.join(`
+`);
+    sections.push(currentSection);
+    return {
+      currentSection: null,
+      currentLines: []
+    };
+  }
+  return { currentSection, currentLines };
+}
+function parseEntryDoc(content) {
+  const sections = [];
+  const lines = content.split(`
+`);
+  let currentSection = null;
+  let currentLines = [];
+  let insideCodeBlock = false;
+  for (const line of lines) {
+    if (isCodeBlockDelimiter(line)) {
+      insideCodeBlock = !insideCodeBlock;
+    }
+    if (!insideCodeBlock) {
+      const trimmed = line.trim();
+      if (trimmed === MANAGED_START) {
+        const result = handleManagedStart(currentLines, sections);
+        currentSection = result.currentSection;
+        currentLines = result.currentLines;
+        continue;
+      }
+      if (trimmed === MANAGED_END) {
+        const result = handleManagedEnd(currentSection, currentLines, sections);
+        currentSection = result.currentSection;
+        currentLines = result.currentLines;
+        continue;
+      }
+    }
+    currentLines.push(line);
+  }
+  if (currentLines.length > 0) {
+    sections.push({
+      type: "custom",
+      content: currentLines.join(`
+`)
+    });
+  }
+  return { sections };
+}
+function mergeEntryDoc(existingContent, templateContent) {
+  const warnings = [];
+  const { sections } = parseEntryDoc(existingContent);
+  const hasManagedSections = sections.some((s) => s.type === "managed");
+  if (!hasManagedSections) {
+    const wrapped = wrapInManagedMarkers(templateContent);
+    return {
+      content: wrapped,
+      managedSections: 1,
+      customSections: 0,
+      warnings: ["No managed sections found in existing content, wrapping template entirely"]
+    };
+  }
+  const mergedSections = [];
+  let managedCount = 0;
+  let customCount = 0;
+  let templateInserted = false;
+  for (const section of sections) {
+    if (section.type === "managed") {
+      if (!templateInserted) {
+        mergedSections.push(MANAGED_START);
+        mergedSections.push(templateContent);
+        mergedSections.push(MANAGED_END);
+        templateInserted = true;
+        managedCount++;
+      } else {
+        warnings.push("Multiple managed sections found, keeping only the first one");
+      }
+    } else {
+      mergedSections.push(section.content);
+      customCount++;
+    }
+  }
+  return {
+    content: mergedSections.join(`
+`),
+    managedSections: managedCount,
+    customSections: customCount,
+    warnings
+  };
+}
+function wrapInManagedMarkers(content) {
+  return `${MANAGED_START}
+${content}
+${MANAGED_END}`;
+}
+
+// src/core/updater.ts
 var CUSTOMIZATION_MANIFEST_FILE = ".omcustom-customizations.json";
 function createUpdateResult() {
   return {
@@ -859,7 +1022,7 @@ async function handleBackupIfRequested(targetDir, provider, backup, result) {
   result.backedUpPaths.push(backupPath);
   info("update.backup_created", { path: backupPath });
 }
-async function processComponentUpdate(targetDir, provider, component, updateCheck, customizations, options, result) {
+async function processComponentUpdate(targetDir, provider, component, updateCheck, customizations, options, result, config) {
   const componentUpdate = updateCheck.updatableComponents.find((c) => c.name === component);
   if (!componentUpdate && !options.force) {
     result.skippedComponents.push(component);
@@ -871,7 +1034,7 @@ async function processComponentUpdate(targetDir, provider, component, updateChec
     return;
   }
   try {
-    const preserved = await updateComponent(targetDir, provider, component, customizations, options);
+    const preserved = await updateComponent(targetDir, provider, component, customizations, options, config);
     result.updatedComponents.push(component);
     result.preservedFiles.push(...preserved);
   } catch (err) {
@@ -880,9 +1043,93 @@ async function processComponentUpdate(targetDir, provider, component, updateChec
     result.skippedComponents.push(component);
   }
 }
-async function updateAllComponents(targetDir, provider, components, updateCheck, customizations, options, result) {
+async function updateAllComponents(targetDir, provider, components, updateCheck, customizations, options, result, config) {
   for (const component of components) {
-    await processComponentUpdate(targetDir, provider, component, updateCheck, customizations, options, result);
+    await processComponentUpdate(targetDir, provider, component, updateCheck, customizations, options, result, config);
+  }
+}
+function getEntryTemplateName2(provider, language) {
+  const layout = getProviderLayout(provider);
+  const baseName = layout.entryFile.replace(".md", "");
+  return language === "ko" ? `${baseName}.md.ko` : `${baseName}.md.en`;
+}
+async function backupFile(filePath) {
+  const fs = await import("node:fs/promises");
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${filePath}.backup-${timestamp}`;
+  if (await fileExists(filePath)) {
+    await fs.copyFile(filePath, backupPath);
+    debug("update.file_backed_up", { path: filePath, backup: backupPath });
+  }
+}
+async function resolveManifestCustomizations(options, targetDir) {
+  if (options.forceOverwriteAll) {
+    return null;
+  }
+  if (options.preserveCustomizations === false) {
+    return null;
+  }
+  return loadCustomizationManifest(targetDir);
+}
+function resolveConfigPreserveFiles(options, config) {
+  if (options.forceOverwriteAll) {
+    return [];
+  }
+  return config.preserveFiles || [];
+}
+function resolveCustomizations(customizations, configPreserveFiles) {
+  if (!customizations && configPreserveFiles.length === 0) {
+    return null;
+  }
+  if (customizations && configPreserveFiles.length > 0) {
+    customizations.preserveFiles = [
+      ...new Set([...customizations.preserveFiles, ...configPreserveFiles])
+    ];
+    return customizations;
+  }
+  if (configPreserveFiles.length > 0) {
+    return {
+      modifiedFiles: [],
+      preserveFiles: configPreserveFiles,
+      customComponents: [],
+      lastUpdated: new Date().toISOString()
+    };
+  }
+  return customizations;
+}
+async function updateEntryDoc(targetDir, provider, config, options) {
+  const layout = getProviderLayout(provider);
+  const entryPath = join5(targetDir, layout.entryFile);
+  const templateName = getEntryTemplateName2(provider, config.language);
+  const templatePath = resolveTemplatePath(templateName);
+  if (!await fileExists(templatePath)) {
+    warn("update.entry_template_not_found", { template: templateName });
+    return;
+  }
+  const templateContent = await readTextFile(templatePath);
+  if (await fileExists(entryPath)) {
+    if (options.force) {
+      await backupFile(entryPath);
+      await writeTextFile(entryPath, templateContent);
+      info("update.entry_doc_force_updated", { path: layout.entryFile });
+    } else {
+      const existingContent = await readTextFile(entryPath);
+      const mergeResult = mergeEntryDoc(existingContent, templateContent);
+      await writeTextFile(entryPath, mergeResult.content);
+      debug("update.entry_doc_merged", {
+        path: layout.entryFile,
+        managed: String(mergeResult.managedSections),
+        custom: String(mergeResult.customSections)
+      });
+      if (mergeResult.warnings.length > 0) {
+        for (const warning of mergeResult.warnings) {
+          warn("update.entry_merge_warning", { warning });
+        }
+      }
+    }
+  } else {
+    await writeTextFile(entryPath, wrapInManagedMarkers(templateContent));
+    info("update.entry_doc_created", { path: layout.entryFile });
   }
 }
 async function update(options) {
@@ -901,9 +1148,14 @@ async function update(options) {
       return result;
     }
     await handleBackupIfRequested(options.targetDir, provider, !!options.backup, result);
-    const customizations = options.preserveCustomizations !== false ? await loadCustomizationManifest(options.targetDir) : null;
+    const manifestCustomizations = await resolveManifestCustomizations(options, options.targetDir);
+    const configPreserveFiles = resolveConfigPreserveFiles(options, config);
+    const customizations = resolveCustomizations(manifestCustomizations, configPreserveFiles);
     const components = options.components || getAllUpdateComponents();
-    await updateAllComponents(options.targetDir, provider, components, updateCheck, customizations, options, result);
+    await updateAllComponents(options.targetDir, provider, components, updateCheck, customizations, options, result, config);
+    if (!options.components || options.components.length === 0) {
+      await updateEntryDoc(options.targetDir, provider, config, options);
+    }
     config.version = result.newVersion;
     config.lastUpdated = new Date().toISOString();
     await saveConfig(options.targetDir, config);
@@ -980,28 +1232,33 @@ async function componentHasUpdate(_targetDir, provider, component, config) {
   const latestVersion = await getLatestVersion(provider);
   return installedVersion !== latestVersion;
 }
-async function updateComponent(targetDir, provider, component, customizations, options) {
+async function updateComponent(targetDir, provider, component, customizations, options, config) {
   const preservedFiles = [];
   const componentPath = getComponentPath2(provider, component);
   const srcPath = resolveTemplatePath(componentPath);
   const destPath = join5(targetDir, componentPath);
-  if (customizations && options.preserveCustomizations !== false) {
+  const customComponents = config.customComponents || [];
+  const skipPaths = [];
+  if (customizations && !options.forceOverwriteAll) {
     const toPreserve = customizations.preserveFiles.filter((f) => f.startsWith(componentPath));
-    if (toPreserve.length > 0) {
-      const preserved = await preserveCustomizations(targetDir, toPreserve);
-      preservedFiles.push(...preserved.keys());
-      await copyDirectory(srcPath, destPath, { overwrite: true });
-      const fs = await import("node:fs/promises");
-      for (const [path, content] of preserved) {
-        await fs.writeFile(join5(targetDir, path), content, "utf-8");
-      }
-    } else {
-      await copyDirectory(srcPath, destPath, { overwrite: true });
+    preservedFiles.push(...toPreserve);
+    skipPaths.push(...toPreserve);
+  }
+  for (const cc of customComponents) {
+    if (cc.path.startsWith(componentPath)) {
+      skipPaths.push(cc.path);
     }
-  } else {
-    await copyDirectory(srcPath, destPath, { overwrite: true });
   }
-  debug("update.component_updated", { component });
+  const path = await import("node:path");
+  const normalizedSkipPaths = skipPaths.map((p) => path.relative(destPath, join5(targetDir, p)));
+  await copyDirectory(srcPath, destPath, {
+    overwrite: true,
+    skipPaths: normalizedSkipPaths.length > 0 ? normalizedSkipPaths : undefined
+  });
+  debug("update.component_updated", {
+    component,
+    skippedPaths: String(normalizedSkipPaths.length)
+  });
   return preservedFiles;
 }
 function getComponentPath2(provider, component) {

package/package.json

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

package/templates/.claude/agents/arch-documenter.md

@@ -14,84 +14,20 @@ tools:
   - Bash
 ---
 
-You handle software architecture documentation, including system design documents, API specifications, architecture decision records (ADRs), and technical documentation maintenance.
+You handle software architecture documentation: system design docs, API specs, ADRs, and technical doc maintenance.
 
 ## Capabilities
 
-1. Generate architecture documentation
-2. Create and maintain API specifications
-3. Write Architecture Decision Records (ADRs)
-4. Document system design and structure
-5. Create technical diagrams (Mermaid, PlantUML)
-6. Maintain README and developer guides
-7. Ensure documentation consistency
+- Architecture documentation with diagrams (Mermaid, PlantUML)
+- API specifications (OpenAPI/Swagger)
+- Architecture Decision Records (ADRs)
+- README and developer guide maintenance
 
-## Documentation Types
+## Document Types
 
 | Type | Format | Purpose |
 |------|--------|---------|
 | Architecture | Markdown + Diagrams | System overview |
 | API Spec | OpenAPI/Swagger | API documentation |
 | ADR | Markdown | Decision records |
-| README | Markdown | Project overview |
-| Guides | Markdown | Developer guides |
-
-## Workflow
-
-### Architecture Documentation
-1. Analyze codebase structure
-2. Identify key components
-3. Map dependencies and flows
-4. Generate diagrams
-5. Write documentation
-6. Review for accuracy
-
-### API Documentation
-1. Scan API endpoints
-2. Extract request/response schemas
-3. Generate OpenAPI spec
-4. Add descriptions and examples
-5. Validate specification
-
-### ADR Creation
-1. Understand decision context
-2. Document options considered
-3. Record decision rationale
-4. Note consequences
-5. Link related ADRs
-
-## Output Formats
-
-### Architecture Doc
-```markdown
-# System Architecture
-
-## Overview
-[High-level description]
-
-## Components
-[Component breakdown with diagrams]
-
-## Data Flow
-[Sequence/flow diagrams]
-
-## Dependencies
-[External dependencies]
-```
-
-### ADR Format
-```markdown
-# ADR-{number}: {title}
-
-## Status
-[Proposed | Accepted | Deprecated | Superseded]
-
-## Context
-[What is the issue?]
-
-## Decision
-[What was decided?]
-
-## Consequences
-[What are the results?]
-```
+| README/Guides | Markdown | Project/developer docs |

package/templates/.claude/agents/arch-speckit-agent.md

@@ -14,121 +14,34 @@ tools:
   - Bash
 ---
 
-You are a Spec-Driven Development agent that transforms high-level requirements into executable specifications. You manage the full specification lifecycle from constitution to implementation.
+You are a Spec-Driven Development agent that transforms requirements into executable specifications.
 
 ## Source
 
 External agent from https://github.com/github/spec-kit
-
-**Version**: latest
-**Last Updated**: 2026-01-22
-**Update Command**: `uv tool upgrade specify-cli --from git+https://github.com/github/spec-kit.git`
-
-## Prerequisites
-
-- Python 3.11+
-- uv package manager
-- Git
-- Claude Code or compatible AI agent
-
-## Capabilities
-
-### Specification Workflow
-- Define project constitution (principles, standards)
-- Create feature specifications (user stories, requirements)
-- Clarify ambiguous requirements through Q&A
-- Generate technical plans (architecture, data models)
-- Produce implementation task lists
-
-### Multi-Phase Development
-- **0-to-1 (Greenfield)**: Build from scratch
-- **Creative Exploration**: Parallel tech stack trials
-- **Iterative Improvement (Brownfield)**: Enhance existing systems
-
-### Quality Assurance
-- Analyze consistency across spec artifacts
-- Generate quality checklists
-- Validate spec coverage
+- **Version**: latest
+- **Update**: `uv tool upgrade specify-cli --from git+https://github.com/github/spec-kit.git`
+- **Prerequisites**: Python 3.11+, uv, Git
 
 ## Commands
 
-| Command | Purpose | Output |
-|---------|---------|--------|
-| `/speckit.constitution` | Define project principles | constitution.md |
-| `/speckit.specify` | Define WHAT to build (no tech stack) | spec.md |
-| `/speckit.clarify` | Clarify ambiguous requirements | Q&A session |
-| `/speckit.plan` | Define HOW to build (tech stack) | plan.md, data-model.md |
-| `/speckit.tasks` | Generate implementation tasks | tasks.md |
-| `/speckit.implement` | Execute all tasks | Code + Tests |
-| `/speckit.analyze` | Check spec consistency | Analysis report |
-| `/speckit.checklist` | Generate QA checklist | Checklist |
-
-## File Structure
-
-```
-.specify/
-├── memory/
-│   └── constitution.md          # Project principles
-├── scripts/                     # Helper scripts
-├── specs/
-│   └── NNN-feature-name/
-│       ├── spec.md              # Feature specification
-│       ├── plan.md              # Technical plan
-│       ├── tasks.md             # Task breakdown
-│       ├── data-model.md        # Data structures
-│       ├── research.md          # Technical research
-│       └── contracts/           # API specs
-└── templates/                   # Spec templates
-```
+| Command | Purpose |
+|---------|---------|
+| `/speckit.constitution` | Define project principles |
+| `/speckit.specify` | Define WHAT to build |
+| `/speckit.clarify` | Clarify requirements (Q&A) |
+| `/speckit.plan` | Define HOW to build |
+| `/speckit.tasks` | Generate implementation tasks |
+| `/speckit.implement` | Execute all tasks |
+| `/speckit.analyze` | Check spec consistency |
+| `/speckit.checklist` | Generate QA checklist |
 
 ## Workflow
 
-1. **Initialize project**
-   ```bash
-   $ specify init <project> --ai claude
-   ```
-
-2. **Define constitution**
-   ```
-   /speckit.constitution
-   → .specify/memory/constitution.md
-   ```
-
-3. **Create specification**
-   ```
-   /speckit.specify <feature-description>
-   → .specify/specs/NNN-feature/spec.md
-   ```
-
-4. **Clarify requirements**
-   ```
-   /speckit.clarify
-   → Interactive Q&A
-   ```
-
-5. **Plan implementation**
-   ```
-   /speckit.plan <tech-stack-preferences>
-   → plan.md, data-model.md, research.md
-   ```
-
-6. **Generate tasks**
-   ```
-   /speckit.tasks
-   → tasks.md (TDD structure)
-   ```
-
-7. **Implement**
-   ```
-   /speckit.implement
-   → Execute tasks in order
-   ```
-
-## Integration
-
-Works with:
-- Claude Code (primary)
-- GitHub Copilot
-- Cursor
-- Windsurf
-- Other AI coding assistants
+1. `specify init <project> --ai claude`
+2. `/speckit.constitution` -> principles
+3. `/speckit.specify` -> feature spec
+4. `/speckit.clarify` -> Q&A
+5. `/speckit.plan` -> technical plan
+6. `/speckit.tasks` -> TDD task list
+7. `/speckit.implement` -> execute