@negikirin/repo-pattern 0.1.1

package/scripts/lib/mcp.mjs

@@ -0,0 +1,203 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { appendGitignoreLine, ensureDir, exists, isTracked, readJson, writeJson } from "./fs-utils.mjs";
+import { askPassword, askText, isInteractive, printSummary, style } from "./prompt.mjs";
+
+const PLACEHOLDER_RE = /^\$\{([A-Z0-9_]+)(?::-(.*))?\}$/;
+const SECRET_RE = /(API_KEY|TOKEN|SECRET|PASSWORD)$/;
+const PATH_RE = /(PROJECT_DIR|_DIR|_PATH)$/;
+const SECRET_HELP_URLS = {
+  CONTEXT7_API_KEY: "https://context7.com/dashboard",
+  TAVILY_API_KEY: "https://app.tavily.com/home"
+};
+
+export async function listAvailableMcpServers(sourceRoot) {
+  const serverDir = path.join(sourceRoot, "mcp", "servers");
+  const entries = await fs.readdir(serverDir);
+  return entries.filter((name) => name.endsWith(".json")).map((name) => path.basename(name, ".json")).sort();
+}
+
+function parsePlaceholder(value) {
+  if (typeof value !== "string") return null;
+  const match = value.match(PLACEHOLDER_RE);
+  if (!match) return null;
+  return { name: match[1], defaultValue: match[2] || "" };
+}
+
+export function validateRelativeMcpPath(value) {
+  const input = String(value || "").trim();
+  if (!input) return "Required";
+  if (input.startsWith("~") || path.isAbsolute(input) || /^[A-Za-z]:[\\/]/.test(input)) return "Use a relative path, not an absolute machine path.";
+  if (input.split(/[\\/]+/).includes("..")) return "Path must not contain '..'.";
+  return true;
+}
+
+export function mcpSecretPrompt(input) {
+  const helpUrl = SECRET_HELP_URLS[input.name];
+  return helpUrl ? `MCP secret — ${input.label} (get key: ${helpUrl})` : `MCP secret — ${input.label}`;
+}
+
+function findMcpInputs(mcpServers) {
+  const inputs = [];
+  const seen = new Set();
+
+  function add(input) {
+    if (seen.has(input.name)) return;
+    seen.add(input.name);
+    inputs.push(input);
+  }
+
+  for (const [serverName, server] of Object.entries(mcpServers)) {
+    for (const [envName, envValue] of Object.entries(server.env || {})) {
+      const placeholder = parsePlaceholder(envValue);
+      if (!placeholder) continue;
+      add({
+        ...placeholder,
+        kind: SECRET_RE.test(placeholder.name) ? "secret" : "text",
+        label: `${serverName}: ${envName}`
+      });
+    }
+
+    for (const arg of server.args || []) {
+      const placeholder = parsePlaceholder(arg);
+      if (!placeholder) continue;
+      add({
+        ...placeholder,
+        kind: PATH_RE.test(placeholder.name) ? "path" : "text",
+        label: `${serverName}: ${placeholder.name}`
+      });
+    }
+  }
+
+  return inputs;
+}
+
+function missingRequiredInputs(inputs, values) {
+  return inputs.filter((input) => !input.defaultValue && !values[input.name]);
+}
+
+function replacePlaceholders(value, values) {
+  if (Array.isArray(value)) return value.map((item) => replacePlaceholders(item, values));
+  if (!value || typeof value !== "object") {
+    const placeholder = parsePlaceholder(value);
+    return placeholder && values[placeholder.name] ? values[placeholder.name] : value;
+  }
+
+  return Object.fromEntries(
+    Object.entries(value).map(([key, nested]) => [key, replacePlaceholders(nested, values)])
+  );
+}
+
+export function applyMcpValues(mcpServers, values = {}) {
+  return replacePlaceholders(mcpServers, values);
+}
+
+export async function readMcpConfig({ sourceRoot, profile = "web", mcpServers: selectedServers = null }) {
+  const profileDir = path.join(sourceRoot, "mcp", "profiles");
+  const profileData = selectedServers ? null : await readJson(path.join(profileDir, `${profile}.json`));
+  const profileServers = selectedServers || profileData?.servers;
+  if (!profileServers) {
+    const profiles = (await fs.readdir(profileDir)).filter((name) => name.endsWith(".json")).map((name) => path.basename(name, ".json")).sort();
+    throw new Error(`MCP profile not found: ${profile}. Available profiles: ${profiles.join(", ")}`);
+  }
+  if (profile === "custom" && profileServers.length === 0) throw new Error("Custom MCP profile requires at least one server.");
+
+  const mcpServers = {};
+
+  for (const name of profileServers) {
+    const serverPath = path.join(sourceRoot, "mcp", "servers", `${name}.json`);
+    if (!exists(serverPath)) throw new Error(`MCP server definition not found: ${name}`);
+    const serverData = await readJson(serverPath);
+    Object.assign(mcpServers, serverData);
+  }
+
+  return { profileServers, mcpServers };
+}
+
+export async function collectMcpValues(mcpServers, { yes = false, values = {} } = {}) {
+  const inputs = findMcpInputs(mcpServers);
+  const nextValues = { ...values };
+
+  if (yes || !isInteractive()) return nextValues;
+
+  for (const input of inputs) {
+    if (nextValues[input.name]) continue;
+    const initial = process.env[input.name] || input.defaultValue;
+    if (input.kind === "path") {
+      nextValues[input.name] = await askText(`MCP path — ${input.label}`, {
+        initial: initial || ".",
+        validate: validateRelativeMcpPath
+      });
+    } else if (input.kind === "secret") {
+      nextValues[input.name] = await askPassword(mcpSecretPrompt(input), {
+        initial,
+        validate: (value) => String(value || "").trim() ? true : "Required"
+      });
+    } else {
+      nextValues[input.name] = await askText(`MCP value — ${input.label}`, {
+        initial,
+        validate: (value) => String(value || "").trim() ? true : "Required"
+      });
+    }
+  }
+
+  return nextValues;
+}
+
+function warnMissingMcpValues(mcpServers, values) {
+  const missing = missingRequiredInputs(findMcpInputs(mcpServers), { ...process.env, ...values });
+  if (missing.length === 0) return [];
+  const names = missing.map((input) => input.name);
+  console.warn(style("info", `MCP values missing: ${names.join(", ")}. Export env vars or edit .mcp.json before using those servers.`));
+  return names;
+}
+
+async function syncEnabledMcpServers(target, servers, { dryRun = false } = {}) {
+  const settingsPath = path.join(target, ".claude", "settings.json");
+  const settings = await readJson(settingsPath, {
+    "$schema": "https://json.schemastore.org/claude-code-settings.json",
+    "permissions": {
+      "allow": [],
+      "ask": [],
+      "deny": [],
+      "additionalDirectories": [],
+      "defaultMode": "default",
+      "disableBypassPermissionsMode": "disable"
+    },
+    "hooks": {}
+  });
+
+  settings.enabledMcpjsonServers = servers;
+
+  await writeJson(settingsPath, settings, { dryRun });
+}
+
+export async function generateMcp({ sourceRoot, target, profile = "web", mcpServers: selectedServers = null, mcpValues = {}, yes = false, dryRun = false }) {
+  const { profileServers, mcpServers } = await readMcpConfig({ sourceRoot, profile, mcpServers: selectedServers });
+  if (isTracked(target, ".mcp.json")) throw new Error(".mcp.json is tracked. Untrack it before generating MCP config with local values.");
+  if (isTracked(target, ".claude/settings.json")) throw new Error(".claude/settings.json is tracked. Untrack it before enabling MCP servers.");
+  const values = await collectMcpValues(mcpServers, { yes, values: mcpValues });
+  const resolvedMcpServers = applyMcpValues(mcpServers, values);
+
+  await ensureDir(target, { dryRun });
+  await writeJson(path.join(target, ".mcp.json"), { mcpServers: resolvedMcpServers }, { dryRun });
+  await appendGitignoreLine(target, ".mcp.json", { dryRun });
+
+  await syncEnabledMcpServers(target, profileServers, { dryRun });
+
+  const lockPath = path.join(target, ".repo-pattern.lock.json");
+  const lock = await readJson(lockPath, {});
+  lock.mcp = lock.mcp || {};
+  lock.mcp.profile = profile;
+  lock.mcp.enabledServers = profileServers;
+  lock.mcp.generatedAt = new Date().toISOString();
+  await writeJson(lockPath, lock, { dryRun });
+
+  const missingValues = warnMissingMcpValues(mcpServers, values);
+  printSummary("MCP generated", [
+    ["Profile", profile],
+    ["Enabled servers", Object.keys(mcpServers).join(", ")],
+    ["Claude enabled", profileServers.join(", ")]
+  ]);
+  return { missingValues };
+}

package/scripts/lib/project-detect.mjs

@@ -0,0 +1,107 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { exists, readJson } from "./fs-utils.mjs";
+
+async function hasAny(target, rels) {
+  for (const rel of rels) {
+    if (exists(path.join(target, rel))) return true;
+  }
+  return false;
+}
+
+function depNames(pkg) {
+  return new Set([
+    ...Object.keys(pkg.dependencies || {}),
+    ...Object.keys(pkg.devDependencies || {}),
+    ...Object.keys(pkg.peerDependencies || {}),
+    ...Object.keys(pkg.optionalDependencies || {})
+  ]);
+}
+
+function hasDep(deps, names) {
+  return names.some((name) => deps.has(name));
+}
+
+async function findByExtension(target, extension) {
+  try {
+    const entries = await fs.readdir(target);
+    return entries.some((entry) => entry.endsWith(extension));
+  } catch {
+    return false;
+  }
+}
+
+export async function detectProject(target) {
+  const pkg = await readJson(path.join(target, "package.json"), null);
+  const deps = pkg ? depNames(pkg) : new Set();
+
+  const languages = new Set();
+  const frameworks = new Set();
+  const tools = new Set();
+
+  const hasPackageJson = !!pkg;
+  const hasTsConfig = await hasAny(target, ["tsconfig.json", "tsconfig.base.json"]);
+
+  if (hasPackageJson) languages.add("javascript");
+  if (hasTsConfig || hasDep(deps, ["typescript", "ts-node", "tsx"])) languages.add("typescript");
+
+  if (await hasAny(target, ["pyproject.toml", "requirements.txt", "setup.py", "setup.cfg", "uv.lock", "poetry.lock"])) languages.add("python");
+  if (await hasAny(target, ["go.mod"])) languages.add("go");
+  if (await hasAny(target, ["pom.xml", "build.gradle", "build.gradle.kts", "gradlew"])) languages.add("java");
+  if (hasDep(deps, ["kotlin", "org.jetbrains.kotlin.jvm", "org.jetbrains.kotlin.android"])) languages.add("kotlin");
+  if (await hasAny(target, ["Cargo.toml"])) languages.add("rust");
+  if (await hasAny(target, ["pubspec.yaml"])) languages.add("dart");
+  if (await hasAny(target, ["CMakeLists.txt", "conanfile.txt", "conanfile.py", "vcpkg.json"]) || await findByExtension(target, ".cpp") || await findByExtension(target, ".cc") || await findByExtension(target, ".cxx")) languages.add("cpp");
+  if (await findByExtension(target, ".csproj") || await findByExtension(target, ".sln")) languages.add("csharp");
+  if (await findByExtension(target, ".fsproj") || await findByExtension(target, ".fs")) languages.add("fsharp");
+  if (await hasAny(target, ["cpanfile", "Makefile.PL", "Build.PL"]) || await findByExtension(target, ".pl") || await findByExtension(target, ".pm")) languages.add("perl");
+  if (await hasAny(target, ["composer.json"])) languages.add("php");
+  if (await hasAny(target, ["Gemfile"]) || await findByExtension(target, ".gemspec")) languages.add("ruby");
+  if (await hasAny(target, ["Package.swift"]) || await findByExtension(target, ".xcodeproj") || await findByExtension(target, ".xcworkspace")) languages.add("swift");
+  if (await hasAny(target, ["oh-package.json5", "build-profile.json5", "hvigorfile.ts"])) languages.add("arkts");
+
+  if (hasDep(deps, ["next"]) || await hasAny(target, ["next.config.js", "next.config.mjs", "next.config.ts"])) {
+    frameworks.add("nextjs");
+    frameworks.add("react");
+  }
+
+  if (hasDep(deps, ["react", "react-dom"])) frameworks.add("react");
+  if (hasDep(deps, ["react-native", "expo"])) frameworks.add("react-native");
+  if (hasDep(deps, ["@angular/core"]) || await hasAny(target, ["angular.json"])) frameworks.add("angular");
+  if (hasDep(deps, ["vue", "@vitejs/plugin-vue"])) frameworks.add("vue");
+  if (hasDep(deps, ["nuxt"]) || await hasAny(target, ["nuxt.config.js", "nuxt.config.mjs", "nuxt.config.ts"])) {
+    frameworks.add("nuxt");
+    frameworks.add("vue");
+  }
+
+  if (await hasAny(target, ["vite.config.js", "vite.config.mjs", "vite.config.ts", "webpack.config.js"])) tools.add("bundler");
+  if (hasDep(deps, ["vite", "webpack", "rollup", "parcel", "playwright", "@playwright/test", "cypress"])) tools.add("frontend-tooling");
+
+  const monorepo = await hasAny(target, ["pnpm-workspace.yaml", "turbo.json", "nx.json", "lerna.json", "rush.json"]);
+
+  let packageManager = null;
+  if (await hasAny(target, ["pnpm-lock.yaml"])) packageManager = "pnpm";
+  else if (await hasAny(target, ["yarn.lock"])) packageManager = "yarn";
+  else if (await hasAny(target, ["bun.lockb", "bun.lock"])) packageManager = "bun";
+  else if (await hasAny(target, ["package-lock.json"])) packageManager = "npm";
+
+  const frontendFrameworks = ["nextjs", "react", "react-native", "angular", "vue", "nuxt"];
+  const backendLanguages = ["python", "go", "java", "kotlin", "rust", "cpp", "csharp", "fsharp", "perl", "php", "ruby", "swift", "arkts"];
+  const hasFrontend = [...frameworks].some((fw) => frontendFrameworks.includes(fw)) || tools.has("frontend-tooling");
+  const hasBackend = backendLanguages.some((language) => languages.has(language));
+
+  let repoType = "generic";
+  if (hasFrontend && hasBackend) repoType = "fullstack";
+  else if (hasFrontend) repoType = "frontend";
+  else if (hasBackend) repoType = "backend";
+  else if (hasPackageJson) repoType = "node";
+
+  return {
+    languages: [...languages],
+    frameworks: [...frameworks],
+    tools: [...tools],
+    packageManager,
+    monorepo,
+    repoType
+  };
+}

package/scripts/lib/prompt.mjs

@@ -0,0 +1,226 @@
+import { confirm, isCancel, multiselect, note, password, select, spinner, text } from "@clack/prompts";
+
+export function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+function handleCancel(value) {
+  if (isCancel(value)) throw new Error("Setup cancelled.");
+  return value;
+}
+
+function clackValidate(validate, fallback = null) {
+  if (!validate) return undefined;
+  return (value) => {
+    const result = validate(value || fallback || "");
+    if (result === true) return undefined;
+    if (result === false) return "Invalid";
+    return result;
+  };
+}
+
+export async function askText(message, { initial = "", validate = null } = {}) {
+  return handleCancel(await text({
+    message,
+    initialValue: initial,
+    validate: clackValidate(validate)
+  }));
+}
+
+export async function askPassword(message, { initial = "", validate = null } = {}) {
+  const value = handleCancel(await password({
+    message: initial ? `${message} (leave empty to keep current value)` : message,
+    validate: clackValidate(validate, initial)
+  }));
+  return value || initial;
+}
+
+export async function askConfirm(message, defaultYes = true) {
+  return handleCancel(await confirm({
+    message,
+    initialValue: defaultYes
+  })) === true;
+}
+
+function normalizeOptions(options) {
+  return options.map((option) => {
+    if (typeof option === "string") return { label: option, value: option };
+    return {
+      label: option.title || option.label || option.value,
+      value: option.value,
+      hint: option.description || option.hint,
+      selected: option.selected,
+      disabled: option.disabled
+    };
+  });
+}
+
+function enabledOptions(options) {
+  return options.filter((option) => !option.disabled);
+}
+
+export async function selectOne({ message, options, initialValue = null }) {
+  const normalized = normalizeOptions(options);
+  if (normalized.some((choice) => choice.disabled && choice.value === initialValue)) {
+    throw new Error(`Initial option is disabled: ${initialValue}`);
+  }
+
+  const choices = enabledOptions(normalized);
+  return handleCancel(await select({
+    message,
+    options: choices,
+    initialValue
+  }));
+}
+
+export async function selectMany({ message, options, initialValues = [] }) {
+  const choices = enabledOptions(normalizeOptions(options));
+  const enabledValues = new Set(choices.map((choice) => choice.value));
+  const selected = new Set(initialValues.filter((value) => enabledValues.has(value)));
+  for (const choice of choices) {
+    if (choice.selected) selected.add(choice.value);
+  }
+
+  return handleCancel(await multiselect({
+    message,
+    options: choices,
+    initialValues: [...selected],
+    required: false
+  }));
+}
+
+export function printBox(title, lines = []) {
+  if (isInteractive()) {
+    note(lines.join("\n"), title);
+    return;
+  }
+
+  console.log(`\n== ${title} ==`);
+  for (const line of lines) console.log(line);
+}
+
+const ANSI_RESET = "\x1b[0m";
+const ANSI_STYLES = {
+  dim: "\x1b[2m",
+  error: "\x1b[31m",
+  info: "\x1b[34m",
+  success: "\x1b[32m"
+};
+const LOGO_PALETTE = ["\x1b[38;5;39m", "\x1b[38;5;81m", "\x1b[38;5;141m", "\x1b[38;5;213m"];
+const LOGO_LINES = [
+  "  ____  ____ ",
+  " |  _ \\|  _ \\",
+  " | |_) | |_) |",
+  " |  _ <|  __/ ",
+  " |_| \\_\\_|    ",
+  "repo-pattern"
+];
+
+function supportsAnsiColor() {
+  return isInteractive() && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+}
+
+export function style(kind, value) {
+  const color = ANSI_STYLES[kind];
+  return color && supportsAnsiColor() ? `${color}${value}${ANSI_RESET}` : String(value);
+}
+
+function gradient(line) {
+  let painted = 0;
+  const total = [...line].filter((char) => char !== " ").length || 1;
+  return [...line].map((char) => {
+    if (char === " ") return char;
+    const color = LOGO_PALETTE[Math.floor(painted++ * LOGO_PALETTE.length / total)];
+    return `${color}${char}`;
+  }).join("") + ANSI_RESET;
+}
+
+export function renderLogo({ color = false } = {}) {
+  const lines = color ? LOGO_LINES.map(gradient) : LOGO_LINES;
+  return [...lines, "ECC-first Claude Code setup"];
+}
+
+export function printLogo() {
+  printBox("repo-pattern", renderLogo({ color: supportsAnsiColor() }));
+}
+
+const SUMMARY_VALUE_WIDTH = 72;
+
+function wrapValue(value) {
+  const text = String(value);
+  if (text.length <= SUMMARY_VALUE_WIDTH) return [text];
+
+  const rawParts = text.includes(", ") ? text.split(", ") : text.split(" ");
+  const parts = rawParts.map((part, index) => text.includes(", ") && index < rawParts.length - 1 ? `${part},` : part);
+  const lines = [];
+  let line = "";
+
+  function pushLine(value) {
+    lines.push(value);
+  }
+
+  for (const part of parts) {
+    if (part.length > SUMMARY_VALUE_WIDTH) {
+      if (line) {
+        pushLine(line);
+        line = "";
+      }
+      for (let i = 0; i < part.length; i += SUMMARY_VALUE_WIDTH) {
+        pushLine(part.slice(i, i + SUMMARY_VALUE_WIDTH));
+      }
+      continue;
+    }
+
+    const next = line ? `${line} ${part}` : part;
+    if (next.length > SUMMARY_VALUE_WIDTH && line) {
+      pushLine(line);
+      line = part;
+    } else {
+      line = next;
+    }
+  }
+
+  if (line) pushLine(line);
+  return lines;
+}
+
+function summaryLines(rows) {
+  const width = Math.max(...rows.map(([label]) => label.length), 0);
+  const lines = [];
+  for (const [label, value] of rows) {
+    const wrapped = wrapValue(value);
+    lines.push(`${label.padEnd(width)}  ${wrapped[0]}`);
+    for (const continuation of wrapped.slice(1)) {
+      lines.push(`${"".padEnd(width)}  ${continuation}`);
+    }
+  }
+  return lines;
+}
+
+export function printSummary(title, rows = []) {
+  const lines = summaryLines(rows);
+  if (!isInteractive()) {
+    printBox(title, lines);
+    return;
+  }
+  note(lines.join("\n"), title);
+}
+
+export async function withSpinner(message, task) {
+  if (!isInteractive()) return task();
+
+  const s = spinner();
+  s.start(message);
+  try {
+    const result = await task();
+    s.stop(`${message} done`);
+    return result;
+  } catch (error) {
+    s.stop(`${message} failed`);
+    throw error;
+  }
+}
+
+export function printSection(title) {
+  console.log(isInteractive() ? `\n◆ ${title}` : `\n== ${title} ==`);
+}