shipfolio 1.0.0

package/dist/cli.js

@@ -0,0 +1,2027 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/scanner/git.ts
+import simpleGit from "simple-git";
+async function getGitMeta(projectPath) {
+  const git = simpleGit(projectPath);
+  const empty = {
+    isRepo: false,
+    firstCommitDate: null,
+    lastCommitDate: null,
+    totalCommits: 0,
+    remoteUrl: null,
+    lastCommitHash: null
+  };
+  try {
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) return empty;
+  } catch {
+    return empty;
+  }
+  try {
+    const log = await git.log({ maxCount: 1 });
+    let firstCommitDate = null;
+    try {
+      const firstResult = await git.raw(["log", "--reverse", "--format=%aI", "--max-count=1"]);
+      firstCommitDate = firstResult.trim() || null;
+    } catch {
+    }
+    let remoteUrl = null;
+    try {
+      const remotes = await git.getRemotes(true);
+      const origin = remotes.find((r) => r.name === "origin");
+      if (origin?.refs?.fetch) {
+        remoteUrl = normalizeGitUrl(origin.refs.fetch);
+      }
+    } catch {
+    }
+    let totalCommits = 0;
+    try {
+      const result = await git.raw(["rev-list", "--count", "HEAD"]);
+      totalCommits = parseInt(result.trim(), 10) || 0;
+    } catch {
+      totalCommits = 0;
+    }
+    return {
+      isRepo: true,
+      firstCommitDate,
+      lastCommitDate: log.latest?.date || null,
+      totalCommits,
+      remoteUrl,
+      lastCommitHash: log.latest?.hash || null
+    };
+  } catch {
+    return { ...empty, isRepo: true };
+  }
+}
+function normalizeGitUrl(url) {
+  if (url.startsWith("git@")) {
+    url = url.replace(":", "/").replace("git@", "https://");
+  }
+  if (url.endsWith(".git")) {
+    url = url.slice(0, -4);
+  }
+  return url;
+}
+async function findGitRepos(rootPath, maxDepth = 3) {
+  const { glob: glob2 } = await import("glob");
+  const gitDirs = await glob2("**/.git", {
+    cwd: rootPath,
+    maxDepth: maxDepth + 1,
+    dot: true,
+    ignore: [
+      "**/node_modules/**/.git",
+      "**/vendor/**/.git",
+      "**/__pycache__/**/.git"
+    ]
+  });
+  return gitDirs.map((gitDir) => {
+    const parts = gitDir.split("/");
+    parts.pop();
+    return parts.length > 0 ? `${rootPath}/${parts.join("/")}` : rootPath;
+  }).sort();
+}
+var init_git = __esm({
+  "src/scanner/git.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/utils/fs.ts
+import { readFile, writeFile, access, mkdir } from "fs/promises";
+import { join } from "path";
+async function fileExists(path2) {
+  try {
+    await access(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJson(path2) {
+  const content = await readFile(path2, "utf-8");
+  return JSON.parse(content);
+}
+async function writeJson(path2, data) {
+  await writeFile(path2, JSON.stringify(data, null, 2), "utf-8");
+}
+async function readText(path2) {
+  return readFile(path2, "utf-8");
+}
+async function writeText(path2, content) {
+  await writeFile(path2, content, "utf-8");
+}
+async function ensureDir(path2) {
+  await mkdir(path2, { recursive: true });
+}
+var init_fs = __esm({
+  "src/utils/fs.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/scanner/detectors/node.ts
+async function detectNode(projectPath) {
+  const pkgPath = join(projectPath, "package.json");
+  if (!await fileExists(pkgPath)) return null;
+  const pkg = await readJson(pkgPath);
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  const depNames = Object.keys(allDeps);
+  const techStack = [];
+  if (depNames.includes("next")) techStack.push("Next.js");
+  else if (depNames.includes("nuxt")) techStack.push("Nuxt");
+  else if (depNames.includes("astro")) techStack.push("Astro");
+  else if (depNames.includes("svelte") || depNames.includes("@sveltejs/kit"))
+    techStack.push("Svelte");
+  if (depNames.includes("react")) techStack.push("React");
+  if (depNames.includes("vue")) techStack.push("Vue");
+  if (depNames.includes("tailwindcss")) techStack.push("Tailwind CSS");
+  if (depNames.includes("express")) techStack.push("Express");
+  if (depNames.includes("fastify")) techStack.push("Fastify");
+  if (depNames.includes("hono")) techStack.push("Hono");
+  if (depNames.includes("prisma") || depNames.includes("@prisma/client"))
+    techStack.push("Prisma");
+  if (depNames.includes("drizzle-orm")) techStack.push("Drizzle");
+  if (depNames.includes("mongoose")) techStack.push("MongoDB");
+  if (depNames.includes("openai")) techStack.push("OpenAI");
+  if (depNames.includes("@anthropic-ai/sdk")) techStack.push("Claude API");
+  if (depNames.includes("langchain")) techStack.push("LangChain");
+  if (depNames.includes("typescript")) techStack.push("TypeScript");
+  else techStack.push("JavaScript");
+  return {
+    name: pkg.name || null,
+    description: pkg.description || null,
+    homepage: pkg.homepage || null,
+    techStack
+  };
+}
+var init_node = __esm({
+  "src/scanner/detectors/node.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_fs();
+  }
+});
+
+// src/scanner/detectors/python.ts
+async function detectPython(projectPath) {
+  const techStack = ["Python"];
+  const reqPath = join(projectPath, "requirements.txt");
+  const pyprojectPath = join(projectPath, "pyproject.toml");
+  const setupPath = join(projectPath, "setup.py");
+  let deps = "";
+  if (await fileExists(reqPath)) {
+    deps = await readText(reqPath);
+  } else if (await fileExists(pyprojectPath)) {
+    deps = await readText(pyprojectPath);
+  } else if (await fileExists(setupPath)) {
+    deps = await readText(setupPath);
+  } else {
+    return null;
+  }
+  const depsLower = deps.toLowerCase();
+  if (depsLower.includes("django")) techStack.push("Django");
+  if (depsLower.includes("flask")) techStack.push("Flask");
+  if (depsLower.includes("fastapi")) techStack.push("FastAPI");
+  if (depsLower.includes("pytorch") || depsLower.includes("torch"))
+    techStack.push("PyTorch");
+  if (depsLower.includes("tensorflow")) techStack.push("TensorFlow");
+  if (depsLower.includes("transformers")) techStack.push("Transformers");
+  if (depsLower.includes("langchain")) techStack.push("LangChain");
+  if (depsLower.includes("openai")) techStack.push("OpenAI");
+  if (depsLower.includes("pandas")) techStack.push("Pandas");
+  if (depsLower.includes("numpy")) techStack.push("NumPy");
+  if (depsLower.includes("scikit")) techStack.push("Scikit-learn");
+  return { techStack };
+}
+var init_python = __esm({
+  "src/scanner/detectors/python.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_fs();
+  }
+});
+
+// src/scanner/detectors/rust.ts
+async function detectRust(projectPath) {
+  const cargoPath = join(projectPath, "Cargo.toml");
+  if (!await fileExists(cargoPath)) return null;
+  const content = await readText(cargoPath);
+  const techStack = ["Rust"];
+  if (content.includes("actix")) techStack.push("Actix");
+  if (content.includes("axum")) techStack.push("Axum");
+  if (content.includes("tokio")) techStack.push("Tokio");
+  if (content.includes("wasm")) techStack.push("WebAssembly");
+  if (content.includes("tauri")) techStack.push("Tauri");
+  if (content.includes("diesel")) techStack.push("Diesel");
+  if (content.includes("sqlx")) techStack.push("SQLx");
+  const nameMatch = content.match(/\[package\][\s\S]*?name\s*=\s*"([^"]+)"/);
+  const descMatch = content.match(
+    /\[package\][\s\S]*?description\s*=\s*"([^"]+)"/
+  );
+  return {
+    name: nameMatch?.[1] || null,
+    description: descMatch?.[1] || null,
+    techStack
+  };
+}
+var init_rust = __esm({
+  "src/scanner/detectors/rust.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_fs();
+  }
+});
+
+// src/scanner/detectors/go.ts
+async function detectGo(projectPath) {
+  const goModPath = join(projectPath, "go.mod");
+  if (!await fileExists(goModPath)) return null;
+  const content = await readText(goModPath);
+  const techStack = ["Go"];
+  if (content.includes("gin-gonic")) techStack.push("Gin");
+  if (content.includes("echo")) techStack.push("Echo");
+  if (content.includes("fiber")) techStack.push("Fiber");
+  if (content.includes("grpc")) techStack.push("gRPC");
+  if (content.includes("gorm")) techStack.push("GORM");
+  if (content.includes("cobra")) techStack.push("Cobra");
+  if (content.includes("ent")) techStack.push("Ent");
+  return { techStack };
+}
+var init_go = __esm({
+  "src/scanner/detectors/go.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_fs();
+  }
+});
+
+// src/scanner/detectors/generic.ts
+import { glob } from "glob";
+import { basename, extname } from "path";
+async function detectLanguages(projectPath) {
+  const ignorePattern = IGNORE_DIRS.map((d) => `**/${d}/**`);
+  const files = await glob("**/*.*", {
+    cwd: projectPath,
+    ignore: ignorePattern,
+    nodir: true,
+    maxDepth: 5
+  });
+  const counts = {};
+  for (const file of files) {
+    const ext = extname(file).toLowerCase();
+    const lang = EXTENSION_MAP[ext];
+    if (lang) {
+      counts[lang] = (counts[lang] || 0) + 1;
+    }
+  }
+  return counts;
+}
+function deriveNameFromPath(projectPath) {
+  return basename(projectPath);
+}
+var EXTENSION_MAP, IGNORE_DIRS;
+var init_generic = __esm({
+  "src/scanner/detectors/generic.ts"() {
+    "use strict";
+    init_esm_shims();
+    EXTENSION_MAP = {
+      ".ts": "TypeScript",
+      ".tsx": "TypeScript",
+      ".js": "JavaScript",
+      ".jsx": "JavaScript",
+      ".py": "Python",
+      ".rs": "Rust",
+      ".go": "Go",
+      ".java": "Java",
+      ".kt": "Kotlin",
+      ".swift": "Swift",
+      ".rb": "Ruby",
+      ".php": "PHP",
+      ".cs": "C#",
+      ".cpp": "C++",
+      ".c": "C",
+      ".dart": "Dart",
+      ".lua": "Lua",
+      ".zig": "Zig",
+      ".sol": "Solidity",
+      ".ex": "Elixir",
+      ".exs": "Elixir"
+    };
+    IGNORE_DIRS = [
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      "out",
+      ".next",
+      "target",
+      "vendor",
+      "__pycache__",
+      ".venv",
+      "venv"
+    ];
+  }
+});
+
+// src/scanner/extractors.ts
+async function extractReadme(projectPath) {
+  const candidates = [
+    "README.md",
+    "readme.md",
+    "Readme.md",
+    "README.txt",
+    "README"
+  ];
+  for (const name of candidates) {
+    const p6 = join(projectPath, name);
+    if (await fileExists(p6)) {
+      const content = await readText(p6);
+      return content.slice(0, 3e3);
+    }
+  }
+  return null;
+}
+function extractFirstParagraph(readme) {
+  if (!readme) return null;
+  const lines = readme.split("\n");
+  let collecting = false;
+  const paragraphLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#")) {
+      if (collecting && paragraphLines.length > 0) break;
+      collecting = true;
+      continue;
+    }
+    if (collecting && trimmed === "" && paragraphLines.length > 0) break;
+    if (collecting && trimmed !== "") {
+      paragraphLines.push(trimmed);
+    }
+    if (!collecting && trimmed !== "" && !trimmed.startsWith("[")) {
+      paragraphLines.push(trimmed);
+      collecting = true;
+    }
+  }
+  return paragraphLines.length > 0 ? paragraphLines.join(" ") : null;
+}
+function extractDemoUrl(readme) {
+  if (!readme) return null;
+  const patterns = [
+    /(?:demo|live|website|site|url|link)[\s:]*\[?[^\]]*\]?\(?(https?:\/\/[^\s)]+)/i,
+    /\[(?:demo|live|website|try it)\]\((https?:\/\/[^\s)]+)\)/i,
+    /(https?:\/\/[^\s)]+\.(?:vercel|netlify|pages\.dev|herokuapp|railway)\.app[^\s)]*)/i
+  ];
+  for (const pattern of patterns) {
+    const match = readme.match(pattern);
+    if (match?.[1]) return match[1];
+  }
+  return null;
+}
+var init_extractors = __esm({
+  "src/scanner/extractors.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_fs();
+  }
+});
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    logger = {
+      info(msg) {
+        console.log(chalk.cyan(`-- ${msg}`));
+      },
+      success(msg) {
+        console.log(chalk.green(`-- ${msg}`));
+      },
+      warn(msg) {
+        console.log(chalk.yellow(`-- ${msg}`));
+      },
+      error(msg) {
+        console.error(chalk.red(`-- ${msg}`));
+      },
+      plain(msg) {
+        console.log(msg);
+      },
+      blank() {
+        console.log();
+      },
+      header(msg) {
+        console.log();
+        console.log(chalk.bold(msg));
+        console.log();
+      },
+      table(rows) {
+        if (rows.length === 0) return;
+        const colWidths = rows[0].map(
+          (_, colIdx) => Math.max(...rows.map((row) => (row[colIdx] || "").length))
+        );
+        for (const row of rows) {
+          const line = row.map((cell, i) => (cell || "").padEnd(colWidths[i] + 2)).join("");
+          console.log(`  ${line}`);
+        }
+      }
+    };
+  }
+});
+
+// src/scanner/index.ts
+import ora from "ora";
+async function scanProjects(directories) {
+  const allRepos = [];
+  const spinner = ora("Scanning for projects...").start();
+  for (const dir of directories) {
+    try {
+      const repos = await findGitRepos(dir);
+      allRepos.push(...repos);
+    } catch (err) {
+      logger.warn(`Could not scan ${dir}: ${err}`);
+    }
+  }
+  const uniqueRepos = [...new Set(allRepos)];
+  spinner.text = `Found ${uniqueRepos.length} repositories. Extracting metadata...`;
+  const projects = [];
+  for (const repoPath of uniqueRepos) {
+    try {
+      const project = await extractProjectMeta(repoPath);
+      if (project) {
+        projects.push(project);
+      }
+    } catch (err) {
+    }
+  }
+  spinner.succeed(`Scanned ${projects.length} projects`);
+  return projects;
+}
+async function extractProjectMeta(projectPath) {
+  const gitMeta = await getGitMeta(projectPath);
+  if (!gitMeta.isRepo) return null;
+  let techStack = [];
+  let name = null;
+  let description = null;
+  let homepage = null;
+  const nodeInfo = await detectNode(projectPath);
+  if (nodeInfo) {
+    techStack.push(...nodeInfo.techStack);
+    name = nodeInfo.name || name;
+    description = nodeInfo.description || description;
+    homepage = nodeInfo.homepage || homepage;
+  }
+  const pythonInfo = await detectPython(projectPath);
+  if (pythonInfo) {
+    techStack.push(...pythonInfo.techStack);
+  }
+  const rustInfo = await detectRust(projectPath);
+  if (rustInfo) {
+    techStack.push(...rustInfo.techStack);
+    name = rustInfo.name || name;
+    description = rustInfo.description || description;
+  }
+  const goInfo = await detectGo(projectPath);
+  if (goInfo) {
+    techStack.push(...goInfo.techStack);
+  }
+  techStack = [...new Set(techStack)];
+  const languages = await detectLanguages(projectPath);
+  if (techStack.length === 0) {
+    const topLangs = Object.entries(languages).sort((a, b) => b[1] - a[1]).slice(0, 3).map(([lang]) => lang);
+    techStack = topLangs;
+  }
+  const readmeContent = await extractReadme(projectPath);
+  if (!description) {
+    description = extractFirstParagraph(readmeContent) || "";
+  }
+  const demoUrl = homepage || extractDemoUrl(readmeContent);
+  if (!name) {
+    name = deriveNameFromPath(projectPath);
+  }
+  const id = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return {
+    id,
+    name,
+    localPath: projectPath,
+    description: description || "",
+    techStack,
+    languages,
+    firstCommitDate: gitMeta.firstCommitDate || "",
+    lastCommitDate: gitMeta.lastCommitDate || "",
+    totalCommits: gitMeta.totalCommits,
+    remoteUrl: gitMeta.remoteUrl,
+    demoUrl,
+    readmeContent,
+    lastScannedCommit: gitMeta.lastCommitHash || ""
+  };
+}
+var init_scanner = __esm({
+  "src/scanner/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_git();
+    init_node();
+    init_python();
+    init_rust();
+    init_go();
+    init_generic();
+    init_extractors();
+    init_logger();
+  }
+});
+
+// src/interviewer/questions.ts
+var THEME_OPTIONS, FONT_OPTIONS, ANIMATION_OPTIONS, SECTION_OPTIONS, ENGINE_OPTIONS, DEPLOY_OPTIONS, ROLE_OPTIONS, DEFAULT_ACCENT_COLORS;
+var init_questions = __esm({
+  "src/interviewer/questions.ts"() {
+    "use strict";
+    init_esm_shims();
+    THEME_OPTIONS = [
+      { value: "dark-minimal", label: "Dark Minimal" },
+      { value: "light-clean", label: "Light Clean" },
+      { value: "monochrome", label: "Monochrome" },
+      { value: "custom", label: "Custom (AI decides)" }
+    ];
+    FONT_OPTIONS = [
+      { value: "Inter", label: "Inter" },
+      { value: "JetBrains Mono", label: "JetBrains Mono" },
+      { value: "system", label: "System Default" }
+    ];
+    ANIMATION_OPTIONS = [
+      { value: "subtle", label: "Subtle" },
+      { value: "moderate", label: "Moderate" },
+      { value: "none", label: "None" }
+    ];
+    SECTION_OPTIONS = [
+      { value: "skills", label: "Skills / Tech Stack" },
+      { value: "about", label: "About Me" },
+      { value: "timeline", label: "Timeline / Changelog" },
+      { value: "blog", label: "Blog" },
+      { value: "metrics", label: "Metrics Dashboard" },
+      { value: "contact", label: "Contact" }
+    ];
+    ENGINE_OPTIONS = [
+      { value: "claude", label: "Claude Code" },
+      { value: "codex", label: "Codex" },
+      { value: "v0", label: "v0 (Vercel)" }
+    ];
+    DEPLOY_OPTIONS = [
+      { value: "cloudflare", label: "Cloudflare Pages" },
+      { value: "vercel", label: "Vercel" },
+      { value: "local", label: "Local only (no deploy)" }
+    ];
+    ROLE_OPTIONS = [
+      { value: "solo", label: "Solo" },
+      { value: "lead", label: "Lead" },
+      { value: "contributor", label: "Contributor" }
+    ];
+    DEFAULT_ACCENT_COLORS = [
+      { value: "#7c3aed", label: "Purple" },
+      { value: "#10b981", label: "Green" },
+      { value: "#f97316", label: "Orange" },
+      { value: "#3b82f6", label: "Blue" },
+      { value: "#ef4444", label: "Red" },
+      { value: "#ec4899", label: "Pink" }
+    ];
+  }
+});
+
+// src/interviewer/index.ts
+import * as p from "@clack/prompts";
+function handleCancel(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+}
+async function runInterview(scannedProjects, availableEngines) {
+  p.intro("shipfolio");
+  logger.header("Project Selection");
+  const projectOptions = scannedProjects.map((proj) => ({
+    value: proj.id,
+    label: `${proj.name}`,
+    hint: `${proj.techStack.slice(0, 3).join(", ")} | ${proj.totalCommits} commits`
+  }));
+  const selectedIds = await p.multiselect({
+    message: "Select projects to include:",
+    options: projectOptions,
+    required: true
+  });
+  handleCancel(selectedIds);
+  const projectEntries = [];
+  for (const id of selectedIds) {
+    const meta = scannedProjects.find((p6) => p6.id === id);
+    logger.plain(`
+  Configuring: ${meta.name}`);
+    const overrideDesc = await p.text({
+      message: `Description for ${meta.name} (enter to use auto-generated):`,
+      placeholder: meta.description?.slice(0, 80) || "Auto-generate from README",
+      defaultValue: ""
+    });
+    handleCancel(overrideDesc);
+    const demoUrl = await p.text({
+      message: `Demo URL for ${meta.name}:`,
+      placeholder: meta.demoUrl || "none",
+      defaultValue: meta.demoUrl || ""
+    });
+    handleCancel(demoUrl);
+    const showSource = await p.confirm({
+      message: `Show source code link for ${meta.name}?`,
+      initialValue: !!meta.remoteUrl
+    });
+    handleCancel(showSource);
+    const role = await p.select({
+      message: `Your role in ${meta.name}:`,
+      options: ROLE_OPTIONS
+    });
+    handleCancel(role);
+    const metricsInput = await p.text({
+      message: `Key metrics for ${meta.name} (e.g. "1k users, $5k MRR"):`,
+      placeholder: "optional",
+      defaultValue: ""
+    });
+    handleCancel(metricsInput);
+    const metrics = {};
+    if (metricsInput) {
+      metrics.custom = { summary: metricsInput };
+    }
+    projectEntries.push({
+      ...meta,
+      included: true,
+      overrideDescription: overrideDesc || null,
+      showSourceLink: showSource,
+      demoUrl: demoUrl || meta.demoUrl,
+      role,
+      metrics
+    });
+  }
+  logger.header("Personal Information");
+  const name = await p.text({
+    message: "Your full name:",
+    validate: (v) => v.length === 0 ? "Name is required" : void 0
+  });
+  handleCancel(name);
+  const tagline = await p.text({
+    message: "Professional tagline (one line):",
+    placeholder: "Full-stack developer. I ship things."
+  });
+  handleCancel(tagline);
+  const bioChoice = await p.select({
+    message: "Bio:",
+    options: [
+      { value: "auto", label: "Auto-generate from my projects" },
+      { value: "manual", label: "Write manually" }
+    ]
+  });
+  handleCancel(bioChoice);
+  let bio = "auto";
+  if (bioChoice === "manual") {
+    bio = await p.text({
+      message: "Your bio (2-3 sentences):"
+    });
+    handleCancel(bio);
+  }
+  const photoUrl = await p.text({
+    message: "Photo URL (optional):",
+    placeholder: "https://...",
+    defaultValue: ""
+  });
+  handleCancel(photoUrl);
+  const github = await p.text({
+    message: "GitHub username or URL:",
+    defaultValue: ""
+  });
+  handleCancel(github);
+  const twitter = await p.text({
+    message: "Twitter/X handle:",
+    defaultValue: ""
+  });
+  handleCancel(twitter);
+  const linkedin = await p.text({
+    message: "LinkedIn URL:",
+    defaultValue: ""
+  });
+  handleCancel(linkedin);
+  const blogUrl = await p.text({
+    message: "Blog URL:",
+    defaultValue: ""
+  });
+  handleCancel(blogUrl);
+  const email = await p.text({
+    message: "Contact email:",
+    defaultValue: ""
+  });
+  handleCancel(email);
+  const owner = {
+    name,
+    tagline,
+    bio,
+    photoUrl: photoUrl || null,
+    social: {
+      github: github || void 0,
+      twitter: twitter || void 0,
+      linkedin: linkedin || void 0,
+      blog: blogUrl || void 0,
+      email: email || void 0
+    }
+  };
+  logger.header("Design Preferences");
+  const theme = await p.select({
+    message: "Theme:",
+    options: THEME_OPTIONS
+  });
+  handleCancel(theme);
+  const accentColor = await p.select({
+    message: "Accent color:",
+    options: [
+      ...DEFAULT_ACCENT_COLORS,
+      { value: "custom", label: "Custom hex" }
+    ]
+  });
+  handleCancel(accentColor);
+  let finalAccent = accentColor;
+  if (accentColor === "custom") {
+    finalAccent = await p.text({
+      message: "Custom accent color (hex):",
+      placeholder: "#7c3aed",
+      validate: (v) => /^#[0-9a-fA-F]{6}$/.test(v) ? void 0 : "Enter a valid hex color"
+    });
+    handleCancel(finalAccent);
+  }
+  const font = await p.select({
+    message: "Font:",
+    options: FONT_OPTIONS
+  });
+  handleCancel(font);
+  const animationLevel = await p.select({
+    message: "Animation level:",
+    options: ANIMATION_OPTIONS
+  });
+  handleCancel(animationLevel);
+  const style = {
+    theme,
+    accentColor: finalAccent,
+    font,
+    animationLevel
+  };
+  logger.header("Sections");
+  const additionalSections = await p.multiselect({
+    message: "Additional sections (Hero + Projects always included):",
+    options: SECTION_OPTIONS,
+    required: false
+  });
+  handleCancel(additionalSections);
+  const sections = [
+    "hero",
+    "projects",
+    ...additionalSections
+  ];
+  logger.header("AI Engine");
+  let engine;
+  if (availableEngines.length === 1) {
+    engine = availableEngines[0];
+    logger.info(`Using ${engine}`);
+  } else {
+    const filteredEngineOptions = ENGINE_OPTIONS.filter(
+      (o) => availableEngines.includes(o.value)
+    );
+    engine = await p.select({
+      message: "AI engine to use:",
+      options: filteredEngineOptions
+    });
+    handleCancel(engine);
+  }
+  logger.header("Deployment");
+  const deployPlatform = await p.select({
+    message: "Deploy to:",
+    options: DEPLOY_OPTIONS
+  });
+  handleCancel(deployPlatform);
+  let projectName = "";
+  if (deployPlatform !== "local") {
+    projectName = await p.text({
+      message: "Project name (used in URL):",
+      placeholder: "my-shipfolio",
+      validate: (v) => /^[a-z0-9-]+$/.test(v) ? void 0 : "Lowercase letters, numbers, and hyphens only"
+    });
+    handleCancel(projectName);
+  }
+  p.outro("Configuration complete. Generating your site...");
+  return {
+    projects: projectEntries,
+    owner,
+    style,
+    sections,
+    engine,
+    deploy: {
+      platform: deployPlatform,
+      projectName
+    }
+  };
+}
+var init_interviewer = __esm({
+  "src/interviewer/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_questions();
+    init_logger();
+  }
+});
+
+// src/spec/builder.ts
+function buildSpec(interview) {
+  return {
+    version: "1.0.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    engine: interview.engine,
+    framework: "next",
+    style: interview.style,
+    owner: interview.owner,
+    projects: interview.projects,
+    sections: interview.sections,
+    deploy: {
+      platform: interview.deploy.platform,
+      projectName: interview.deploy.projectName
+    }
+  };
+}
+var init_builder = __esm({
+  "src/spec/builder.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/orchestrator/prompt-builder.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2, dirname } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function getPromptsDir() {
+  const currentDir = dirname(fileURLToPath2(import.meta.url));
+  const candidates = [
+    join2(currentDir, "../../prompts"),
+    join2(currentDir, "../prompts"),
+    join2(currentDir, "../../../prompts")
+  ];
+  return candidates[0];
+}
+async function loadTemplate(filename) {
+  const promptsDir = getPromptsDir();
+  const candidates = [
+    join2(promptsDir, filename),
+    join2(dirname(fileURLToPath2(import.meta.url)), "../../prompts", filename),
+    join2(dirname(fileURLToPath2(import.meta.url)), "../../../prompts", filename)
+  ];
+  for (const candidate of candidates) {
+    try {
+      return await readFile2(candidate, "utf-8");
+    } catch {
+      continue;
+    }
+  }
+  throw new Error(`Prompt template not found: ${filename}`);
+}
+async function buildFreshPrompt(spec) {
+  let template = await loadTemplate("fresh-build.md");
+  const sectionsText = spec.sections.map((s) => `- ${s}`).join("\n");
+  template = template.replace("{{SPEC_JSON}}", JSON.stringify(spec, null, 2)).replace("{{THEME}}", spec.style.theme).replace("{{ACCENT_COLOR}}", spec.style.accentColor).replace("{{ANIMATION_LEVEL}}", spec.style.animationLevel).replace("{{FONT}}", spec.style.font).replace("{{SECTIONS_LIST}}", sectionsText);
+  return template;
+}
+async function buildUpdatePrompt(existingConfig, diff) {
+  let template = await loadTemplate("update.md");
+  const newProjectsText = diff.newProjects.length > 0 ? diff.newProjects.map(
+    (p6) => `- ${p6.name}: ${p6.description}
+  Tech: ${p6.techStack.join(", ")}
+  README excerpt: ${(p6.readmeContent || "").slice(0, 500)}`
+  ).join("\n\n") : "None";
+  const updatedProjectsText = diff.updatedProjects.length > 0 ? diff.updatedProjects.map(
+    (u) => `- ${u.project.name}: ${u.newCommits} new commits
+  README changed: ${u.readmeChanged}
+  Dependencies changed: ${u.depsChanged}`
+  ).join("\n\n") : "None";
+  const removedProjectsText = diff.removedProjects.length > 0 ? diff.removedProjects.map((p6) => `- ${p6.name}`).join("\n") : "None";
+  template = template.replace(
+    "{{EXISTING_CONFIG_JSON}}",
+    JSON.stringify(existingConfig, null, 2)
+  ).replace("{{NEW_PROJECTS}}", newProjectsText).replace("{{UPDATED_PROJECTS}}", updatedProjectsText).replace("{{REMOVED_PROJECTS}}", removedProjectsText).replace("{{PERSONAL_INFO_DIFF}}", "No changes");
+  return template;
+}
+var init_prompt_builder = __esm({
+  "src/orchestrator/prompt-builder.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/utils/exec.ts
+import { execa } from "execa";
+async function run(command, args, options) {
+  return execa(command, args, {
+    stdio: "pipe",
+    ...options
+  });
+}
+async function commandExists(command) {
+  try {
+    await execa("which", [command]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runWithOutput(command, args, options) {
+  const result = await execa(command, args, {
+    stdio: "pipe",
+    ...options
+  });
+  return result.stdout;
+}
+var init_exec = __esm({
+  "src/utils/exec.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/orchestrator/detect.ts
+async function detectEngines() {
+  const results = [];
+  if (process.env.V0_API_KEY) {
+    results.push({ type: "v0", available: true });
+  }
+  if (await commandExists("claude")) {
+    results.push({ type: "claude", available: true });
+  }
+  if (await commandExists("codex")) {
+    results.push({ type: "codex", available: true });
+  }
+  return results;
+}
+function getAvailableEngineTypes(engines) {
+  return engines.filter((e) => e.available).map((e) => e.type);
+}
+var init_detect = __esm({
+  "src/orchestrator/detect.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_exec();
+  }
+});
+
+// src/orchestrator/engines/claude.ts
+import { execa as execa2 } from "execa";
+import ora2 from "ora";
+async function generateWithClaude(prompt, outputDir) {
+  const spinner = ora2("Generating site with Claude Code...").start();
+  try {
+    const fullPrompt = `${prompt}
+
+Create all files in the current working directory. Do not ask questions, just generate all files.`;
+    await execa2("claude", ["-p", fullPrompt], {
+      cwd: outputDir,
+      stdio: "pipe",
+      timeout: 3e5
+      // 5 minute timeout
+    });
+    spinner.succeed("Site generated with Claude Code");
+  } catch (error) {
+    spinner.fail("Claude Code generation failed");
+    throw error;
+  }
+}
+var init_claude = __esm({
+  "src/orchestrator/engines/claude.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/orchestrator/engines/codex.ts
+import { execa as execa3 } from "execa";
+import ora3 from "ora";
+async function generateWithCodex(prompt, outputDir) {
+  const spinner = ora3("Generating site with Codex...").start();
+  try {
+    const fullPrompt = `${prompt}
+
+Create all files in the current working directory. Do not ask questions, just generate all files.`;
+    await execa3("codex", ["--quiet", "--full-auto", fullPrompt], {
+      cwd: outputDir,
+      stdio: "pipe",
+      timeout: 3e5
+    });
+    spinner.succeed("Site generated with Codex");
+  } catch (error) {
+    spinner.fail("Codex generation failed");
+    throw error;
+  }
+}
+var init_codex = __esm({
+  "src/orchestrator/engines/codex.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/orchestrator/engines/v0.ts
+import OpenAI from "openai";
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join3, dirname as dirname2 } from "path";
+import ora4 from "ora";
+async function generateWithV0(prompt, outputDir, apiKey) {
+  const spinner = ora4("Generating site with v0...").start();
+  const client = new OpenAI({
+    apiKey,
+    baseURL: "https://api.v0.dev/v1"
+  });
+  try {
+    const response = await client.chat.completions.create({
+      model: "v0-1.0-md",
+      messages: [
+        {
+          role: "system",
+          content: "Generate a complete Next.js 15 portfolio website using TypeScript, Tailwind CSS, and shadcn/ui. Return all files with their paths clearly marked. Use ```tsx filename.tsx or ```ts filename.ts code blocks with the filename on the same line as the opening backticks. No emoji in any output."
+        },
+        {
+          role: "user",
+          content: prompt
+        }
+      ]
+    });
+    const content = response.choices[0]?.message?.content;
+    if (!content) {
+      throw new Error("v0 returned empty response");
+    }
+    spinner.text = "Parsing v0 output...";
+    const files = extractFiles(content);
+    if (files.length === 0) {
+      throw new Error("No files extracted from v0 response");
+    }
+    spinner.text = `Writing ${files.length} files...`;
+    for (const file of files) {
+      const filePath = join3(outputDir, file.filename);
+      await mkdir2(dirname2(filePath), { recursive: true });
+      await writeFile2(filePath, file.content, "utf-8");
+    }
+    const hasPkgJson = files.some((f) => f.filename === "package.json");
+    if (!hasPkgJson) {
+      await writeFile2(
+        join3(outputDir, "package.json"),
+        JSON.stringify(
+          {
+            name: "shipfolio-site",
+            version: "1.0.0",
+            private: true,
+            scripts: {
+              dev: "next dev",
+              build: "next build",
+              start: "next start"
+            },
+            dependencies: {
+              next: "^15.0.0",
+              react: "^19.0.0",
+              "react-dom": "^19.0.0",
+              "class-variance-authority": "^0.7.0",
+              clsx: "^2.1.0",
+              "tailwind-merge": "^2.6.0",
+              "lucide-react": "^0.460.0"
+            },
+            devDependencies: {
+              typescript: "^5.7.0",
+              "@types/node": "^22.0.0",
+              "@types/react": "^19.0.0",
+              "@types/react-dom": "^19.0.0",
+              tailwindcss: "^4.0.0",
+              "@tailwindcss/postcss": "^4.0.0"
+            }
+          },
+          null,
+          2
+        ),
+        "utf-8"
+      );
+    }
+    spinner.succeed(`Site generated with v0 (${files.length} files)`);
+  } catch (error) {
+    spinner.fail("v0 generation failed");
+    throw error;
+  }
+}
+function extractFiles(content) {
+  const files = [];
+  const patterns = [
+    // ```tsx src/app/page.tsx
+    /```(?:tsx?|jsx?|css|json|mjs|cjs)\s+([^\n`]+)\n([\s\S]*?)```/g,
+    // ```tsx filename="src/app/page.tsx"
+    /```(?:tsx?|jsx?|css|json|mjs|cjs)\s+filename="([^"]+)"\n([\s\S]*?)```/g,
+    // ```tsx {filename: "src/app/page.tsx"}
+    /```(?:tsx?|jsx?|css|json|mjs|cjs).*?filename:\s*"([^"]+)".*?\n([\s\S]*?)```/g
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const filename = match[1].trim();
+      const fileContent = match[2].trim();
+      if (filename.includes(" ") && !filename.includes("/") && !filename.includes(".")) {
+        continue;
+      }
+      const cleanFilename = filename.replace(/^["']|["']$/g, "").replace(/^\.\//g, "");
+      if (cleanFilename && fileContent) {
+        files.push({ filename: cleanFilename, content: fileContent });
+      }
+    }
+  }
+  return files;
+}
+var init_v0 = __esm({
+  "src/orchestrator/engines/v0.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/orchestrator/validator.ts
+async function validateGeneratedSite(siteDir) {
+  const errors = [];
+  const requiredFiles = [
+    "package.json",
+    "next.config.ts",
+    "src/app/layout.tsx",
+    "src/app/page.tsx"
+  ];
+  const alternativeChecks = [
+    ["next.config.ts", ["next.config.ts", "next.config.js", "next.config.mjs"]]
+  ];
+  for (const file of requiredFiles) {
+    const alternatives = alternativeChecks.find(([key]) => key === file);
+    if (alternatives) {
+      const anyExists = await Promise.any(
+        alternatives[1].map(async (alt) => {
+          if (await fileExists(join(siteDir, alt))) return true;
+          throw new Error("not found");
+        })
+      ).catch(() => false);
+      if (!anyExists) {
+        errors.push(`Missing: ${file} (or any alternative)`);
+      }
+    } else {
+      if (!await fileExists(join(siteDir, file))) {
+        errors.push(`Missing: ${file}`);
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+async function validateBuildOutput(siteDir) {
+  const errors = [];
+  const outDir = join(siteDir, "out");
+  if (!await fileExists(outDir)) {
+    errors.push("Build output directory 'out/' not found");
+    return { valid: false, errors };
+  }
+  const indexHtml = join(outDir, "index.html");
+  if (!await fileExists(indexHtml)) {
+    errors.push("Missing: out/index.html");
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+var init_validator = __esm({
+  "src/orchestrator/validator.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_fs();
+  }
+});
+
+// src/orchestrator/index.ts
+import ora5 from "ora";
+async function generateSite(engine, prompt, outputDir) {
+  await ensureDir(outputDir);
+  switch (engine) {
+    case "claude":
+      await generateWithClaude(prompt, outputDir);
+      break;
+    case "codex":
+      await generateWithCodex(prompt, outputDir);
+      break;
+    case "v0": {
+      const apiKey = process.env.V0_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          "V0_API_KEY environment variable is required for v0 engine"
+        );
+      }
+      await generateWithV0(prompt, outputDir, apiKey);
+      break;
+    }
+  }
+  const validation = await validateGeneratedSite(outputDir);
+  if (!validation.valid) {
+    logger.warn("Generated site has issues:");
+    for (const err of validation.errors) {
+      logger.warn(`  ${err}`);
+    }
+  }
+}
+async function buildSite(siteDir) {
+  const spinner = ora5("Installing dependencies...").start();
+  try {
+    await run("npm", ["install"], { cwd: siteDir });
+    spinner.text = "Building site...";
+    await run("npm", ["run", "build"], { cwd: siteDir });
+    spinner.succeed("Site built successfully");
+  } catch (error) {
+    spinner.fail("Build failed");
+    logger.error(error.stderr || error.message || String(error));
+    return false;
+  }
+  const validation = await validateBuildOutput(siteDir);
+  if (!validation.valid) {
+    logger.error("Build output validation failed:");
+    for (const err of validation.errors) {
+      logger.error(`  ${err}`);
+    }
+    return false;
+  }
+  return true;
+}
+var init_orchestrator = __esm({
+  "src/orchestrator/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_claude();
+    init_codex();
+    init_v0();
+    init_validator();
+    init_fs();
+    init_exec();
+    init_logger();
+  }
+});
+
+// src/deployer/auth.ts
+async function checkAuth(platform) {
+  if (platform === "local") return true;
+  try {
+    if (platform === "cloudflare") {
+      await runWithOutput("npx", ["wrangler", "whoami"]);
+      return true;
+    }
+    if (platform === "vercel") {
+      await runWithOutput("npx", ["vercel", "whoami"]);
+      return true;
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+async function login(platform) {
+  if (platform === "cloudflare") {
+    logger.info("Opening Cloudflare login in browser...");
+    await run("npx", ["wrangler", "login"], { stdio: "inherit" });
+  } else if (platform === "vercel") {
+    logger.info("Opening Vercel login in browser...");
+    await run("npx", ["vercel", "login"], { stdio: "inherit" });
+  }
+}
+async function ensureAuth(platform) {
+  if (platform === "local") return;
+  const isAuthed = await checkAuth(platform);
+  if (!isAuthed) {
+    await login(platform);
+    const nowAuthed = await checkAuth(platform);
+    if (!nowAuthed) {
+      throw new Error(`Authentication failed for ${platform}`);
+    }
+  }
+}
+var init_auth = __esm({
+  "src/deployer/auth.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_exec();
+    init_logger();
+  }
+});
+
+// src/deployer/cloudflare.ts
+import ora6 from "ora";
+async function deployToCloudflare(distDir, projectName) {
+  const spinner = ora6("Deploying to Cloudflare Pages...").start();
+  try {
+    const output = await runWithOutput("npx", [
+      "wrangler",
+      "pages",
+      "deploy",
+      distDir,
+      `--project-name=${projectName}`
+    ]);
+    const urlMatch = output.match(
+      /https:\/\/[^\s]+\.pages\.dev/
+    );
+    const url = urlMatch?.[0] || `https://${projectName}.pages.dev`;
+    spinner.succeed(`Deployed to Cloudflare Pages`);
+    logger.info(`URL: ${url}`);
+    return url;
+  } catch (error) {
+    spinner.fail("Cloudflare Pages deployment failed");
+    throw error;
+  }
+}
+var init_cloudflare = __esm({
+  "src/deployer/cloudflare.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_exec();
+    init_logger();
+  }
+});
+
+// src/deployer/vercel.ts
+import ora7 from "ora";
+async function deployToVercel(distDir) {
+  const spinner = ora7("Deploying to Vercel...").start();
+  try {
+    const output = await runWithOutput("npx", [
+      "vercel",
+      "deploy",
+      distDir,
+      "--yes",
+      "--prod"
+    ]);
+    const urlMatch = output.match(
+      /https:\/\/[^\s]+\.vercel\.app/
+    );
+    const url = urlMatch?.[0] || output.trim().split("\n").pop() || "";
+    spinner.succeed("Deployed to Vercel");
+    logger.info(`URL: ${url}`);
+    return url;
+  } catch (error) {
+    spinner.fail("Vercel deployment failed");
+    throw error;
+  }
+}
+var init_vercel = __esm({
+  "src/deployer/vercel.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_exec();
+    init_logger();
+  }
+});
+
+// src/deployer/github.ts
+import * as p2 from "@clack/prompts";
+async function setupGitHubAutoDeploy(siteDir, projectName) {
+  const hasGh = await commandExists("gh");
+  if (!hasGh) {
+    logger.info(
+      "GitHub CLI (gh) not found. Install it to enable auto-deploy setup."
+    );
+    return;
+  }
+  const shouldSetup = await p2.confirm({
+    message: "Set up GitHub auto-deploy? (push = redeploy)",
+    initialValue: false
+  });
+  if (p2.isCancel(shouldSetup) || !shouldSetup) return;
+  const visibility = await p2.select({
+    message: "Repository visibility:",
+    options: [
+      { value: "private", label: "Private" },
+      { value: "public", label: "Public" }
+    ]
+  });
+  if (p2.isCancel(visibility)) return;
+  try {
+    const gitDir = join(siteDir, ".git");
+    if (!await fileExists(gitDir)) {
+      await run("git", ["init"], { cwd: siteDir });
+    }
+    await run(
+      "gh",
+      [
+        "repo",
+        "create",
+        projectName,
+        `--${visibility}`,
+        "--source",
+        siteDir,
+        "--push"
+      ],
+      { cwd: siteDir, stdio: "inherit" }
+    );
+    logger.success(`GitHub repository created: ${projectName}`);
+    logger.info(
+      "Connect this repo in your Cloudflare Pages or Vercel dashboard for auto-deploy."
+    );
+  } catch (error) {
+    logger.error(`GitHub setup failed: ${error.message}`);
+  }
+}
+var init_github = __esm({
+  "src/deployer/github.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_exec();
+    init_fs();
+    init_logger();
+  }
+});
+
+// src/deployer/index.ts
+import { join as join4 } from "path";
+async function deploy(siteDir, platform, projectName) {
+  if (platform === "local") {
+    logger.info(`Site built at ${join4(siteDir, "out/")}`);
+    logger.info("Run `npx serve ./out` in the site directory to preview.");
+    return null;
+  }
+  await ensureAuth(platform);
+  const distDir = join4(siteDir, "out");
+  let url;
+  if (platform === "cloudflare") {
+    url = await deployToCloudflare(distDir, projectName);
+  } else {
+    url = await deployToVercel(distDir);
+  }
+  await setupGitHubAutoDeploy(siteDir, projectName);
+  return url;
+}
+var init_deployer = __esm({
+  "src/deployer/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_auth();
+    init_cloudflare();
+    init_vercel();
+    init_github();
+    init_logger();
+  }
+});
+
+// src/pdf/index.ts
+import { createServer } from "http";
+import { join as join5 } from "path";
+import ora8 from "ora";
+async function exportPdf(siteDir, outputPath) {
+  const distDir = join5(siteDir, "out");
+  const pdfPath = outputPath || join5(distDir, "shipfolio.pdf");
+  const spinner = ora8("Exporting PDF...").start();
+  const server = await startStaticServer(distDir);
+  const port = server.address()?.port || 3456;
+  try {
+    const { chromium } = await import("playwright");
+    const browser = await chromium.launch();
+    const page = await browser.newPage();
+    await page.goto(`http://localhost:${port}`, {
+      waitUntil: "networkidle"
+    });
+    await page.waitForTimeout(1e3);
+    await page.pdf({
+      path: pdfPath,
+      format: "A4",
+      printBackground: true,
+      margin: {
+        top: "1cm",
+        right: "1cm",
+        bottom: "1cm",
+        left: "1cm"
+      }
+    });
+    await browser.close();
+    spinner.succeed(`PDF exported: ${pdfPath}`);
+    return pdfPath;
+  } catch (error) {
+    spinner.fail("PDF export failed");
+    if (error.message?.includes("browserType.launch")) {
+      logger.error(
+        "Playwright browsers not installed. Run: npx playwright install chromium"
+      );
+    } else {
+      logger.error(error.message || String(error));
+    }
+    throw error;
+  } finally {
+    server.close();
+  }
+}
+function startStaticServer(dir) {
+  return new Promise(async (resolve7, reject) => {
+    const handler = await import("serve-handler");
+    const server = createServer((req, res) => {
+      return handler.default(req, res, {
+        public: dir,
+        cleanUrls: true
+      });
+    });
+    server.listen(0, () => {
+      resolve7(server);
+    });
+    server.on("error", reject);
+  });
+}
+async function startPreviewServer(siteDir, port = 3e3) {
+  const distDir = join5(siteDir, "out");
+  const handler = await import("serve-handler");
+  const server = createServer((req, res) => {
+    return handler.default(req, res, {
+      public: distDir,
+      cleanUrls: true
+    });
+  });
+  return new Promise((resolve7, reject) => {
+    server.listen(port, () => {
+      logger.info(`Preview: http://localhost:${port}`);
+      resolve7(server);
+    });
+    server.on("error", reject);
+  });
+}
+var init_pdf = __esm({
+  "src/pdf/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+  }
+});
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  initCommand: () => initCommand
+});
+import { resolve } from "path";
+import { join as join6 } from "path";
+import * as p3 from "@clack/prompts";
+async function initCommand(options) {
+  logger.header("shipfolio v1.0.0");
+  logger.info("Detecting AI engines...");
+  const engines = await detectEngines();
+  const availableTypes = getAvailableEngineTypes(engines);
+  if (availableTypes.length === 0) {
+    logger.error("No AI engine found.");
+    logger.plain("");
+    logger.plain("  shipfolio requires one of the following:");
+    logger.plain("    - Claude Code: npm install -g @anthropic-ai/claude-code");
+    logger.plain("    - Codex:       npm install -g @openai/codex");
+    logger.plain("    - v0:          Set V0_API_KEY environment variable");
+    logger.plain("");
+    process.exit(1);
+  }
+  logger.info(
+    `Available engines: ${availableTypes.join(", ")}`
+  );
+  const scanDirs = options.scan?.map((d) => resolve(d)) || [
+    resolve(process.cwd())
+  ];
+  const scannedProjects = await scanProjects(scanDirs);
+  if (scannedProjects.length === 0) {
+    logger.error("No projects found. Specify a different directory with --scan.");
+    process.exit(1);
+  }
+  logger.header(`Found ${scannedProjects.length} projects:`);
+  const tableRows = scannedProjects.map((proj) => [
+    proj.name,
+    proj.techStack.slice(0, 3).join(", "),
+    proj.firstCommitDate?.slice(0, 10) || "?",
+    `${proj.totalCommits} commits`
+  ]);
+  logger.table(tableRows);
+  logger.blank();
+  const interviewResult = await runInterview(scannedProjects, availableTypes);
+  const spec = buildSpec(interviewResult);
+  const prompt = await buildFreshPrompt(spec);
+  const outputDir = resolve(options.output || "./shipfolio-site");
+  await ensureDir(outputDir);
+  await generateSite(spec.engine, prompt, outputDir);
+  let buildSuccess = await buildSite(outputDir);
+  if (!buildSuccess) {
+    logger.info("Attempting retry...");
+    buildSuccess = await buildSite(outputDir);
+    if (!buildSuccess) {
+      logger.error("Build failed after retry. Check the output directory for details.");
+      process.exit(1);
+    }
+  }
+  if (!options.noPreview) {
+    const server = await startPreviewServer(outputDir);
+    logger.blank();
+    const proceed = await p3.confirm({
+      message: "Deploy now?",
+      initialValue: true
+    });
+    server.close();
+    if (p3.isCancel(proceed) || !proceed) {
+      if (spec.deploy.platform === "local") {
+      } else {
+        logger.info("Skipping deploy. Run `npx shipfolio deploy` later.");
+      }
+    }
+  }
+  if (!options.noPdf) {
+    try {
+      await exportPdf(outputDir);
+    } catch {
+      logger.warn("PDF export skipped due to error.");
+    }
+  }
+  if (spec.deploy.platform !== "local") {
+    const url = await deploy(
+      outputDir,
+      spec.deploy.platform,
+      spec.deploy.projectName
+    );
+    if (url) {
+      spec.deploy.url = url;
+    }
+  }
+  await writeJson(join6(outputDir, "shipfolio.config.json"), {
+    ...spec,
+    sitePath: outputDir
+  });
+  logger.header("Done.");
+  if (spec.deploy.url) {
+    logger.info(`Site: ${spec.deploy.url}`);
+  }
+  logger.info(`Local: ${outputDir}`);
+  logger.info(
+    `Update: npx shipfolio update --site ${outputDir}`
+  );
+}
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_scanner();
+    init_interviewer();
+    init_builder();
+    init_prompt_builder();
+    init_detect();
+    init_orchestrator();
+    init_deployer();
+    init_pdf();
+    init_pdf();
+    init_fs();
+    init_logger();
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+init_init();
+import { Command } from "commander";
+
+// src/commands/update.ts
+init_esm_shims();
+init_scanner();
+import { resolve as resolve2 } from "path";
+
+// src/spec/diff.ts
+init_esm_shims();
+function computeDiff(oldConfig, newScan) {
+  const oldProjectMap = new Map(
+    oldConfig.projects.map((p6) => [p6.localPath, p6])
+  );
+  const newProjectMap = new Map(newScan.map((p6) => [p6.localPath, p6]));
+  const newProjects = [];
+  const updatedProjects = [];
+  const removedProjects = [];
+  const unchangedProjects = [];
+  for (const [path2, meta] of newProjectMap) {
+    const oldProject = oldProjectMap.get(path2);
+    if (!oldProject) {
+      newProjects.push(meta);
+    } else if (meta.lastScannedCommit !== oldProject.lastScannedCommit) {
+      const newCommits = meta.totalCommits - oldProject.totalCommits;
+      updatedProjects.push({
+        project: meta,
+        newCommits: Math.max(newCommits, 0),
+        readmeChanged: meta.readmeContent !== oldProject.readmeContent,
+        depsChanged: JSON.stringify(meta.techStack) !== JSON.stringify(oldProject.techStack)
+      });
+    } else {
+      unchangedProjects.push(oldProject);
+    }
+  }
+  for (const [path2, project] of oldProjectMap) {
+    if (!newProjectMap.has(path2)) {
+      removedProjects.push(project);
+    }
+  }
+  return {
+    newProjects,
+    updatedProjects,
+    removedProjects,
+    unchangedProjects
+  };
+}
+
+// src/commands/update.ts
+init_prompt_builder();
+init_detect();
+init_orchestrator();
+init_deployer();
+init_pdf();
+init_fs();
+init_logger();
+import * as p4 from "@clack/prompts";
+async function updateCommand(options) {
+  logger.header("shipfolio update");
+  const siteDir = resolve2(options.site);
+  const configPath = join(siteDir, "shipfolio.config.json");
+  if (!await fileExists(configPath)) {
+    logger.error(
+      "shipfolio.config.json not found. This directory was not generated by shipfolio."
+    );
+    const fresh = await p4.confirm({
+      message: "Proceed with fresh build instead?",
+      initialValue: true
+    });
+    if (p4.isCancel(fresh) || !fresh) {
+      process.exit(0);
+    }
+    const { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+    await initCommand2({ output: siteDir });
+    return;
+  }
+  const config = await readJson(configPath);
+  logger.info(
+    `Site: ${config.deploy.projectName || "local"} (generated ${config.generatedAt.slice(0, 10)})`
+  );
+  logger.info(`Theme: ${config.style.theme}`);
+  logger.info(`Projects: ${config.projects.length}`);
+  const engines = await detectEngines();
+  const availableTypes = getAvailableEngineTypes(engines);
+  if (availableTypes.length === 0) {
+    logger.error("No AI engine found. See `npx shipfolio` for install instructions.");
+    process.exit(1);
+  }
+  const scanDirs = options.scan?.map((d) => resolve2(d)) || [...new Set(config.projects.map((p6) => {
+    const parts = p6.localPath.split("/");
+    parts.pop();
+    return parts.join("/");
+  }))];
+  const scannedProjects = await scanProjects(scanDirs);
+  const diff = computeDiff(config, scannedProjects);
+  logger.header("Changes detected:");
+  if (diff.newProjects.length > 0) {
+    logger.plain("  New:");
+    for (const proj of diff.newProjects) {
+      logger.plain(`    + ${proj.name}    ${proj.techStack.slice(0, 3).join(", ")}`);
+    }
+  }
+  if (diff.updatedProjects.length > 0) {
+    logger.plain("  Updated:");
+    for (const upd of diff.updatedProjects) {
+      logger.plain(
+        `    ~ ${upd.project.name}    ${upd.newCommits} new commits`
+      );
+    }
+  }
+  if (diff.removedProjects.length > 0) {
+    logger.plain("  Removed:");
+    for (const proj of diff.removedProjects) {
+      logger.plain(`    - ${proj.name}    (directory gone)`);
+    }
+  }
+  if (diff.newProjects.length === 0 && diff.updatedProjects.length === 0 && diff.removedProjects.length === 0) {
+    logger.info("No changes detected.");
+    return;
+  }
+  const proceed = await p4.confirm({
+    message: "Apply these changes?",
+    initialValue: true
+  });
+  if (p4.isCancel(proceed) || !proceed) {
+    process.exit(0);
+  }
+  const engine = availableTypes.includes(config.engine) ? config.engine : availableTypes[0];
+  const prompt = await buildUpdatePrompt(config, diff);
+  await generateSite(engine, prompt, siteDir);
+  const buildSuccess = await buildSite(siteDir);
+  if (!buildSuccess) {
+    logger.error("Build failed. Check the site directory.");
+    process.exit(1);
+  }
+  if (!options.noPreview) {
+    const server = await startPreviewServer(siteDir);
+    const ok = await p4.confirm({
+      message: "Looks good?",
+      initialValue: true
+    });
+    server.close();
+    if (p4.isCancel(ok) || !ok) {
+      logger.info("Update cancelled at preview.");
+      return;
+    }
+  }
+  if (!options.noPdf) {
+    try {
+      await exportPdf(siteDir);
+    } catch {
+      logger.warn("PDF export skipped.");
+    }
+  }
+  if (!options.noDeploy && config.deploy.platform !== "local") {
+    await deploy(siteDir, config.deploy.platform, config.deploy.projectName);
+  }
+  const updatedConfig = {
+    ...config,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    projects: [
+      ...diff.unchangedProjects,
+      ...diff.updatedProjects.map((u) => {
+        const existing = config.projects.find(
+          (p6) => p6.localPath === u.project.localPath
+        );
+        return {
+          ...u.project,
+          included: true,
+          overrideDescription: existing?.overrideDescription || null,
+          showSourceLink: existing?.showSourceLink ?? !!u.project.remoteUrl,
+          role: existing?.role || "solo",
+          metrics: existing?.metrics || {}
+        };
+      }),
+      ...diff.newProjects.map(
+        (proj) => ({
+          ...proj,
+          included: true,
+          overrideDescription: null,
+          showSourceLink: !!proj.remoteUrl,
+          role: "solo",
+          metrics: {}
+        })
+      )
+    ]
+  };
+  await writeJson(join(siteDir, "shipfolio.config.json"), updatedConfig);
+  logger.success("Update complete.");
+}
+
+// src/commands/spec.ts
+init_esm_shims();
+init_scanner();
+init_interviewer();
+init_builder();
+init_prompt_builder();
+init_detect();
+init_fs();
+init_logger();
+import { resolve as resolve3 } from "path";
+async function specCommand(options) {
+  logger.header("shipfolio spec");
+  const engines = await detectEngines();
+  const availableTypes = getAvailableEngineTypes(engines);
+  const engineTypes = availableTypes.length > 0 ? availableTypes : ["claude"];
+  const scanDirs = options.scan?.map((d) => resolve3(d)) || [
+    resolve3(process.cwd())
+  ];
+  const scannedProjects = await scanProjects(scanDirs);
+  if (scannedProjects.length === 0) {
+    logger.error("No projects found.");
+    process.exit(1);
+  }
+  logger.info(`Found ${scannedProjects.length} projects`);
+  const interviewResult = await runInterview(
+    scannedProjects,
+    [...engineTypes]
+  );
+  const spec = buildSpec(interviewResult);
+  const prompt = await buildFreshPrompt(spec);
+  const outputDir = options.output || ".";
+  const specPath = resolve3(outputDir, "shipfolio-spec.json");
+  const promptPath = resolve3(outputDir, "shipfolio-prompt.md");
+  await writeJson(specPath, spec);
+  await writeText(promptPath, prompt);
+  logger.success(`Spec saved: ${specPath}`);
+  logger.success(`Prompt saved: ${promptPath}`);
+  logger.blank();
+  logger.info(
+    "Use these files inside your Claude Code or Codex session to generate the site."
+  );
+}
+
+// src/commands/deploy.ts
+init_esm_shims();
+init_deployer();
+init_fs();
+init_logger();
+import { resolve as resolve4 } from "path";
+import * as p5 from "@clack/prompts";
+async function deployCommand(options) {
+  const siteDir = resolve4(options.site);
+  const configPath = join(siteDir, "shipfolio.config.json");
+  let platform;
+  let projectName;
+  if (await fileExists(configPath)) {
+    const config = await readJson(configPath);
+    platform = options.platform || config.deploy.platform;
+    projectName = config.deploy.projectName;
+  } else {
+    platform = options.platform || "cloudflare";
+    projectName = await p5.text({
+      message: "Project name:",
+      validate: (v) => /^[a-z0-9-]+$/.test(v) ? void 0 : "Lowercase letters, numbers, and hyphens only"
+    });
+    if (p5.isCancel(projectName)) process.exit(0);
+  }
+  if (platform === "local") {
+    logger.info("Deploy platform is set to local. Nothing to deploy.");
+    return;
+  }
+  const outDir = join(siteDir, "out");
+  if (!await fileExists(outDir)) {
+    logger.error("Build output not found. Run `npm run build` in the site directory first.");
+    process.exit(1);
+  }
+  await deploy(siteDir, platform, projectName);
+}
+
+// src/commands/pdf.ts
+init_esm_shims();
+init_pdf();
+init_fs();
+init_logger();
+import { resolve as resolve5 } from "path";
+async function pdfCommand(options) {
+  const siteDir = resolve5(options.site);
+  const outDir = join(siteDir, "out");
+  if (!await fileExists(outDir)) {
+    logger.error(
+      "Build output not found. Run `npm run build` in the site directory first."
+    );
+    process.exit(1);
+  }
+  await exportPdf(siteDir, options.output);
+}
+
+// src/commands/preview.ts
+init_esm_shims();
+init_pdf();
+init_fs();
+init_logger();
+import { resolve as resolve6 } from "path";
+async function previewCommand(options) {
+  const siteDir = resolve6(options.site);
+  const outDir = join(siteDir, "out");
+  if (!await fileExists(outDir)) {
+    logger.error(
+      "Build output not found. Run `npm run build` in the site directory first."
+    );
+    process.exit(1);
+  }
+  const port = options.port || 3e3;
+  await startPreviewServer(siteDir, port);
+  logger.info("Press Ctrl+C to stop.");
+  await new Promise(() => {
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("shipfolio").description(
+  "Generate and deploy your personal portfolio site from local projects using AI"
+).version("1.0.0");
+program.command("init", { isDefault: true }).description("Generate a new portfolio site").option("-s, --scan <dirs...>", "Directories to scan for projects").option("-e, --engine <engine>", "AI engine: claude | codex | v0").option("-d, --deploy <platform>", "Deploy target: cloudflare | vercel | local").option("--style <theme>", "Theme: dark-minimal | light-clean | monochrome").option("--accent <hex>", "Accent color (hex)").option("--auto", "Skip prompts, use defaults").option("-o, --output <dir>", "Output directory", "./shipfolio-site").option("--no-pdf", "Skip PDF export").option("--no-preview", "Skip local preview").option("-v, --verbose", "Verbose output").action(initCommand);
+program.command("update").description("Update an existing portfolio site").requiredOption("--site <path>", "Path to existing site directory").option("-s, --scan <dirs...>", "Directories to scan for projects").option("--no-pdf", "Skip PDF export").option("--no-preview", "Skip preview").option("--no-deploy", "Skip deployment").action(updateCommand);
+program.command("spec").description("Generate spec and prompt files only").option("-s, --scan <dirs...>", "Directories to scan for projects").option("-o, --output <dir>", "Output directory for spec files", ".").action(specCommand);
+program.command("deploy").description("Deploy an existing built site").requiredOption("--site <path>", "Path to site directory").option("-p, --platform <platform>", "Deploy platform: cloudflare | vercel").action(deployCommand);
+program.command("pdf").description("Export site to PDF").requiredOption("--site <path>", "Path to site directory").option("-o, --output <path>", "PDF output path").action(pdfCommand);
+program.command("preview").description("Start local preview server").requiredOption("--site <path>", "Path to site directory").option("--port <port>", "Port number", "3000").action((opts) => previewCommand({ ...opts, port: parseInt(opts.port) }));
+program.parse();
+//# sourceMappingURL=cli.js.map