oh-my-customcode 0.10.0 → 0.10.2

package/dist/cli/index.js

@@ -12301,8 +12301,38 @@ var $visitAsync = visit.visitAsync;
 import { join as join2 } from "node:path";
 
 // src/utils/fs.ts
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { dirname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+function validatePreserveFilePath(filePath, projectRoot) {
+  if (!filePath || filePath.trim() === "") {
+    return {
+      valid: false,
+      reason: "Path cannot be empty"
+    };
+  }
+  if (isAbsolute(filePath)) {
+    return {
+      valid: false,
+      reason: "Absolute paths are not allowed"
+    };
+  }
+  const normalizedPath = normalize(filePath);
+  if (normalizedPath.startsWith("..")) {
+    return {
+      valid: false,
+      reason: "Path cannot traverse outside project root"
+    };
+  }
+  const resolvedPath = resolve(projectRoot, normalizedPath);
+  const relativePath = relative(projectRoot, resolvedPath);
+  if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
+    return {
+      valid: false,
+      reason: "Resolved path escapes project root"
+    };
+  }
+  return { valid: true };
+}
 async function fileExists(path) {
   const fs = await import("node:fs/promises");
   try {
@@ -12691,7 +12721,7 @@ async function loadConfig(targetDir) {
   if (await fileExists(configPath)) {
     try {
       const config = await readJsonFile(configPath);
-      const merged = mergeConfig(getDefaultConfig(), config);
+      const merged = mergeConfig(getDefaultConfig(), config, targetDir);
       if (merged.configVersion < CURRENT_CONFIG_VERSION) {
         const migrated = migrateConfig(merged);
         await saveConfig(targetDir, migrated);
@@ -12720,7 +12750,30 @@ function deduplicateCustomComponents(components) {
   }
   return [...seen.values()];
 }
-function mergeConfig(defaults, overrides) {
+function mergeConfig(defaults, overrides, targetDir) {
+  let mergedPreserveFiles;
+  if (overrides.preserveFiles) {
+    const allFiles = [...new Set([...defaults.preserveFiles || [], ...overrides.preserveFiles])];
+    if (targetDir) {
+      const validatedFiles = [];
+      for (const filePath of allFiles) {
+        const validation = validatePreserveFilePath(filePath, targetDir);
+        if (validation.valid) {
+          validatedFiles.push(filePath);
+        } else {
+          warn("config.invalid_preserve_path", {
+            path: filePath,
+            reason: validation.reason ?? "Invalid path"
+          });
+        }
+      }
+      mergedPreserveFiles = validatedFiles;
+    } else {
+      mergedPreserveFiles = allFiles;
+    }
+  } else {
+    mergedPreserveFiles = defaults.preserveFiles;
+  }
   return {
     ...defaults,
     ...overrides,
@@ -12734,7 +12787,7 @@ function mergeConfig(defaults, overrides) {
       ...defaults.agents,
       ...overrides.agents
     },
-    preserveFiles: overrides.preserveFiles ? [...new Set([...defaults.preserveFiles || [], ...overrides.preserveFiles])] : defaults.preserveFiles,
+    preserveFiles: mergedPreserveFiles,
     customComponents: overrides.customComponents ? deduplicateCustomComponents([
       ...defaults.customComponents || [],
       ...overrides.customComponents
@@ -13465,8 +13518,260 @@ async function doctorCommand(options = {}) {
 import { join as join5 } from "node:path";
 
 // src/core/installer.ts
-import { copyFile as fsCopyFile, rename } from "node:fs/promises";
+import { readFile as fsReadFile, writeFile as fsWriteFile, rename } from "node:fs/promises";
 import { basename, join as join4 } from "node:path";
+
+// src/core/git-workflow.ts
+import { execFileSync } from "node:child_process";
+function execGit(args, cwd) {
+  try {
+    return execFileSync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, GIT_DIR: undefined, GIT_WORK_TREE: undefined }
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function isGitRepo(cwd) {
+  return execGit(["rev-parse", "--is-inside-work-tree"], cwd) === "true";
+}
+function detectDefaultBranch(cwd) {
+  const remoteHead = execGit(["symbolic-ref", "refs/remotes/origin/HEAD"], cwd);
+  if (remoteHead) {
+    return remoteHead.replace("refs/remotes/origin/", "");
+  }
+  const branches = getLocalBranches(cwd);
+  for (const candidate of ["main", "master", "develop"]) {
+    if (branches.includes(candidate)) {
+      return candidate;
+    }
+  }
+  const head = execGit(["symbolic-ref", "--short", "HEAD"], cwd);
+  if (head) {
+    return head;
+  }
+  return "main";
+}
+function getLocalBranches(cwd) {
+  const output = execGit(["branch", "--format=%(refname:short)"], cwd);
+  if (!output)
+    return [];
+  return output.split(`
+`).filter(Boolean);
+}
+function getRemoteBranches(cwd) {
+  const output = execGit(["branch", "-r", "--format=%(refname:short)"], cwd);
+  if (!output)
+    return [];
+  return output.split(`
+`).filter(Boolean).map((b) => b.replace(/^origin\//, "")).filter((b) => b !== "HEAD");
+}
+function detectBranchPatterns(branches) {
+  const prefixes = new Set;
+  const knownPrefixes = ["feature", "release", "hotfix", "bugfix", "fix", "chore", "docs"];
+  for (const branch of branches) {
+    const slashIdx = branch.indexOf("/");
+    if (slashIdx > 0) {
+      const prefix = branch.substring(0, slashIdx);
+      if (knownPrefixes.includes(prefix)) {
+        prefixes.add(`${prefix}/*`);
+      }
+    }
+  }
+  return [...prefixes].sort();
+}
+function determineWorkflowType(hasDevelop, branchPatterns, allBranches) {
+  const hasFlowPatterns = branchPatterns.some((p) => p === "feature/*" || p === "release/*" || p === "hotfix/*");
+  if (hasDevelop && hasFlowPatterns) {
+    return "git-flow";
+  }
+  const hasFeatureBranches = allBranches.some((b) => b.includes("/"));
+  if (!hasDevelop && hasFeatureBranches) {
+    return "github-flow";
+  }
+  if (!hasDevelop && !hasFeatureBranches) {
+    return "trunk-based";
+  }
+  if (hasDevelop) {
+    return "git-flow";
+  }
+  return "github-flow";
+}
+function detectGitWorkflow(cwd) {
+  if (!isGitRepo(cwd)) {
+    return null;
+  }
+  const localBranches = getLocalBranches(cwd);
+  const remoteBranches = getRemoteBranches(cwd);
+  const allBranches = [...new Set([...localBranches, ...remoteBranches])];
+  const defaultBranch = detectDefaultBranch(cwd);
+  const hasDevelop = localBranches.includes("develop") || remoteBranches.includes("develop");
+  const branchPatterns = detectBranchPatterns(allBranches);
+  const type = determineWorkflowType(hasDevelop, branchPatterns, allBranches);
+  return {
+    type,
+    defaultBranch,
+    hasDevelop,
+    branchPatterns
+  };
+}
+function renderGitWorkflowEN(result) {
+  switch (result.type) {
+    case "git-flow":
+      return renderGitFlowEN(result);
+    case "github-flow":
+      return renderGithubFlowEN(result);
+    case "trunk-based":
+      return renderTrunkBasedEN(result);
+  }
+}
+function renderGitWorkflowKO(result) {
+  switch (result.type) {
+    case "git-flow":
+      return renderGitFlowKO(result);
+    case "github-flow":
+      return renderGithubFlowKO(result);
+    case "trunk-based":
+      return renderTrunkBasedKO(result);
+  }
+}
+function renderGitFlowEN(r) {
+  const lines = [
+    "## Git Workflow (MUST follow)",
+    "",
+    "| Branch | Purpose |",
+    "|--------|---------|",
+    `| \`${r.defaultBranch}\` | Main development branch (default) |`
+  ];
+  if (r.branchPatterns.includes("feature/*")) {
+    lines.push(`| \`feature/*\` | New features -> PR to ${r.defaultBranch} |`);
+  }
+  if (r.branchPatterns.includes("release/*")) {
+    lines.push("| `release/*` | Release preparation -> **npm publish here only** |");
+  }
+  if (r.branchPatterns.includes("hotfix/*")) {
+    lines.push(`| \`hotfix/*\` | Critical fixes -> tag -> publish -> merge to ${r.defaultBranch} |`);
+  }
+  if (r.branchPatterns.includes("bugfix/*")) {
+    lines.push(`| \`bugfix/*\` | Bug fixes -> PR to ${r.defaultBranch} |`);
+  }
+  lines.push("");
+  lines.push("**Key rules:**");
+  lines.push(`- Create feature branches from \`${r.defaultBranch}\``);
+  lines.push("- Use conventional commits: `feat:`, `fix:`, `docs:`, `chore:`");
+  lines.push('- Include "Closes #N" in commit message to auto-close issues');
+  return lines.join(`
+`);
+}
+function renderGithubFlowEN(r) {
+  const lines = [
+    "## Git Workflow (MUST follow)",
+    "",
+    "| Branch | Purpose |",
+    "|--------|---------|",
+    `| \`${r.defaultBranch}\` | Production-ready code (default) |`,
+    `| \`feature/*\` | New features -> PR to ${r.defaultBranch} |`,
+    "",
+    "**Key rules:**",
+    `- Create feature branches from \`${r.defaultBranch}\``,
+    `- All changes go through PR to \`${r.defaultBranch}\``,
+    "- Use conventional commits: `feat:`, `fix:`, `docs:`, `chore:`",
+    '- Include "Closes #N" in commit message to auto-close issues'
+  ];
+  return lines.join(`
+`);
+}
+function renderTrunkBasedEN(r) {
+  const lines = [
+    "## Git Workflow (MUST follow)",
+    "",
+    "| Branch | Purpose |",
+    "|--------|---------|",
+    `| \`${r.defaultBranch}\` | Main trunk (default) |`,
+    "",
+    "**Key rules:**",
+    `- Commit directly to \`${r.defaultBranch}\` or use short-lived branches`,
+    "- Keep branches short-lived (merge within 1-2 days)",
+    "- Use conventional commits: `feat:`, `fix:`, `docs:`, `chore:`"
+  ];
+  return lines.join(`
+`);
+}
+function renderGitFlowKO(r) {
+  const lines = [
+    "## Git 워크플로우 (반드시 준수)",
+    "",
+    "| 브랜치 | 용도 |",
+    "|--------|------|",
+    `| \`${r.defaultBranch}\` | 메인 개발 브랜치 (기본) |`
+  ];
+  if (r.branchPatterns.includes("feature/*")) {
+    lines.push(`| \`feature/*\` | 새 기능 -> ${r.defaultBranch}으로 PR |`);
+  }
+  if (r.branchPatterns.includes("release/*")) {
+    lines.push("| `release/*` | 릴리스 준비 -> **npm 배포는 여기서만** |");
+  }
+  if (r.branchPatterns.includes("hotfix/*")) {
+    lines.push(`| \`hotfix/*\` | 긴급 수정 -> 태그 -> 배포 -> ${r.defaultBranch} 머지 |`);
+  }
+  if (r.branchPatterns.includes("bugfix/*")) {
+    lines.push(`| \`bugfix/*\` | 버그 수정 -> ${r.defaultBranch}으로 PR |`);
+  }
+  lines.push("");
+  lines.push("**핵심 규칙:**");
+  lines.push(`- \`${r.defaultBranch}\`에서 feature 브랜치 생성`);
+  lines.push("- Conventional commits 사용: `feat:`, `fix:`, `docs:`, `chore:`");
+  lines.push('- 커밋 메시지에 "Closes #N" 포함시 이슈 자동 종료');
+  return lines.join(`
+`);
+}
+function renderGithubFlowKO(r) {
+  const lines = [
+    "## Git 워크플로우 (반드시 준수)",
+    "",
+    "| 브랜치 | 용도 |",
+    "|--------|------|",
+    `| \`${r.defaultBranch}\` | 프로덕션 준비 코드 (기본) |`,
+    `| \`feature/*\` | 새 기능 -> ${r.defaultBranch}으로 PR |`,
+    "",
+    "**핵심 규칙:**",
+    `- \`${r.defaultBranch}\`에서 feature 브랜치 생성`,
+    `- 모든 변경은 \`${r.defaultBranch}\`으로 PR을 통해 진행`,
+    "- Conventional commits 사용: `feat:`, `fix:`, `docs:`, `chore:`",
+    '- 커밋 메시지에 "Closes #N" 포함시 이슈 자동 종료'
+  ];
+  return lines.join(`
+`);
+}
+function renderTrunkBasedKO(r) {
+  const lines = [
+    "## Git 워크플로우 (반드시 준수)",
+    "",
+    "| 브랜치 | 용도 |",
+    "|--------|------|",
+    `| \`${r.defaultBranch}\` | 메인 트렁크 (기본) |`,
+    "",
+    "**핵심 규칙:**",
+    `- \`${r.defaultBranch}\`에 직접 커밋하거나 단기 브랜치 사용`,
+    "- 브랜치는 단기 유지 (1-2일 내 머지)",
+    "- Conventional commits 사용: `feat:`, `fix:`, `docs:`, `chore:`"
+  ];
+  return lines.join(`
+`);
+}
+function getDefaultWorkflow() {
+  return {
+    type: "github-flow",
+    defaultBranch: "main",
+    hasDevelop: false,
+    branchPatterns: ["feature/*"]
+  };
+}
+
+// src/core/installer.ts
 var DEFAULT_LANGUAGE2 = "en";
 function getTemplateDir() {
   const packageRoot = getPackageRoot();
@@ -13601,6 +13906,11 @@ async function installComponent(targetDir, provider, component, options) {
   debug("install.component_installed", { component });
   return true;
 }
+var GIT_WORKFLOW_PLACEHOLDER = "<!-- omcustom:git-workflow -->";
+function renderGitWorkflowSection(targetDir, language) {
+  const result = detectGitWorkflow(targetDir) ?? getDefaultWorkflow();
+  return language === "ko" ? renderGitWorkflowKO(result) : renderGitWorkflowEN(result);
+}
 async function installEntryDoc(targetDir, provider, language, overwrite = false) {
   const layout = getProviderLayout(provider);
   const templateFile = getEntryTemplateName(provider, language);
@@ -13615,7 +13925,12 @@ async function installEntryDoc(targetDir, provider, language, overwrite = false)
     debug("install.entry_md_skipped", { reason: "exists", language, entry: layout.entryFile });
     return false;
   }
-  await fsCopyFile(srcPath, destPath);
+  let content = await fsReadFile(srcPath, "utf-8");
+  if (content.includes(GIT_WORKFLOW_PLACEHOLDER)) {
+    const workflowSection = renderGitWorkflowSection(targetDir, language);
+    content = content.replace(GIT_WORKFLOW_PLACEHOLDER, workflowSection);
+  }
+  await fsWriteFile(destPath, content, "utf-8");
   debug("install.entry_md_installed", { language, entry: layout.entryFile });
   return true;
 }
@@ -14362,27 +14677,63 @@ function resolveConfigPreserveFiles(options, config) {
   if (options.forceOverwriteAll) {
     return [];
   }
-  return config.preserveFiles || [];
+  const preserveFiles = config.preserveFiles || [];
+  const validatedPaths = [];
+  for (const filePath of preserveFiles) {
+    const validation = validatePreserveFilePath(filePath, options.targetDir);
+    if (validation.valid) {
+      validatedPaths.push(filePath);
+    } else {
+      warn("preserve_files.invalid_path", {
+        path: filePath,
+        reason: validation.reason ?? "Invalid path"
+      });
+    }
+  }
+  return validatedPaths;
 }
-function resolveCustomizations(customizations, configPreserveFiles) {
-  if (!customizations && configPreserveFiles.length === 0) {
-    return null;
+function resolveCustomizations(customizations, configPreserveFiles, targetDir) {
+  const validatedManifestFiles = [];
+  if (customizations && customizations.preserveFiles.length > 0) {
+    for (const filePath of customizations.preserveFiles) {
+      const validation = validatePreserveFilePath(filePath, targetDir);
+      if (validation.valid) {
+        validatedManifestFiles.push(filePath);
+      } else {
+        warn("preserve_files.invalid_path", {
+          path: filePath,
+          reason: validation.reason ?? "Invalid path",
+          source: "manifest"
+        });
+      }
+    }
   }
-  if (customizations && configPreserveFiles.length > 0) {
-    customizations.preserveFiles = [
-      ...new Set([...customizations.preserveFiles, ...configPreserveFiles])
-    ];
-    return customizations;
+  if (validatedManifestFiles.length === 0 && configPreserveFiles.length === 0) {
+    return customizations && customizations.modifiedFiles.length > 0 ? customizations : null;
+  }
+  if (validatedManifestFiles.length > 0 && configPreserveFiles.length > 0) {
+    const merged = customizations || {
+      modifiedFiles: [],
+      preserveFiles: [],
+      customComponents: [],
+      lastUpdated: new Date().toISOString()
+    };
+    merged.preserveFiles = [...new Set([...validatedManifestFiles, ...configPreserveFiles])];
+    return merged;
   }
   if (configPreserveFiles.length > 0) {
     return {
-      modifiedFiles: [],
+      modifiedFiles: customizations?.modifiedFiles || [],
       preserveFiles: configPreserveFiles,
-      customComponents: [],
+      customComponents: customizations?.customComponents || [],
       lastUpdated: new Date().toISOString()
     };
   }
-  return customizations;
+  if (customizations) {
+    customizations.preserveFiles = validatedManifestFiles;
+    return customizations;
+  }
+  return null;
 }
 async function updateEntryDoc(targetDir, provider, config, options) {
   const layout = getProviderLayout(provider);
@@ -14437,7 +14788,7 @@ async function update(options) {
     await handleBackupIfRequested(options.targetDir, provider, !!options.backup, result);
     const manifestCustomizations = await resolveManifestCustomizations(options, options.targetDir);
     const configPreserveFiles = resolveConfigPreserveFiles(options, config);
-    const customizations = resolveCustomizations(manifestCustomizations, configPreserveFiles);
+    const customizations = resolveCustomizations(manifestCustomizations, configPreserveFiles, options.targetDir);
     const components = options.components || getAllUpdateComponents();
     await updateAllComponents(options.targetDir, provider, components, updateCheck, customizations, options, result, config);
     if (!options.components || options.components.length === 0) {