@squadbase/vantage-template 0.0.1

package/dist/index.js

@@ -0,0 +1,1157 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { parseArgs } from "util";
+
+// src/commands/add.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join4 } from "path";
+
+// src/ai/customize.ts
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+// src/logger.ts
+var colors = {
+  red: "\x1B[0;31m",
+  green: "\x1B[0;32m",
+  yellow: "\x1B[1;33m",
+  cyan: "\x1B[0;36m",
+  dim: "\x1B[2m",
+  reset: "\x1B[0m"
+};
+function log(color, message) {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+// src/ai/diff.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  red: "\x1B[0;31m",
+  green: "\x1B[0;32m",
+  cyan: "\x1B[0;36m",
+  dim: "\x1B[2m"
+};
+function computeOps(before, after) {
+  const n = before.length;
+  const m = after.length;
+  const dp = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      if (before[i2] === after[j2]) {
+        dp[i2][j2] = dp[i2 + 1][j2 + 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+      }
+    }
+  }
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (before[i] === after[j]) {
+      ops.push({ type: "equal", value: before[i] });
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      ops.push({ type: "delete", value: before[i] });
+      i++;
+    } else {
+      ops.push({ type: "insert", value: after[j] });
+      j++;
+    }
+  }
+  while (i < n) ops.push({ type: "delete", value: before[i++] });
+  while (j < m) ops.push({ type: "insert", value: after[j++] });
+  return ops;
+}
+function unifiedDiff(before, after, filename, options = {}) {
+  const beforeLines = before.split("\n");
+  const afterLines = after.split("\n");
+  const ops = computeOps(beforeLines, afterLines);
+  const context = options.context ?? 2;
+  const lines = [];
+  lines.push(`${ANSI.cyan}--- ${filename}${ANSI.reset}`);
+  lines.push(`${ANSI.cyan}+++ ${filename}${ANSI.reset}`);
+  const hasChange = ops.some((o) => o.type !== "equal");
+  if (!hasChange) {
+    lines.push(`${ANSI.dim}(no change)${ANSI.reset}`);
+    return lines.join("\n");
+  }
+  const hunks = [];
+  let current = [];
+  let trailingEqual = 0;
+  for (const op of ops) {
+    if (op.type === "equal") {
+      trailingEqual++;
+      current.push(op);
+      if (trailingEqual > context * 2 && current.some((o) => o.type !== "equal")) {
+        const trimmed = current.slice(0, current.length - (trailingEqual - context));
+        hunks.push(trimmed);
+        current = current.slice(current.length - context);
+        trailingEqual = context;
+      }
+    } else {
+      trailingEqual = 0;
+      current.push(op);
+    }
+  }
+  if (current.some((o) => o.type !== "equal")) {
+    hunks.push(current);
+  }
+  for (const hunk of hunks) {
+    let leading = 0;
+    while (leading < hunk.length && hunk[leading].type === "equal") leading++;
+    if (leading > context) {
+      hunk.splice(0, leading - context);
+    }
+  }
+  for (const hunk of hunks) {
+    for (const op of hunk) {
+      if (op.type === "equal") {
+        lines.push(` ${op.value}`);
+      } else if (op.type === "delete") {
+        lines.push(`${ANSI.red}-${op.value}${ANSI.reset}`);
+      } else {
+        lines.push(`${ANSI.green}+${op.value}${ANSI.reset}`);
+      }
+    }
+    lines.push(`${ANSI.dim}...${ANSI.reset}`);
+  }
+  if (lines[lines.length - 1] === `${ANSI.dim}...${ANSI.reset}`) lines.pop();
+  return lines.join("\n");
+}
+function diffStats(before, after) {
+  const ops = computeOps(before.split("\n"), after.split("\n"));
+  let added = 0;
+  let removed = 0;
+  for (const op of ops) {
+    if (op.type === "insert") added++;
+    else if (op.type === "delete") removed++;
+  }
+  return { added, removed };
+}
+
+// src/ai/provider.ts
+var PROVIDER_MAP = {
+  openai: {
+    pkg: "@ai-sdk/openai",
+    factory: "createOpenAI",
+    defaultModel: "gpt-5.4-mini-2026-03-17",
+    envKey: "OPENAI_API_KEY"
+  },
+  anthropic: {
+    pkg: "@ai-sdk/anthropic",
+    factory: "createAnthropic",
+    defaultModel: "claude-sonnet-4-5",
+    envKey: "ANTHROPIC_API_KEY"
+  },
+  google: {
+    pkg: "@ai-sdk/google",
+    factory: "createGoogleGenerativeAI",
+    defaultModel: "gemini-3.5-flash",
+    envKey: "GOOGLE_GENERATIVE_AI_API_KEY",
+    envKeyAliases: ["GOOGLE_AI_API_KEY"]
+  },
+  mistral: {
+    pkg: "@ai-sdk/mistral",
+    factory: "createMistral",
+    defaultModel: "mistral-large-latest",
+    envKey: "MISTRAL_API_KEY"
+  },
+  xai: {
+    pkg: "@ai-sdk/xai",
+    factory: "createXai",
+    defaultModel: "grok-2-latest",
+    envKey: "XAI_API_KEY"
+  },
+  groq: {
+    pkg: "@ai-sdk/groq",
+    factory: "createGroq",
+    defaultModel: "llama-3.3-70b-versatile",
+    envKey: "GROQ_API_KEY"
+  }
+};
+function normalizeProvider(provider) {
+  return provider.toLowerCase().replace(/[-_\s]/g, "");
+}
+async function resolveModel(opts) {
+  const normalized = normalizeProvider(opts.provider);
+  const entry = PROVIDER_MAP[normalized] ?? {
+    pkg: `@ai-sdk/${normalized}`,
+    factory: normalized,
+    defaultModel: "",
+    envKey: `${normalized.toUpperCase()}_API_KEY`
+  };
+  const apiKey = opts.apiKey ?? process.env[entry.envKey] ?? entry.envKeyAliases?.map((k) => process.env[k]).find((v) => Boolean(v));
+  if (!apiKey) {
+    const envKeyList = [entry.envKey, ...entry.envKeyAliases ?? []].join(" or ");
+    throw new Error(
+      `Missing API key for provider "${opts.provider}". Pass --apiKey, or set ${envKeyList}.`
+    );
+  }
+  const modelId = opts.model ?? entry.defaultModel;
+  if (!modelId) {
+    throw new Error(
+      `No default model is known for provider "${opts.provider}". Pass --model <model-id>.`
+    );
+  }
+  let mod;
+  try {
+    mod = await import(entry.pkg);
+  } catch {
+    throw new Error(
+      [
+        `AI SDK provider package "${entry.pkg}" is not installed.`,
+        `Run: npm install ai ${entry.pkg}`
+      ].join("\n")
+    );
+  }
+  const factory = mod[entry.factory] ?? mod.default?.[entry.factory];
+  if (typeof factory !== "function") {
+    throw new Error(
+      `Could not find factory "${entry.factory}" in "${entry.pkg}". The provider package layout may have changed.`
+    );
+  }
+  const providerInstance = factory({ apiKey, baseURL: opts.baseUrl });
+  const modelSettings = normalized === "google" ? { thinkingConfig: { thinkingBudget: 0, includeThoughts: false } } : void 0;
+  const model = providerInstance(modelId, modelSettings);
+  return { model, providerName: normalized, modelId };
+}
+
+// src/ai/system-prompt.ts
+var SYSTEM_PROMPT = `You are a copy-alignment assistant for the Squadbase Vantage dashboard template.
+
+The files under <FILES_TO_CUSTOMIZE> are a finished, idiomatic dashboard. The user wants only its *surface wording* nudged toward <USER_INTENT> \u2014 just enough that the screen reads as if it were built for that use case. This is a light relabeling pass, not a rebuild. When in doubt, change less.
+
+# What you may change
+Only string literals that a user reads on screen or that act as labels:
+- Page / section titles, descriptions, and headings.
+- KPI names, chart titles & descriptions, axis & series & legend text.
+- Filter labels and option text, table column headers.
+- Label lists and copy maps that appear as plain string literals in the provided files \u2014 KPI name lists, stage names, chart axis names, and the like. (Mock data files are not provided; you only relabel the display copy in the component and page files you are given.)
+
+# What you must not touch
+You edit only the *text inside* an existing string literal, or the text *between* two existing tags \u2014 never the code around it.
+- Never change a number, currency amount, percentage, or date, and never touch a value that contains code: a \`\${...}\` interpolation, a function call, or a variable reference. Those are sample or computed values, not copy.
+- Never add, remove, reorder, or replace a JSX element, component, icon, or wrapper \u2014 including \`<Placeholder>\` and \`<Skeleton>\`. Do not turn a placeholder into text, or text into a placeholder.
+- Do not edit, add, or remove \`import\` lines, and do not alter logic, types, data shape, array lengths, or component composition.
+- Every edit must leave all existing imports and variables still referenced. If a rename would orphan an import or a variable, skip it.
+
+# How to choose wording
+Treat <USER_INTENT> as a hint about the domain, not a spec. Pick natural, concrete labels a real dashboard for that domain would use \u2014 never \`foo / bar / baz\`. Keep each replacement close to the original in length and tone so the layout still fits. If a label already suits the domain, leave it. Files are relabeled independently, so use the same wording for a given concept (e.g. a recurring metric name) everywhere it appears, drawn from <USER_INTENT>, to keep repeated labels consistent across files.
+
+# Output
+Return search/replace edits. Each has \`path\` (a dest from the schema enum), \`old_content\` (the exact current snippet, matched byte-for-byte and unique within the file \u2014 include surrounding context if needed), \`new_content\` (the renamed text), and \`rationale\` (one short sentence). You are renaming, so \`new_content\` is never empty. Return an empty array if nothing needs renaming. Use \`notes\` only to flag something noteworthy.
+
+Before returning, re-check every edit: it changes display copy only, leaves all code, numbers, and JSX elements intact, and orphans no import or variable.
+`;
+
+// src/ai/customize.ts
+async function importAI() {
+  try {
+    const mod = await import("ai");
+    return mod;
+  } catch {
+    throw new Error(
+      [
+        `AI SDK package "ai" is not installed.`,
+        `Run: npm install ai`
+      ].join("\n")
+    );
+  }
+}
+function buildSchema(allowedPaths) {
+  return {
+    type: "object",
+    additionalProperties: false,
+    required: ["edits", "notes"],
+    properties: {
+      edits: {
+        type: "array",
+        items: {
+          type: "object",
+          additionalProperties: false,
+          required: ["path", "old_content", "new_content", "rationale"],
+          properties: {
+            path: { type: "string", enum: allowedPaths },
+            old_content: { type: "string" },
+            new_content: { type: "string" },
+            rationale: { type: "string" }
+          }
+        }
+      },
+      notes: { type: "string" }
+    }
+  };
+}
+function buildUserPrompt(intent, files) {
+  const parts = [];
+  parts.push(`<USER_INTENT>`);
+  parts.push(intent);
+  parts.push(`</USER_INTENT>`);
+  parts.push("");
+  parts.push(`<FILES_TO_CUSTOMIZE>`);
+  for (const [path, content] of files) {
+    parts.push(`--- FILE: ${path} ---`);
+    parts.push(content);
+    parts.push("");
+  }
+  parts.push(`</FILES_TO_CUSTOMIZE>`);
+  return parts.join("\n");
+}
+function readInputFiles(projectRoot, templateDir, entries, fromTemplate) {
+  const files = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const path = fromTemplate ? join(templateDir, entry.src) : join(projectRoot, entry.dest);
+    try {
+      files.set(entry.dest, readFileSync(path, "utf-8"));
+    } catch (err) {
+      throw new Error(
+        `Failed to read ${path}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return files;
+}
+function applyEditsToFile(before, edits) {
+  let text = before;
+  for (const edit of edits) {
+    const idx = text.indexOf(edit.old_content);
+    if (idx === -1) {
+      throw new Error(`old_content not found in file:
+${edit.old_content}`);
+    }
+    if (text.indexOf(edit.old_content, idx + 1) !== -1) {
+      throw new Error(
+        `old_content is not unique (matched more than once); include more surrounding context:
+${edit.old_content}`
+      );
+    }
+    text = text.slice(0, idx) + edit.new_content + text.slice(idx + edit.old_content.length);
+  }
+  return text;
+}
+var RELABEL_CONCURRENCY = 4;
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (true) {
+      const i = next++;
+      if (i >= items.length) return;
+      try {
+        results[i] = { status: "fulfilled", value: await fn(items[i], i) };
+      } catch (reason) {
+        results[i] = { status: "rejected", reason };
+      }
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, () => worker())
+  );
+  return results;
+}
+async function relabelFile(generateObject, jsonSchema, model, intent, path, content) {
+  const schema = jsonSchema(buildSchema([path]));
+  const userPrompt = buildUserPrompt(intent, /* @__PURE__ */ new Map([[path, content]]));
+  const result = await generateObject({
+    model,
+    schema,
+    system: SYSTEM_PROMPT,
+    prompt: userPrompt,
+    temperature: 0.3,
+    maxTokens: 8e3
+  });
+  const object = result.object;
+  if (process.env.SQUADBASE_AI_DEBUG) {
+    const r = result;
+    log(
+      "dim",
+      `[debug] ${path} finishReason=${r.finishReason ?? "?"} usage=${JSON.stringify(r.usage ?? {})}`
+    );
+  }
+  let edits = [];
+  const rawEdits = object.edits;
+  if (typeof rawEdits === "string") {
+    edits = parseEditsString(rawEdits);
+  } else if (Array.isArray(rawEdits)) {
+    edits = rawEdits;
+  } else if (rawEdits != null) {
+    throw new Error(`AI returned \`edits\` as ${typeof rawEdits}, expected array.`);
+  }
+  return { edits, notes: object.notes };
+}
+function formatAIError(err, modelId) {
+  const e = err;
+  const parts = [];
+  parts.push(`AI did not return a valid object (model=${modelId}).`);
+  if (e.message) parts.push(`Message: ${e.message}`);
+  if (e.finishReason) parts.push(`finishReason: ${e.finishReason}`);
+  if (typeof e.text === "string" && e.text.length > 0) {
+    const snippet = e.text.length > 800 ? `${e.text.slice(0, 800)}\u2026(${e.text.length} chars)` : e.text;
+    parts.push(`Raw response text:
+${snippet}`);
+  }
+  if (e.cause) {
+    const causeMsg = e.cause instanceof Error ? e.cause.message : String(e.cause);
+    parts.push(`Cause: ${causeMsg}`);
+  }
+  if (e.usage) parts.push(`Usage: ${JSON.stringify(e.usage)}`);
+  return parts.join("\n");
+}
+async function customizeWithAI(projectRoot, manifest, templateDir, options) {
+  const relabelFiles = manifest.files.filter((f) => f.relabel !== false);
+  const allowedPaths = relabelFiles.map((f) => f.dest);
+  const inputFiles = readInputFiles(
+    projectRoot,
+    templateDir,
+    relabelFiles,
+    options.dryRun
+  );
+  if (!options.json) {
+    log("cyan", `
+Customizing with AI (${options.provider}${options.model ? `:${options.model}` : ""})...`);
+    log("dim", `  files: ${allowedPaths.length}, intent: ${truncate(options.prompt, 80)}`);
+  }
+  const { generateObject, jsonSchema } = await importAI();
+  const { model, providerName, modelId } = await resolveModel({
+    provider: options.provider,
+    model: options.model,
+    apiKey: options.apiKey,
+    baseUrl: options.baseUrl
+  });
+  const aiError = [];
+  const editsArray = [];
+  const noteParts = [];
+  const settled = await mapWithConcurrency(
+    allowedPaths,
+    RELABEL_CONCURRENCY,
+    (path) => relabelFile(
+      generateObject,
+      jsonSchema,
+      model,
+      options.prompt,
+      path,
+      inputFiles.get(path) ?? ""
+    )
+  );
+  settled.forEach((r, i) => {
+    const path = allowedPaths[i];
+    if (r.status === "fulfilled") {
+      editsArray.push(...r.value.edits);
+      if (r.value.notes && r.value.notes.trim().length > 0) {
+        noteParts.push(`${path}: ${r.value.notes.trim()}`);
+      }
+    } else {
+      aiError.push(path);
+      if (!options.json) {
+        const msg = formatAIError(r.reason, modelId);
+        log("red", `
+${path}: AI call failed (left unchanged)`);
+        log("dim", `  ${msg.split("\n")[0]}`);
+        if (process.env.SQUADBASE_AI_DEBUG) {
+          log("dim", msg);
+        }
+      }
+    }
+  });
+  const allowedSet = new Set(allowedPaths);
+  const skipped = [];
+  const editsByPath = /* @__PURE__ */ new Map();
+  for (const raw of editsArray) {
+    if (!allowedSet.has(raw.path)) {
+      skipped.push(raw.path);
+      continue;
+    }
+    const arr = editsByPath.get(raw.path) ?? [];
+    arr.push(raw);
+    editsByPath.set(raw.path, arr);
+  }
+  const edits = [];
+  const failedVerification = [];
+  for (const [path, rawForPath] of editsByPath) {
+    const before = inputFiles.get(path) ?? "";
+    try {
+      const after = applyEditsToFile(before, rawForPath);
+      if (after === before) continue;
+      const { added, removed } = diffStats(before, after);
+      const rationale = rawForPath.map((e) => e.rationale).filter((s) => s && s.trim().length > 0).join("; ");
+      edits.push({
+        path,
+        rationale,
+        before,
+        after,
+        added,
+        removed
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      failedVerification.push(path);
+      if (!options.json) {
+        log("red", `
+${path}: edit verification failed`);
+        log("dim", `  ${msg.split("\n")[0]}`);
+        if (process.env.SQUADBASE_AI_DEBUG) {
+          log("dim", msg);
+        }
+      }
+    }
+  }
+  const editedPaths = new Set(edits.map((e) => e.path));
+  const failedSet = new Set(failedVerification);
+  const erroredSet = new Set(aiError);
+  const unchanged = allowedPaths.filter(
+    (p) => !editedPaths.has(p) && !failedSet.has(p) && !erroredSet.has(p)
+  );
+  if (options.dryRun) {
+    if (!options.json) {
+      for (const edit of edits) {
+        log("cyan", `
+${edit.path}  (+${edit.added} -${edit.removed})`);
+        if (edit.rationale) log("dim", `  ${edit.rationale}`);
+        console.log(unifiedDiff(edit.before, edit.after, edit.path));
+      }
+    }
+  } else {
+    for (const edit of edits) {
+      writeFileSync(join(projectRoot, edit.path), edit.after, "utf-8");
+      if (!options.json) {
+        log("cyan", `  rewrote: ${edit.path} (+${edit.added} -${edit.removed})`);
+      }
+    }
+  }
+  return {
+    edits,
+    unchanged,
+    skipped,
+    failedVerification,
+    aiError,
+    notes: noteParts.length > 0 ? noteParts.join("\n") : void 0,
+    provider: providerName,
+    model: modelId
+  };
+}
+function truncate(s, n) {
+  if (s.length <= n) return s;
+  return s.slice(0, n - 1) + "\u2026";
+}
+function stripTrailingCommas(s) {
+  const out = [];
+  let inString = false;
+  let escape = false;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (inString) {
+      out.push(ch);
+      if (escape) {
+        escape = false;
+      } else if (ch === "\\") {
+        escape = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out.push(ch);
+      continue;
+    }
+    if (ch === ",") {
+      let j = i + 1;
+      while (j < s.length && /\s/.test(s[j])) j++;
+      if (j < s.length && (s[j] === "]" || s[j] === "}")) {
+        continue;
+      }
+    }
+    out.push(ch);
+  }
+  return out.join("");
+}
+function parseEditsString(raw) {
+  let lastErr = null;
+  for (const candidate of [raw, stripTrailingCommas(raw)]) {
+    try {
+      const parsed = JSON.parse(candidate);
+      if (Array.isArray(parsed)) return parsed;
+      throw new Error(`Parsed edits is ${typeof parsed}, expected array.`);
+    } catch (err) {
+      lastErr = err;
+    }
+  }
+  throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+}
+
+// src/apply.ts
+import { copyFileSync, existsSync as existsSync2, mkdirSync } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+
+// src/manifest.ts
+import { existsSync, readFileSync as readFileSync2, readdirSync } from "fs";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function getTemplatesDir(source = "ui-templates") {
+  return join2(__dirname, "..", source);
+}
+function getTemplateDir(templateName, source = "ui-templates") {
+  return join2(getTemplatesDir(source), templateName);
+}
+function listTemplateNames(source = "ui-templates") {
+  const templatesDir = getTemplatesDir(source);
+  if (!existsSync(templatesDir)) {
+    return [];
+  }
+  return readdirSync(templatesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+}
+function loadManifest(templateName, source = "ui-templates") {
+  const templateDir = getTemplateDir(templateName, source);
+  if (!existsSync(templateDir)) {
+    throw new Error(`Template "${templateName}" not found.`);
+  }
+  const manifestPath = join2(templateDir, "manifest.json");
+  if (!existsSync(manifestPath)) {
+    throw new Error(`Template "${templateName}" is missing manifest.json.`);
+  }
+  const raw = JSON.parse(readFileSync2(manifestPath, "utf-8"));
+  if (!raw.name || !raw.files || !Array.isArray(raw.files)) {
+    throw new Error(`Invalid manifest.json in template "${templateName}".`);
+  }
+  return raw;
+}
+
+// src/apply.ts
+function applyTemplate(projectRoot, manifest, options) {
+  const templateDir = getTemplateDir(manifest.name, options.source ?? "ui-templates");
+  const conflicts = checkConflicts(projectRoot, manifest.files, options.force);
+  if (conflicts.length > 0) {
+    log("red", "File conflicts detected (use --force to overwrite):");
+    for (const c of conflicts) {
+      log("red", `  ${c}`);
+    }
+    process.exit(1);
+  }
+  for (const file of manifest.files) {
+    const src = join3(templateDir, file.src);
+    const dest = join3(projectRoot, file.dest);
+    if (options.dryRun) {
+      const label2 = file.action === "replace" ? "replace" : "add";
+      log("dim", `  [dry-run] ${label2}: ${file.dest}`);
+      continue;
+    }
+    mkdirSync(dirname2(dest), { recursive: true });
+    copyFileSync(src, dest);
+    const label = file.action === "replace" ? "replaced" : "added";
+    log("cyan", `  ${label}: ${file.dest}`);
+  }
+}
+function checkConflicts(projectRoot, files, force) {
+  if (force) return [];
+  return files.filter((f) => f.action === "add" && existsSync2(join3(projectRoot, f.dest))).map((f) => f.dest);
+}
+
+// src/commands/add.ts
+function isVantageProject(projectRoot) {
+  const pkgPath = join4(projectRoot, "package.json");
+  if (!existsSync3(pkgPath)) return false;
+  try {
+    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+    return Boolean(pkg.dependencies?.["@squadbase/vantage"] ?? pkg.devDependencies?.["@squadbase/vantage"]);
+  } catch {
+    return false;
+  }
+}
+function findStaleTemplateFiles(projectRoot, appliedTemplate, source) {
+  const stale = [];
+  for (const name of listTemplateNames(source)) {
+    if (name === appliedTemplate) continue;
+    if (name.replace(/-ja$/, "") === appliedTemplate.replace(/-ja$/, "")) continue;
+    let manifest;
+    try {
+      manifest = loadManifest(name, source);
+    } catch {
+      continue;
+    }
+    for (const file of manifest.files) {
+      if (file.action !== "add") continue;
+      if (existsSync3(join4(projectRoot, file.dest))) stale.push(file.dest);
+    }
+  }
+  return [...new Set(stale)].sort();
+}
+async function addTemplate(templateName, options) {
+  const projectRoot = process.cwd();
+  const source = options.source ?? "ui-templates";
+  if (!isVantageProject(projectRoot)) {
+    log("red", "@squadbase/vantage is not a dependency here. Are you in a Squadbase Vantage project?");
+    log("dim", "Run 'npx @squadbase/vantage-template init' first.");
+    process.exit(1);
+  }
+  const available = listTemplateNames(source);
+  if (!available.includes(templateName)) {
+    log("red", `Template "${templateName}" not found in ${source}/.`);
+    if (available.length > 0) {
+      log("yellow", `Available templates: ${available.join(", ")}`);
+    }
+    process.exit(1);
+  }
+  const manifest = loadManifest(templateName, source);
+  const templateDir = getTemplateDir(templateName, source);
+  if (!options.ai?.json) {
+    log("green", `Applying template: ${manifest.name}`);
+    if (options.dryRun) {
+      log("yellow", "(dry run \u2014 no files will be changed)");
+    }
+    const entry = manifest.files.find((f) => f.action === "replace");
+    if (entry && existsSync3(join4(projectRoot, entry.dest))) {
+      log("yellow", `  ${entry.dest} will be overwritten \u2014 commit first if it holds your work.`);
+    }
+  }
+  applyTemplate(projectRoot, manifest, options);
+  if (!options.ai?.json) {
+    const stale = findStaleTemplateFiles(projectRoot, templateName, source);
+    if (stale.length > 0) {
+      log("yellow", "\nLeftovers from a previously applied template (nothing imports them):");
+      for (const dest of stale) log("dim", `  ${dest}`);
+      log("dim", "  Delete them so they stop showing up in searches.");
+    }
+  }
+  if (options.ai) {
+    const result = await customizeWithAI(projectRoot, manifest, templateDir, options.ai);
+    if (options.ai.json) {
+      console.log(
+        JSON.stringify(
+          {
+            provider: result.provider,
+            model: result.model,
+            edits: result.edits.map((e) => ({
+              path: e.path,
+              rationale: e.rationale,
+              added: e.added,
+              removed: e.removed
+            })),
+            unchanged: result.unchanged,
+            skipped: result.skipped,
+            failedVerification: result.failedVerification,
+            aiError: result.aiError,
+            notes: result.notes,
+            dryRun: options.dryRun
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    log("green", `
+AI customization complete (${result.provider}:${result.model})`);
+    log(
+      "dim",
+      `  edited: ${result.edits.length}, unchanged: ${result.unchanged.length}, skipped: ${result.skipped.length}, failed: ${result.failedVerification.length}, aiError: ${result.aiError.length}`
+    );
+    if (result.skipped.length > 0) {
+      log("yellow", `  skipped paths (not in manifest): ${result.skipped.join(", ")}`);
+    }
+    if (result.failedVerification.length > 0) {
+      log("yellow", `  failed verification (left unchanged): ${result.failedVerification.join(", ")}`);
+    }
+    if (result.aiError.length > 0) {
+      log("yellow", `  AI call failed (left unchanged): ${result.aiError.join(", ")}`);
+    }
+    if (result.notes) {
+      log("cyan", `
+Notes from AI:`);
+      log("dim", `  ${result.notes}`);
+    }
+    if (!options.dryRun && result.edits.length > 0) {
+      log("dim", `
+Run "git diff" to review the AI changes.`);
+    }
+    return;
+  }
+  if (!options.dryRun) {
+    log("green", "\nTemplate applied successfully!");
+    log("dim", 'Run "npx vantage check" to confirm the project still builds.');
+  }
+}
+
+// src/commands/chart.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
+
+// src/chart-presets.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3, join as join5 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+var PRESET_DESCRIPTIONS = {
+  blue: "Default \u2014 blue, teal, fuchsia, violet, gray",
+  sunset: "Warm \u2014 orange, rose, amber, pink, stone",
+  forest: "Natural \u2014 emerald, lime, teal, green, stone",
+  ocean: "Cool \u2014 sky, cyan, indigo, teal, slate",
+  berry: "Vibrant \u2014 purple, pink, fuchsia, violet, rose",
+  mono: "Minimal \u2014 zinc monochrome"
+};
+var BEGIN_MARKER = "/* vantage-template:chart-preset \u2014 regenerated by `chart`; edits here are lost */";
+var END_MARKER = "/* vantage-template:chart-preset:end */";
+function getChartPresetsDir() {
+  return join5(__dirname2, "..", "chart-presets");
+}
+function listChartPresetNames() {
+  const dir = getChartPresetsDir();
+  if (!existsSync4(dir)) return [];
+  return readdirSync2(dir).filter((f) => f.endsWith(".css")).map((f) => f.replace(/\.css$/, "")).sort();
+}
+function getChartPresetDescription(name) {
+  return PRESET_DESCRIPTIONS[name] ?? "";
+}
+function getChartPresetPath(name) {
+  return join5(getChartPresetsDir(), `${name}.css`);
+}
+function applyChartPreset(projectRoot, presetName, options = {}) {
+  const presetPath = getChartPresetPath(presetName);
+  if (!existsSync4(presetPath)) {
+    throw new Error(`Chart preset "${presetName}" not found.`);
+  }
+  const targetPath = join5(projectRoot, "styles.css");
+  if (!existsSync4(targetPath)) {
+    throw new Error("styles.css not found in project.");
+  }
+  const preset = readFileSync4(presetPath, "utf-8").trimEnd();
+  const block = `${BEGIN_MARKER}
+${preset}
+${END_MARKER}
+`;
+  const current = readFileSync4(targetPath, "utf-8");
+  const begin = current.indexOf(BEGIN_MARKER);
+  const end = current.indexOf(END_MARKER);
+  let content;
+  if (begin !== -1 && end !== -1) {
+    content = current.slice(0, begin) + block + current.slice(end + END_MARKER.length + 1);
+  } else {
+    content = `${current.trimEnd()}
+
+${block}`;
+  }
+  if (!options.dryRun) {
+    writeFileSync2(targetPath, content, "utf-8");
+  }
+  return { targetPath, content };
+}
+
+// src/commands/chart.ts
+function setChartPreset(presetName, options) {
+  const projectRoot = process.cwd();
+  const stylesPath = join6(projectRoot, "styles.css");
+  if (!existsSync5(stylesPath)) {
+    log("red", "styles.css not found. Are you in a Squadbase Vantage project?");
+    process.exit(1);
+  }
+  const available = listChartPresetNames();
+  if (!available.includes(presetName)) {
+    log("red", `Chart preset "${presetName}" not found.`);
+    if (available.length > 0) {
+      log("yellow", `Available presets: ${available.join(", ")}`);
+    }
+    process.exit(1);
+  }
+  log("green", `Applying chart preset: ${presetName}`);
+  const description = getChartPresetDescription(presetName);
+  if (description) {
+    log("dim", `  ${description}`);
+  }
+  if (options.dryRun) {
+    log("yellow", "(dry run \u2014 no files will be changed)");
+    const { content } = applyChartPreset(projectRoot, presetName, { dryRun: true });
+    log("dim", "\n--- styles.css (preview) ---");
+    console.log(content);
+    return;
+  }
+  applyChartPreset(projectRoot, presetName);
+  log("cyan", "  updated: styles.css");
+  log("green", "\nChart preset applied successfully!");
+}
+
+// src/commands/init.ts
+import { spawnSync } from "child_process";
+import { cpSync, existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync as readdirSync3 } from "fs";
+import { dirname as dirname4, join as join7 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __dirname3 = dirname4(fileURLToPath3(import.meta.url));
+var RENAME_ON_COPY = {
+  _gitignore: ".gitignore"
+};
+function getBaseTemplateDir() {
+  return join7(__dirname3, "..", "base-template");
+}
+function initProject(options) {
+  const targetDir = process.cwd();
+  const baseTemplateDir = getBaseTemplateDir();
+  if (!existsSync6(baseTemplateDir)) {
+    log("red", "Base template not found. The package may be corrupted.");
+    process.exit(1);
+  }
+  if (options.chart) {
+    const available = listChartPresetNames();
+    if (!available.includes(options.chart)) {
+      log("red", `Chart preset "${options.chart}" not found.`);
+      if (available.length > 0) {
+        log("yellow", `Available presets: ${available.join(", ")}`);
+      }
+      process.exit(1);
+    }
+  }
+  if (!options.force && existsSync6(join7(targetDir, "squadbase.yml"))) {
+    log("red", "This directory already contains a Squadbase project (squadbase.yml exists).");
+    log("yellow", "Use --force to overwrite.");
+    process.exit(1);
+  }
+  if (!options.force && existsSync6(join7(targetDir, "index.tsx"))) {
+    log("red", "This directory already contains an index.tsx.");
+    log("yellow", "Use --force to overwrite.");
+    process.exit(1);
+  }
+  log("green", "Initializing Squadbase Vantage project...");
+  const entries = readdirSync3(baseTemplateDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const destName = RENAME_ON_COPY[entry.name] ?? entry.name;
+    const src = join7(baseTemplateDir, entry.name);
+    const dest = join7(targetDir, destName);
+    if (entry.isDirectory()) {
+      mkdirSync2(dest, { recursive: true });
+      cpSync(src, dest, { recursive: true, force: options.force });
+    } else {
+      if (!options.force && existsSync6(dest)) {
+        log("yellow", `  skipped (exists): ${destName}`);
+        continue;
+      }
+      cpSync(src, dest);
+    }
+    log("cyan", `  ${destName}`);
+  }
+  if (options.chart) {
+    applyChartPreset(targetDir, options.chart);
+    log("cyan", `  chart preset: ${options.chart}`);
+  }
+  if (options.skipInstall) {
+    log("green", "\nProject initialized successfully!");
+    log("dim", "\nNext steps:");
+    log("dim", "  npm install");
+    log("dim", "  npm run dev");
+    return;
+  }
+  log("green", "\nInstalling dependencies...");
+  const install = spawnSync("npm", ["install"], {
+    cwd: targetDir,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  if (install.error || install.status !== 0) {
+    log("red", "\nDependency installation failed.");
+    log("yellow", "Run 'npm install' manually in the project directory.");
+    process.exit(1);
+  }
+  log("green", "\nProject initialized successfully!");
+  log("dim", "\nNext steps:");
+  log("dim", "  npm run dev");
+}
+
+// src/commands/list.ts
+var PREVIEW_BRANCH = "main";
+function previewUrls(templateName, source) {
+  const base = `https://raw.githubusercontent.com/squadbase/squadbase-templates/refs/heads/${PREVIEW_BRANCH}/vantage-template/${source}`;
+  return {
+    image: `${base}/${templateName}/preview-wide.png`,
+    imageSquare: `${base}/${templateName}/preview-square.png`
+  };
+}
+function listTemplates(options = {}) {
+  const source = "ui-templates";
+  const names = listTemplateNames(source);
+  const isJa = options.lang === "ja";
+  const filtered = names.filter((name) => isJa ? name.endsWith("-ja") : !name.endsWith("-ja"));
+  if (options.json) {
+    const items = [];
+    for (const name of filtered) {
+      try {
+        const manifest = loadManifest(name, source);
+        items.push({
+          name: manifest.name,
+          description: manifest.description,
+          ...previewUrls(name, source)
+        });
+      } catch {
+      }
+    }
+    console.log(JSON.stringify(items, null, 2));
+    return;
+  }
+  if (filtered.length === 0) {
+    log("yellow", "No UI templates available.");
+  } else {
+    log("green", "Available UI templates:");
+    for (const name of filtered) {
+      try {
+        const manifest = loadManifest(name, source);
+        const urls = previewUrls(name, source);
+        log("cyan", `  ${manifest.name} \u2014 ${manifest.description}`);
+        log("dim", `    image:       ${urls.image}`);
+        log("dim", `    imageSquare: ${urls.imageSquare}`);
+      } catch {
+        log("dim", `  ${name} (invalid manifest)`);
+      }
+    }
+  }
+  const presets = listChartPresetNames();
+  if (presets.length > 0) {
+    log("green", "\nAvailable chart presets:");
+    for (const name of presets) {
+      const description = getChartPresetDescription(name);
+      if (description) {
+        log("cyan", `  ${name} \u2014 ${description}`);
+      } else {
+        log("cyan", `  ${name}`);
+      }
+    }
+  }
+}
+
+// src/index.ts
+var HELP = `
+Usage: npx @squadbase/vantage-template <command> [options]
+
+Commands:
+  init                  Initialize a new Squadbase Vantage project
+  add <template-name>   Apply a UI template to the current project
+  chart <preset-name>   Switch the chart color preset
+  list                  List available templates and chart presets
+
+Options:
+  --force              Overwrite existing files
+  --dry-run            Show what would be done without making changes
+  --skip-install       Skip dependency installation after init
+  --chart <preset>     Apply a chart preset during init (e.g. --chart sunset)
+  --json               Output as JSON (for the list / add commands)
+  --lang <code>        Filter list by language (e.g. --lang ja)
+  --help               Show this help message
+
+AI customization (add only):
+  --prompt <text>      Customize the applied template with AI. Triggers AI mode.
+  --provider <name>    AI provider name (openai, anthropic, google, mistral, xai, groq, ...)
+  --model <id>         Model id. Defaults per provider (e.g. gpt-5.4-mini-2026-03-17, claude-sonnet-4-5).
+  --apiKey <key>       API key. Falls back to provider-specific env var if omitted.
+  --env-file <path>    Load env vars from a .env file before invoking AI (existing process.env wins).
+  --base-url <url>     Optional OpenAI-compatible endpoint.
+
+Examples:
+  npx @squadbase/vantage-template init
+  npx @squadbase/vantage-template list --lang ja
+  npx @squadbase/vantage-template add kpi-chart-simple \\
+    --prompt "SaaS MRR/ARR dashboard" --provider openai --apiKey $OPENAI_API_KEY
+  npx @squadbase/vantage-template add funnel --prompt "..." \\
+    --provider anthropic --apiKey $ANTHROPIC_API_KEY --dry-run
+`.trim();
+async function main() {
+  const { values, positionals } = parseArgs({
+    options: {
+      force: { type: "boolean", default: false },
+      "dry-run": { type: "boolean", default: false },
+      "skip-install": { type: "boolean", default: false },
+      chart: { type: "string" },
+      json: { type: "boolean", default: false },
+      lang: { type: "string" },
+      help: { type: "boolean", default: false },
+      prompt: { type: "string" },
+      provider: { type: "string" },
+      model: { type: "string" },
+      apiKey: { type: "string" },
+      "base-url": { type: "string" },
+      "env-file": { type: "string" }
+    },
+    allowPositionals: true,
+    strict: true
+  });
+  if (values.help || positionals.length === 0) {
+    console.log(HELP);
+    return;
+  }
+  const command = positionals[0];
+  if (command === "init") {
+    initProject({
+      force: values.force ?? false,
+      skipInstall: values["skip-install"] ?? false,
+      chart: values.chart
+    });
+  } else if (command === "list") {
+    listTemplates({
+      json: values.json ?? false,
+      lang: values.lang
+    });
+  } else if (command === "add") {
+    const templateName = positionals[1];
+    if (!templateName) {
+      log("red", "Missing template name.");
+      log("dim", "Usage: npx @squadbase/vantage-template add <template-name>");
+      process.exit(1);
+    }
+    const envFile = values["env-file"];
+    if (envFile !== void 0) {
+      if (!values.prompt) {
+        log("red", "--env-file requires --prompt (it only affects AI customization).");
+        process.exit(1);
+      }
+      if (typeof process.loadEnvFile !== "function") {
+        log("red", "--env-file requires Node.js 20.12.0 or later (process.loadEnvFile).");
+        log("dim", `Current version: ${process.version}`);
+        process.exit(1);
+      }
+      try {
+        process.loadEnvFile(envFile);
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        log("red", `Failed to load env file "${envFile}": ${reason}`);
+        process.exit(1);
+      }
+    }
+    const ai = values.prompt ? (() => {
+      if (!values.provider) {
+        log("red", "--prompt requires --provider (e.g. --provider openai).");
+        process.exit(1);
+      }
+      return {
+        prompt: values.prompt,
+        provider: values.provider,
+        model: values.model,
+        apiKey: values.apiKey,
+        baseUrl: values["base-url"],
+        dryRun: values["dry-run"] ?? false,
+        json: values.json ?? false
+      };
+    })() : void 0;
+    await addTemplate(templateName, {
+      force: values.force ?? false,
+      dryRun: values["dry-run"] ?? false,
+      source: "ui-templates",
+      ai
+    });
+  } else if (command === "chart") {
+    const presetName = positionals[1];
+    if (!presetName) {
+      log("red", "Missing chart preset name.");
+      log("dim", "Usage: npx @squadbase/vantage-template chart <preset-name>");
+      process.exit(1);
+    }
+    setChartPreset(presetName, {
+      dryRun: values["dry-run"] ?? false
+    });
+  } else {
+    log("red", `Unknown command: "${command}"`);
+    console.log(HELP);
+    process.exit(1);
+  }
+}
+main().catch((err) => {
+  log("red", err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});