shipfolio 1.0.9 → 1.1.0

package/dist/cli.js

@@ -81,7 +81,7 @@ function normalizeGitUrl(url) {
   }
   return url;
 }
-async function findGitRepos(rootPath, maxDepth = 3) {
+async function findGitRepos(rootPath, maxDepth = 6) {
   const { glob: glob2 } = await import("glob");
   const gitDirs = await glob2("**/.git", {
     cwd: rootPath,
@@ -455,15 +455,20 @@ var init_logger = __esm({
 });
 
 // src/scanner/index.ts
+import { dirname, resolve as resolvePath } from "path";
 import ora from "ora";
 async function scanProjects(directories) {
   const allPaths = [];
   const spinner = ora("Scanning for projects...").start();
   for (const dir of directories) {
     try {
-      const repos = await findGitRepos(dir);
+      const repos = await findGitRepos(dir, DEFAULT_SCAN_DEPTH);
       allPaths.push(...repos);
-      const nonGitDirs = await findNonGitProjects(dir, new Set(repos));
+      const nonGitDirs = await findNonGitProjects(
+        dir,
+        repos,
+        DEFAULT_SCAN_DEPTH
+      );
       allPaths.push(...nonGitDirs);
     } catch (err) {
       logger.warn(`Could not scan ${dir}: ${err}`);
@@ -492,31 +497,29 @@ async function scanProjects(directories) {
   spinner.succeed(`Scanned ${projects.length} projects`);
   return projects;
 }
-async function findNonGitProjects(rootPath, gitRepos) {
+async function findNonGitProjects(rootPath, gitRepos, maxDepth) {
   const { glob: glob2 } = await import("glob");
-  const indicators = [
-    "*/package.json",
-    "*/Cargo.toml",
-    "*/go.mod",
-    "*/pyproject.toml",
-    "*/requirements.txt",
-    "*/setup.py"
-  ];
   const found = /* @__PURE__ */ new Set();
-  for (const pattern of indicators) {
-    const matches = await glob2(pattern, {
+  for (const indicator of NON_GIT_PROJECT_INDICATORS) {
+    const matches = await glob2(`**/${indicator}`, {
       cwd: rootPath,
-      ignore: ["**/node_modules/**", "**/vendor/**"]
+      ignore: SCAN_IGNORE_PATTERNS,
+      maxDepth
     });
     for (const match of matches) {
-      const dir = `${rootPath}/${match.split("/")[0]}`;
-      if (!gitRepos.has(dir) && !found.has(dir)) {
-        found.add(dir);
+      const candidateDir = dirname(resolvePath(rootPath, match));
+      if (!isInsideTrackedRepo(candidateDir, gitRepos) && !found.has(candidateDir)) {
+        found.add(candidateDir);
       }
     }
   }
   return [...found].sort();
 }
+function isInsideTrackedRepo(candidateDir, gitRepos) {
+  return gitRepos.some(
+    (repoPath) => candidateDir === repoPath || candidateDir.startsWith(`${repoPath}/`)
+  );
+}
 async function extractProjectMeta(projectPath) {
   const gitMeta = await getGitMeta(projectPath);
   let techStack = [];
@@ -576,6 +579,7 @@ async function extractProjectMeta(projectPath) {
     lastScannedCommit: gitMeta.lastCommitHash || ""
   };
 }
+var DEFAULT_SCAN_DEPTH, NON_GIT_PROJECT_INDICATORS, SCAN_IGNORE_PATTERNS;
 var init_scanner = __esm({
   "src/scanner/index.ts"() {
     "use strict";
@@ -588,6 +592,25 @@ var init_scanner = __esm({
     init_generic();
     init_extractors();
     init_logger();
+    DEFAULT_SCAN_DEPTH = 6;
+    NON_GIT_PROJECT_INDICATORS = [
+      "package.json",
+      "Cargo.toml",
+      "go.mod",
+      "pyproject.toml",
+      "requirements.txt",
+      "setup.py"
+    ];
+    SCAN_IGNORE_PATTERNS = [
+      "**/node_modules/**",
+      "**/vendor/**",
+      "**/.git/**",
+      "**/.next/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/out/**",
+      "**/coverage/**"
+    ];
   }
 });
 
@@ -626,6 +649,14 @@ var init_i18n = __esm({
         showSourceFor: (name) => `Show source code link for ${name}?`,
         roleFor: (name) => `Your role in ${name}:`,
         metricsFor: (name) => `Key metrics for ${name} (e.g. "1k users, $5k MRR"):`,
+        featureProjectFor: (name) => `Feature ${name} more prominently on the site?`,
+        caseStudyDetailsFor: (name) => `Add richer case-study details for ${name}?`,
+        audienceFor: (name) => `Primary audience for ${name}:`,
+        problemFor: (name) => `Problem or goal for ${name}:`,
+        solutionFor: (name) => `Your solution or key decision in ${name}:`,
+        impactFor: (name) => `Outcome / impact for ${name}:`,
+        evidenceFor: (name) => `Evidence for ${name} (comma-separated facts, proof points, links):`,
+        screenshotsFor: (name) => `Screenshot URLs for ${name} (comma-separated):`,
         optional: "optional",
         // Personal info
         personalInfo: "Personal Information",
@@ -672,6 +703,8 @@ var init_i18n = __esm({
         draftLoadPrompt: "Load draft? (skip re-entering previous answers)",
         draftSaved: "Draft saved. Your progress will be restored next time.",
         draftCleared: "Draft cleared.",
+        updateProfilePrompt: "Update profile / contact info too?",
+        reviewSectionsPrompt: "Review enabled sections too?",
         // Roles
         roleSolo: "Solo",
         roleLead: "Lead",
@@ -727,6 +760,14 @@ var init_i18n = __esm({
         showSourceFor: (name) => `\u662F\u5426\u5C55\u793A ${name} \u7684\u6E90\u7801\u94FE\u63A5?`,
         roleFor: (name) => `\u4F60\u5728 ${name} \u4E2D\u7684\u89D2\u8272:`,
         metricsFor: (name) => `${name} \u7684\u5173\u952E\u6307\u6807 (\u5982 "1k \u7528\u6237, $5k MRR"):`,
+        featureProjectFor: (name) => `\u662F\u5426\u5C06 ${name} \u8BBE\u4E3A\u91CD\u70B9\u9879\u76EE?`,
+        caseStudyDetailsFor: (name) => `\u662F\u5426\u4E3A ${name} \u8865\u5145\u66F4\u5B8C\u6574\u7684\u6848\u4F8B\u4FE1\u606F?`,
+        audienceFor: (name) => `${name} \u7684\u4E3B\u8981\u7528\u6237/\u53D7\u4F17:`,
+        problemFor: (name) => `${name} \u89E3\u51B3\u7684\u95EE\u9898\u6216\u76EE\u6807:`,
+        solutionFor: (name) => `\u4F60\u5728 ${name} \u4E2D\u7684\u65B9\u6848\u6216\u5173\u952E\u51B3\u7B56:`,
+        impactFor: (name) => `${name} \u7684\u7ED3\u679C / \u5F71\u54CD:`,
+        evidenceFor: (name) => `${name} \u7684\u8BC1\u660E\u6750\u6599 (\u9017\u53F7\u5206\u9694: \u4E8B\u5B9E\u3001\u6307\u6807\u3001\u94FE\u63A5):`,
+        screenshotsFor: (name) => `${name} \u7684\u622A\u56FE\u94FE\u63A5 (\u9017\u53F7\u5206\u9694):`,
         optional: "\u53EF\u9009",
         personalInfo: "\u4E2A\u4EBA\u4FE1\u606F",
         fullName: "\u4F60\u7684\u5168\u540D:",
@@ -767,6 +808,8 @@ var init_i18n = __esm({
         draftLoadPrompt: "\u662F\u5426\u52A0\u8F7D\u8349\u7A3F? (\u8DF3\u8FC7\u91CD\u590D\u586B\u5199)",
         draftSaved: "\u8349\u7A3F\u5DF2\u4FDD\u5B58, \u4E0B\u6B21\u8FD0\u884C\u65F6\u53EF\u6062\u590D.",
         draftCleared: "\u8349\u7A3F\u5DF2\u6E05\u9664.",
+        updateProfilePrompt: "\u662F\u5426\u540C\u65F6\u66F4\u65B0\u4E2A\u4EBA\u8D44\u6599 / \u8054\u7CFB\u65B9\u5F0F?",
+        reviewSectionsPrompt: "\u662F\u5426\u540C\u65F6\u68C0\u67E5\u542F\u7528\u7684\u9875\u9762\u533A\u5757?",
         roleSolo: "\u72EC\u7ACB\u5B8C\u6210",
         roleLead: "\u4E3B\u5BFC\u5F00\u53D1",
         roleContributor: "\u53C2\u4E0E\u8D21\u732E",
@@ -861,6 +904,102 @@ var init_questions = __esm({
   }
 });
 
+// src/spec/project-utils.ts
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function uniqueStrings(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+function defaultCaseStudy(featured = false) {
+  return {
+    featured,
+    audience: null,
+    problem: null,
+    solution: null,
+    impact: null,
+    evidence: [],
+    screenshots: []
+  };
+}
+function buildTrackingSignature(projects) {
+  return projects.map((project) => `${project.localPath}:${project.lastScannedCommit || "none"}`).sort().join("|");
+}
+function buildMergedProjectMeta(projects, name) {
+  const techStack = uniqueStrings(projects.flatMap((project) => project.techStack));
+  const languages = {};
+  for (const project of projects) {
+    for (const [lang, count] of Object.entries(project.languages)) {
+      languages[lang] = (languages[lang] || 0) + count;
+    }
+  }
+  const firstDates = projects.map((project) => project.firstCommitDate).filter(Boolean).sort();
+  const lastDates = projects.map((project) => project.lastCommitDate).filter(Boolean).sort();
+  const totalCommits = projects.reduce(
+    (sum, project) => sum + project.totalCommits,
+    0
+  );
+  const remoteUrl = projects.find((project) => project.remoteUrl)?.remoteUrl || null;
+  const demoUrl = projects.find((project) => project.demoUrl)?.demoUrl || null;
+  const readmeParts = projects.filter((project) => project.readmeContent).map((project) => `--- ${project.name} ---
+${project.readmeContent}`);
+  const readmeContent = readmeParts.length > 0 ? readmeParts.join("\n\n") : null;
+  const descriptions = projects.map((project) => project.description).filter(Boolean);
+  return {
+    id: slugify(name),
+    name,
+    localPath: projects[0]?.localPath || "",
+    description: descriptions.join(" | "),
+    techStack,
+    languages,
+    firstCommitDate: firstDates[0] || "",
+    lastCommitDate: lastDates[lastDates.length - 1] || "",
+    totalCommits,
+    remoteUrl,
+    demoUrl,
+    readmeContent,
+    lastScannedCommit: buildTrackingSignature(projects)
+  };
+}
+function getTrackedProjectPaths(project) {
+  if (project.trackedProjectPaths && project.trackedProjectPaths.length > 0) {
+    return uniqueStrings(project.trackedProjectPaths);
+  }
+  if (project.children && project.children.length > 0) {
+    return uniqueStrings(project.children.map((child) => child.localPath));
+  }
+  return project.localPath ? [project.localPath] : [];
+}
+function createProjectEntry(meta, overrides = {}) {
+  const baseMetrics = overrides.metrics || {};
+  const baseCaseStudy = overrides.caseStudy ? {
+    ...defaultCaseStudy(overrides.caseStudy.featured),
+    ...overrides.caseStudy,
+    evidence: overrides.caseStudy.evidence || [],
+    screenshots: overrides.caseStudy.screenshots || []
+  } : defaultCaseStudy(false);
+  return {
+    ...meta,
+    included: overrides.included ?? true,
+    overrideDescription: overrides.overrideDescription ?? null,
+    showSourceLink: overrides.showSourceLink ?? !!meta.remoteUrl,
+    role: overrides.role ?? "solo",
+    trackedProjectPaths: overrides.trackedProjectPaths && overrides.trackedProjectPaths.length > 0 ? uniqueStrings(overrides.trackedProjectPaths) : [meta.localPath],
+    metrics: {
+      ...baseMetrics,
+      custom: baseMetrics.custom || void 0
+    },
+    caseStudy: baseCaseStudy,
+    children: overrides.children
+  };
+}
+var init_project_utils = __esm({
+  "src/spec/project-utils.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/interviewer/index.ts
 import * as p from "@clack/prompts";
 function handleCancel(value) {
@@ -869,6 +1008,38 @@ function handleCancel(value) {
     process.exit(0);
   }
 }
+function inferOwnerName() {
+  return process.env.SHIPFOLIO_NAME || process.env.GIT_AUTHOR_NAME || process.env.USER || process.env.USERNAME || "Portfolio Owner";
+}
+function sanitizeProjectName(value) {
+  const sanitized = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return sanitized || "my-shipfolio";
+}
+function parseCommaSeparatedList(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function getAdditionalSectionOptions(projects, owner) {
+  return SECTION_OPTIONS().filter((option) => {
+    switch (option.value) {
+      case "blog":
+        return !!owner.social.blog;
+      case "timeline":
+        return projects.some(
+          (project) => !!project.firstCommitDate || !!project.lastCommitDate
+        );
+      case "metrics":
+        return projects.some(
+          (project) => !!project.metrics.users || !!project.metrics.revenue || !!project.metrics.downloads || !!project.metrics.stars || !!project.metrics.custom || !!project.caseStudy.impact || project.caseStudy.evidence.length > 0
+        );
+      case "contact":
+        return Boolean(
+          owner.social.email || owner.social.github || owner.social.linkedin || owner.social.twitter || owner.social.blog
+        );
+      default:
+        return true;
+    }
+  });
+}
 async function runMergeStep(projects) {
   const shouldMerge = await p.confirm({
     message: t().mergePrompt,
@@ -928,51 +1099,15 @@ function mergeProjects(projects, name) {
       allChildren.push(rest);
     }
   }
-  const techStack = [
-    ...new Set(allChildren.flatMap((p6) => p6.techStack))
-  ];
-  const languages = {};
-  for (const child of allChildren) {
-    for (const [lang, count] of Object.entries(child.languages)) {
-      languages[lang] = (languages[lang] || 0) + count;
-    }
-  }
-  const firstDates = allChildren.map((p6) => p6.firstCommitDate).filter(Boolean).sort();
-  const lastDates = allChildren.map((p6) => p6.lastCommitDate).filter(Boolean).sort();
-  const totalCommits = allChildren.reduce(
-    (sum, p6) => sum + p6.totalCommits,
-    0
-  );
-  const remoteUrl = allChildren.find((p6) => p6.remoteUrl)?.remoteUrl || null;
-  const demoUrl = allChildren.find((p6) => p6.demoUrl)?.demoUrl || null;
-  const readmeParts = allChildren.filter((p6) => p6.readmeContent).map(
-    (p6) => `--- ${p6.name} ---
-${p6.readmeContent}`
-  );
-  const readmeContent = readmeParts.length > 0 ? readmeParts.join("\n\n") : null;
-  const descriptions = allChildren.map((p6) => p6.description).filter(Boolean);
-  const description = descriptions.join(" | ");
-  const localPath = allChildren[0].localPath;
-  const id = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  const mergedMeta = buildMergedProjectMeta(allChildren, name);
   return {
-    id,
-    name,
-    localPath,
-    description,
-    techStack,
-    languages,
-    firstCommitDate: firstDates[0] || "",
-    lastCommitDate: lastDates[lastDates.length - 1] || "",
-    totalCommits,
-    remoteUrl,
-    demoUrl,
-    readmeContent,
-    lastScannedCommit: allChildren[0].lastScannedCommit || "",
+    ...mergedMeta,
     children: allChildren
   };
 }
-async function runInterview(scannedProjects, availableEngines) {
+async function runInterview(scannedProjects, availableEngines, options = {}) {
   p.intro("shipfolio");
+  const auto = options.auto === true;
   logger.header("Project Selection");
   const projectOptions = scannedProjects.map((proj) => {
     const techInfo = proj.techStack.slice(0, 3).join(", ");
@@ -983,23 +1118,45 @@ async function runInterview(scannedProjects, availableEngines) {
       hint: techInfo ? `${techInfo} | ${commitInfo}` : commitInfo
     };
   });
-  const selectedIds = await p.multiselect({
-    message: t().selectProjects,
-    options: projectOptions,
-    required: true
-  });
-  handleCancel(selectedIds);
+  let selectedIds;
+  if (auto) {
+    selectedIds = scannedProjects.map((proj) => proj.id);
+    logger.info(`Auto mode: selected all ${selectedIds.length} scanned projects.`);
+  } else {
+    selectedIds = await p.multiselect({
+      message: t().selectProjects,
+      options: projectOptions,
+      required: true
+    });
+    handleCancel(selectedIds);
+  }
   let selectedMetas = selectedIds.map(
     (id) => scannedProjects.find((p6) => p6.id === id)
   );
-  if (selectedMetas.length >= 2) {
+  if (!auto && selectedMetas.length >= 2) {
     selectedMetas = await runMergeStep(selectedMetas);
   }
+  const autoFeaturedIds = new Set(
+    [...selectedMetas].sort((a, b) => b.totalCommits - a.totalCommits).slice(0, 3).map((project) => project.id)
+  );
   const projectEntries = [];
   for (const meta of selectedMetas) {
     const displayName = meta.children ? `${meta.name} (${meta.children.length} sub-projects)` : meta.name;
     logger.plain(`
   ${t().configuring(displayName)}`);
+    if (auto) {
+      projectEntries.push(
+        createProjectEntry(meta, {
+          showSourceLink: !!meta.remoteUrl,
+          trackedProjectPaths: meta.children?.map((child) => child.localPath) || [
+            meta.localPath
+          ],
+          children: meta.children,
+          caseStudy: defaultCaseStudy(autoFeaturedIds.has(meta.id))
+        })
+      );
+      continue;
+    }
     const overrideDesc = await p.text({
       message: t().descriptionFor(displayName),
       placeholder: meta.description?.slice(0, 80) || t().descriptionPlaceholder,
@@ -1032,119 +1189,229 @@ async function runInterview(scannedProjects, availableEngines) {
     if (metricsInput) {
       metrics.custom = { summary: metricsInput };
     }
-    projectEntries.push({
-      ...meta,
-      included: true,
-      overrideDescription: overrideDesc || null,
-      showSourceLink: showSource,
-      demoUrl: demoUrl || meta.demoUrl,
-      role,
-      metrics
+    const featured = await p.confirm({
+      message: t().featureProjectFor(displayName),
+      initialValue: autoFeaturedIds.has(meta.id)
+    });
+    handleCancel(featured);
+    const addCaseStudyDetails = await p.confirm({
+      message: t().caseStudyDetailsFor(displayName),
+      initialValue: false
     });
+    handleCancel(addCaseStudyDetails);
+    let audience = null;
+    let problem = null;
+    let solution = null;
+    let impact = null;
+    let evidence = [];
+    let screenshots = [];
+    if (addCaseStudyDetails) {
+      const audienceInput = await p.text({
+        message: t().audienceFor(displayName),
+        placeholder: t().optional,
+        defaultValue: ""
+      });
+      handleCancel(audienceInput);
+      audience = audienceInput || null;
+      const problemInput = await p.text({
+        message: t().problemFor(displayName),
+        placeholder: t().optional,
+        defaultValue: ""
+      });
+      handleCancel(problemInput);
+      problem = problemInput || null;
+      const solutionInput = await p.text({
+        message: t().solutionFor(displayName),
+        placeholder: t().optional,
+        defaultValue: ""
+      });
+      handleCancel(solutionInput);
+      solution = solutionInput || null;
+      const impactInput = await p.text({
+        message: t().impactFor(displayName),
+        placeholder: t().optional,
+        defaultValue: metricsInput || ""
+      });
+      handleCancel(impactInput);
+      impact = impactInput || null;
+      const evidenceInput = await p.text({
+        message: t().evidenceFor(displayName),
+        placeholder: t().optional,
+        defaultValue: ""
+      });
+      handleCancel(evidenceInput);
+      evidence = parseCommaSeparatedList(evidenceInput);
+      const screenshotsInput = await p.text({
+        message: t().screenshotsFor(displayName),
+        placeholder: t().optional,
+        defaultValue: ""
+      });
+      handleCancel(screenshotsInput);
+      screenshots = parseCommaSeparatedList(screenshotsInput);
+    }
+    projectEntries.push(
+      createProjectEntry(
+        {
+          ...meta,
+          demoUrl: demoUrl || meta.demoUrl
+        },
+        {
+          overrideDescription: overrideDesc || null,
+          showSourceLink: showSource,
+          role,
+          metrics,
+          trackedProjectPaths: meta.children?.map((child) => child.localPath) || [
+            meta.localPath
+          ],
+          children: meta.children,
+          caseStudy: {
+            featured,
+            audience,
+            problem,
+            solution,
+            impact,
+            evidence,
+            screenshots
+          }
+        }
+      )
+    );
   }
   logger.header(t().personalInfo);
-  const name = await p.text({
-    message: t().fullName,
-    validate: (v) => v.length === 0 ? t().nameRequired : void 0
-  });
-  handleCancel(name);
-  const tagline = await p.text({
-    message: t().tagline,
-    placeholder: t().taglinePlaceholder
-  });
-  handleCancel(tagline);
-  const bioChoice = await p.select({
-    message: t().bio,
-    options: [
-      { value: "auto", label: t().bioAuto },
-      { value: "manual", label: t().bioManual }
-    ]
-  });
-  handleCancel(bioChoice);
-  let bio = "auto";
-  if (bioChoice === "manual") {
-    bio = await p.text({
-      message: t().bioPrompt
+  let owner;
+  if (auto) {
+    owner = {
+      name: inferOwnerName(),
+      tagline: t().taglinePlaceholder,
+      bio: "auto",
+      photoUrl: null,
+      social: {}
+    };
+    logger.info(`Auto mode: using "${owner.name}" as the portfolio owner name.`);
+  } else {
+    const name = await p.text({
+      message: t().fullName,
+      validate: (v) => v.length === 0 ? t().nameRequired : void 0
     });
-    handleCancel(bio);
-  }
-  const photoUrl = await p.text({
-    message: t().photoUrl,
-    placeholder: "https://...",
-    defaultValue: ""
-  });
-  handleCancel(photoUrl);
-  const github = await p.text({
-    message: t().githubUser,
-    defaultValue: ""
-  });
-  handleCancel(github);
-  const twitter = await p.text({
-    message: t().twitterHandle,
-    defaultValue: ""
-  });
-  handleCancel(twitter);
-  const linkedin = await p.text({
-    message: t().linkedinUrl,
-    defaultValue: ""
-  });
-  handleCancel(linkedin);
-  const blogUrl = await p.text({
-    message: t().blogUrl,
-    defaultValue: ""
-  });
-  handleCancel(blogUrl);
-  const email = await p.text({
-    message: t().contactEmail,
-    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
+    handleCancel(name);
+    const tagline = await p.text({
+      message: t().tagline,
+      placeholder: t().taglinePlaceholder
+    });
+    handleCancel(tagline);
+    const bioChoice = await p.select({
+      message: t().bio,
+      options: [
+        { value: "auto", label: t().bioAuto },
+        { value: "manual", label: t().bioManual }
+      ]
+    });
+    handleCancel(bioChoice);
+    let bio = "auto";
+    if (bioChoice === "manual") {
+      bio = await p.text({
+        message: t().bioPrompt
+      });
+      handleCancel(bio);
     }
-  };
+    const photoUrl = await p.text({
+      message: t().photoUrl,
+      placeholder: "https://...",
+      defaultValue: ""
+    });
+    handleCancel(photoUrl);
+    const github = await p.text({
+      message: t().githubUser,
+      defaultValue: ""
+    });
+    handleCancel(github);
+    const twitter = await p.text({
+      message: t().twitterHandle,
+      defaultValue: ""
+    });
+    handleCancel(twitter);
+    const linkedin = await p.text({
+      message: t().linkedinUrl,
+      defaultValue: ""
+    });
+    handleCancel(linkedin);
+    const blogUrl = await p.text({
+      message: t().blogUrl,
+      defaultValue: ""
+    });
+    handleCancel(blogUrl);
+    const email = await p.text({
+      message: t().contactEmail,
+      defaultValue: ""
+    });
+    handleCancel(email);
+    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(t().designPrefs);
-  const theme = await p.select({
-    message: t().theme,
-    options: THEME_OPTIONS()
-  });
-  handleCancel(theme);
-  const accentColor = await p.select({
-    message: t().accentColor,
-    options: [
-      ...DEFAULT_ACCENT_COLORS(),
-      { value: "custom", label: t().customHex }
-    ]
-  });
-  handleCancel(accentColor);
-  let finalAccent = accentColor;
-  if (accentColor === "custom") {
-    finalAccent = await p.text({
-      message: t().customHexPrompt,
-      placeholder: "#7c3aed",
-      validate: (v) => /^#[0-9a-fA-F]{6}$/.test(v) ? void 0 : t().invalidHex
+  let theme;
+  if (options.style) {
+    theme = options.style;
+    logger.info(`Theme preset: ${theme}`);
+  } else if (auto) {
+    theme = "dark-minimal";
+  } else {
+    theme = await p.select({
+      message: t().theme,
+      options: THEME_OPTIONS()
     });
-    handleCancel(finalAccent);
+    handleCancel(theme);
+  }
+  let finalAccent;
+  if (options.accent) {
+    finalAccent = options.accent;
+    logger.info(`Accent preset: ${finalAccent}`);
+  } else if (auto) {
+    finalAccent = "#7c3aed";
+  } else {
+    const accentColor = await p.select({
+      message: t().accentColor,
+      options: [
+        ...DEFAULT_ACCENT_COLORS(),
+        { value: "custom", label: t().customHex }
+      ]
+    });
+    handleCancel(accentColor);
+    finalAccent = accentColor;
+    if (accentColor === "custom") {
+      finalAccent = await p.text({
+        message: t().customHexPrompt,
+        placeholder: "#7c3aed",
+        validate: (v) => /^#[0-9a-fA-F]{6}$/.test(v) ? void 0 : t().invalidHex
+      });
+      handleCancel(finalAccent);
+    }
   }
-  const font = await p.select({
+  const font = auto ? "Inter" : await p.select({
     message: t().font,
     options: FONT_OPTIONS()
   });
-  handleCancel(font);
-  const animationLevel = await p.select({
+  if (!auto) {
+    handleCancel(font);
+  }
+  const animationLevel = auto ? "subtle" : await p.select({
     message: t().animationLevel,
     options: ANIMATION_OPTIONS()
   });
-  handleCancel(animationLevel);
+  if (!auto) {
+    handleCancel(animationLevel);
+  }
   const style = {
     theme,
     accentColor: finalAccent,
@@ -1152,20 +1419,34 @@ async function runInterview(scannedProjects, availableEngines) {
     animationLevel
   };
   logger.header(t().sections);
-  const additionalSections = await p.multiselect({
-    message: t().additionalSections,
-    options: SECTION_OPTIONS(),
-    required: false
-  });
-  handleCancel(additionalSections);
-  const sections = [
-    "hero",
-    "projects",
-    ...additionalSections
-  ];
+  let sections;
+  if (auto) {
+    sections = ["hero", "projects", "about", "contact"];
+  } else {
+    const sectionOptions = getAdditionalSectionOptions(projectEntries, owner);
+    const additionalSections = sectionOptions.length > 0 ? await p.multiselect({
+      message: t().additionalSections,
+      options: sectionOptions,
+      required: false
+    }) : [];
+    if (sectionOptions.length > 0) {
+      handleCancel(additionalSections);
+    }
+    sections = [
+      "hero",
+      "projects",
+      ...additionalSections
+    ];
+  }
   logger.header(t().aiEngine);
   let engine;
-  if (availableEngines.length === 1) {
+  if (options.engine && availableEngines.includes(options.engine)) {
+    engine = options.engine;
+    logger.info(t().engineUsing(engine));
+  } else if (availableEngines.length === 1) {
+    engine = availableEngines[0];
+    logger.info(t().engineUsing(engine));
+  } else if (auto) {
     engine = availableEngines[0];
     logger.info(t().engineUsing(engine));
   } else {
@@ -1179,26 +1460,38 @@ async function runInterview(scannedProjects, availableEngines) {
     handleCancel(engine);
   }
   logger.header(t().deployment);
-  const deployPlatform = await p.select({
-    message: t().deployTo,
-    options: DEPLOY_OPTIONS()
-  });
-  handleCancel(deployPlatform);
+  let deployPlatform;
+  if (options.deploy) {
+    deployPlatform = options.deploy;
+    logger.info(`Deploy preset: ${deployPlatform}`);
+  } else if (auto) {
+    deployPlatform = "local";
+  } else {
+    deployPlatform = await p.select({
+      message: t().deployTo,
+      options: DEPLOY_OPTIONS()
+    });
+    handleCancel(deployPlatform);
+  }
   let projectName = "";
   let customDomain = "";
   if (deployPlatform !== "local") {
-    projectName = await p.text({
-      message: t().projectNamePrompt,
-      placeholder: "my-shipfolio",
-      validate: (v) => /^[a-z0-9-]+$/.test(v) ? void 0 : t().projectNameInvalid
-    });
-    handleCancel(projectName);
-    customDomain = await p.text({
-      message: t().customDomainPrompt,
-      placeholder: "portfolio.example.com",
-      defaultValue: ""
-    });
-    handleCancel(customDomain);
+    if (auto) {
+      projectName = sanitizeProjectName(`${owner.name}-shipfolio`);
+    } else {
+      projectName = await p.text({
+        message: t().projectNamePrompt,
+        placeholder: "my-shipfolio",
+        validate: (v) => /^[a-z0-9-]+$/.test(v) ? void 0 : t().projectNameInvalid
+      });
+      handleCancel(projectName);
+      customDomain = await p.text({
+        message: t().customDomainPrompt,
+        placeholder: "portfolio.example.com",
+        defaultValue: ""
+      });
+      handleCancel(customDomain);
+    }
   }
   p.outro(t().configComplete);
   return {
@@ -1221,13 +1514,121 @@ var init_interviewer = __esm({
     init_questions();
     init_logger();
     init_i18n();
+    init_project_utils();
+  }
+});
+
+// src/spec/schema.ts
+import { z } from "zod";
+function parseShipfolioSpec(input) {
+  return shipfolioSpecSchema.parse(input);
+}
+function parseShipfolioConfig(input) {
+  return shipfolioConfigSchema.parse(input);
+}
+var sectionIdSchema, engineTypeSchema, deployPlatformSchema, styleConfigSchema, projectMetaSchema, projectCaseStudySchema, ownerInfoSchema, projectEntrySchema, deployConfigSchema, shipfolioSpecSchema, shipfolioConfigSchema;
+var init_schema = __esm({
+  "src/spec/schema.ts"() {
+    "use strict";
+    init_esm_shims();
+    sectionIdSchema = z.enum([
+      "hero",
+      "projects",
+      "skills",
+      "about",
+      "timeline",
+      "blog",
+      "metrics",
+      "contact"
+    ]);
+    engineTypeSchema = z.enum(["claude", "codex", "v0"]);
+    deployPlatformSchema = z.enum(["cloudflare", "vercel", "local"]);
+    styleConfigSchema = z.object({
+      theme: z.enum(["dark-minimal", "light-clean", "monochrome", "custom"]),
+      accentColor: z.string(),
+      font: z.string(),
+      animationLevel: z.enum(["none", "subtle", "moderate"])
+    });
+    projectMetaSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+      localPath: z.string(),
+      description: z.string(),
+      techStack: z.array(z.string()),
+      languages: z.record(z.number()),
+      firstCommitDate: z.string(),
+      lastCommitDate: z.string(),
+      totalCommits: z.number().int().nonnegative(),
+      remoteUrl: z.string().nullable(),
+      demoUrl: z.string().nullable(),
+      readmeContent: z.string().nullable(),
+      lastScannedCommit: z.string()
+    });
+    projectCaseStudySchema = z.object({
+      featured: z.boolean(),
+      audience: z.string().nullable(),
+      problem: z.string().nullable(),
+      solution: z.string().nullable(),
+      impact: z.string().nullable(),
+      evidence: z.array(z.string()),
+      screenshots: z.array(z.string())
+    });
+    ownerInfoSchema = z.object({
+      name: z.string(),
+      tagline: z.string(),
+      bio: z.union([z.literal("auto"), z.string()]),
+      photoUrl: z.string().nullable(),
+      social: z.object({
+        github: z.string().optional(),
+        twitter: z.string().optional(),
+        linkedin: z.string().optional(),
+        blog: z.string().optional(),
+        email: z.string().optional()
+      })
+    });
+    projectEntrySchema = projectMetaSchema.extend({
+      included: z.boolean(),
+      overrideDescription: z.string().nullable(),
+      showSourceLink: z.boolean(),
+      role: z.enum(["solo", "lead", "contributor"]),
+      trackedProjectPaths: z.array(z.string()),
+      metrics: z.object({
+        users: z.string().optional(),
+        revenue: z.string().optional(),
+        downloads: z.string().optional(),
+        stars: z.number().int().optional(),
+        custom: z.record(z.string()).optional()
+      }),
+      caseStudy: projectCaseStudySchema,
+      children: z.array(projectMetaSchema).optional()
+    });
+    deployConfigSchema = z.object({
+      platform: deployPlatformSchema,
+      projectName: z.string(),
+      customDomain: z.string().optional(),
+      url: z.string().optional()
+    });
+    shipfolioSpecSchema = z.object({
+      version: z.string(),
+      generatedAt: z.string(),
+      engine: engineTypeSchema,
+      framework: z.literal("next"),
+      style: styleConfigSchema,
+      owner: ownerInfoSchema,
+      projects: z.array(projectEntrySchema),
+      sections: z.array(sectionIdSchema),
+      deploy: deployConfigSchema
+    });
+    shipfolioConfigSchema = shipfolioSpecSchema.extend({
+      sitePath: z.string()
+    });
   }
 });
 
 // src/spec/builder.ts
 function buildSpec(interview) {
-  return {
-    version: "1.0.0",
+  return parseShipfolioSpec({
+    version: "1.1.0",
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     engine: interview.engine,
     framework: "next",
@@ -1240,208 +1641,114 @@ function buildSpec(interview) {
       projectName: interview.deploy.projectName,
       customDomain: interview.deploy.customDomain
     }
-  };
+  });
 }
 var init_builder = __esm({
   "src/spec/builder.ts"() {
     "use strict";
     init_esm_shims();
+    init_schema();
   }
 });
 
 // src/orchestrator/prompt-builder.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+async function loadPromptTemplate(filename) {
+  const cached = promptTemplateCache.get(filename);
+  if (cached) {
+    return cached;
+  }
+  const candidates = [
+    fileURLToPath2(new URL(`../prompts/${filename}`, import.meta.url)),
+    fileURLToPath2(new URL(`../../prompts/${filename}`, import.meta.url)),
+    fileURLToPath2(new URL(`../../../prompts/${filename}`, import.meta.url))
+  ];
+  for (const path2 of candidates) {
+    if (await fileExists(path2)) {
+      const template = await readText(path2);
+      promptTemplateCache.set(filename, template);
+      return template;
+    }
+  }
+  throw new Error(`Prompt template not found: ${filename}`);
+}
+function fillTemplate(template, replacements) {
+  return Object.entries(replacements).reduce((text4, [key, value]) => {
+    return text4.split(`{{${key}}}`).join(value);
+  }, template);
+}
 async function buildFreshPrompt(spec) {
-  let template = FRESH_BUILD_TEMPLATE;
-  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 = UPDATE_TEMPLATE;
-  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)}`
+  const template = await loadPromptTemplate("fresh-build.md");
+  const sectionsText = spec.sections.map((section) => `- ${section}`).join("\n");
+  return fillTemplate(template, {
+    SPEC_JSON: JSON.stringify(spec, null, 2),
+    THEME: spec.style.theme,
+    ACCENT_COLOR: spec.style.accentColor,
+    ANIMATION_LEVEL: spec.style.animationLevel,
+    FONT: spec.style.font,
+    SECTIONS_LIST: sectionsText
+  });
+}
+async function buildUpdatePrompt(existingConfig, diff, preparedNewProjects = [], personalInfoDiff = "No changes") {
+  const template = await loadPromptTemplate("update.md");
+  const newProjects = preparedNewProjects.length > 0 ? preparedNewProjects : diff.newProjects.map((project) => ({
+    ...project,
+    included: true,
+    overrideDescription: null,
+    showSourceLink: !!project.remoteUrl,
+    role: "solo",
+    trackedProjectPaths: [project.localPath],
+    metrics: {},
+    caseStudy: {
+      featured: false,
+      audience: null,
+      problem: null,
+      solution: null,
+      impact: null,
+      evidence: [],
+      screenshots: []
+    }
+  }));
+  const newProjectsText = newProjects.length > 0 ? newProjects.map(
+    (project) => `- ${project.name}: ${project.overrideDescription || project.description}
+  Tech: ${project.techStack.join(", ")}
+  Demo: ${project.demoUrl || "none"}
+  Featured: ${project.caseStudy.featured}
+  Case study: ${JSON.stringify(project.caseStudy)}
+  README excerpt: ${(project.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}`
+    (update) => `- ${update.project.name}: ${update.newCommits} new commits
+  README changed: ${update.readmeChanged}
+  Dependencies changed: ${update.depsChanged}
+  Changed paths: ${update.changedPaths.join(", ") || "none"}
+  Removed paths: ${update.removedPaths.join(", ") || "none"}
+  Case study: ${JSON.stringify(update.project.caseStudy)}`
   ).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 FRESH_BUILD_TEMPLATE, UPDATE_TEMPLATE;
+  const removedProjectsText = diff.removedProjects.length > 0 ? diff.removedProjects.map((project) => `- ${project.name}`).join("\n") : "None";
+  return fillTemplate(template, {
+    EXISTING_CONFIG_JSON: JSON.stringify(existingConfig, null, 2),
+    NEW_PROJECTS: newProjectsText,
+    UPDATED_PROJECTS: updatedProjectsText,
+    REMOVED_PROJECTS: removedProjectsText,
+    PERSONAL_INFO_DIFF: personalInfoDiff
+  });
+}
+var promptTemplateCache;
 var init_prompt_builder = __esm({
   "src/orchestrator/prompt-builder.ts"() {
     "use strict";
     init_esm_shims();
-    FRESH_BUILD_TEMPLATE = `# Task
-
-Generate a complete, production-ready personal portfolio website.
-All data and design preferences are provided in the spec below.
-Output a fully working Next.js project that builds and deploys as a static site.
-
-# Spec
-
-{{SPEC_JSON}}
-
-# Technical Requirements
-
-- Next.js 15 with App Router and TypeScript
-- Tailwind CSS v4 for styling
-- shadcn/ui components (initialize with \`npx shadcn@latest init --yes\`)
-- Static export: set \`output: 'export'\` in next.config.ts
-- Build command: \`npm run build\` producing \`out/\` directory
-- Zero external API calls at runtime -- all data is embedded in source
-- All project data in \`src/data/projects.ts\` as typed constants
-- Include \`@media print\` stylesheet in \`src/app/globals.css\` for PDF export
-- Responsive: mobile-first with Tailwind breakpoints (sm, md, lg, xl)
-- Lighthouse performance score 95+
-- Semantic HTML with ARIA labels and keyboard navigation
-- No emoji anywhere in text, UI, code, or comments
-- Use lucide-react for icons
-
-# Design Direction
-
-- Theme: {{THEME}}
-- Accent color: {{ACCENT_COLOR}}
-- Animation level: {{ANIMATION_LEVEL}}
-- Font: {{FONT}}
-
-Design guidelines:
-- Typography-driven layout with large, bold headings
-- Generous whitespace between sections
-- Single accent color for interactive elements and highlights only
-- Project cards should feel substantial but clean
-- The site must look hand-crafted, not template-generated
-- Dark themes: use zinc/slate backgrounds, not pure black
-- Light themes: use warm whites and subtle grays
-
-# Content Generation
-
-For each project in the spec:
-- Write a 2-3 sentence narrative description based on the README content and tech stack
-- Focus on what it does and why it matters
-- If user provided an override description, use that instead
-- Maintain consistent voice across all descriptions
-
-For the bio (if set to "auto"):
-- Generate a professional, authentic bio based on the project portfolio
-- Emphasize shipping velocity and breadth
-- Tone: confident, direct, no buzzwords or fluff
-
-# Sections to Include
-
-{{SECTIONS_LIST}}
-
-Hero and Projects are always included. Additional sections as specified.
-
-# Print / PDF Styles
-
-In globals.css, add @media print rules:
-- Single-column layout
-- Hide navigation, footer, animations
-- Preserve background colors (user will print with backgrounds enabled)
-- Show link URLs inline: \`a[href]::after { content: " (" attr(href) ")"; }\`
-- Avoid page breaks inside project cards
-- A4-friendly margins and font sizes
-
-# File Structure to Generate
-
-\`\`\`
-next.config.ts
-package.json
-tailwind.config.ts
-tsconfig.json
-postcss.config.mjs
-components.json
-src/app/layout.tsx
-src/app/page.tsx
-src/app/globals.css
-src/components/ui/  (shadcn components as needed)
-src/components/hero.tsx
-src/components/project-card.tsx
-src/components/project-grid.tsx
-src/components/skills.tsx
-src/components/about.tsx
-src/components/timeline.tsx
-src/components/contact.tsx
-src/components/navigation.tsx
-src/components/footer.tsx
-src/data/projects.ts
-src/data/owner.ts
-src/lib/utils.ts
-public/favicon.svg
-shipfolio.config.json
-\`\`\`
-
-# Important
-
-- Generate ALL files needed for the project to build successfully
-- Include all shadcn/ui component files that are referenced
-- The \`package.json\` must include all dependencies
-- \`npm install && npm run build\` must succeed without errors
-- Do not use next/image (incompatible with static export) -- use standard <img> tags
-- Do not use features that require a server (API routes, middleware, ISR)
-`;
-    UPDATE_TEMPLATE = `# Task
-
-Update an existing portfolio website previously generated by shipfolio.
-You must preserve the existing design system, layout structure, component
-architecture, and any custom modifications the user has made.
-
-# Existing Site Configuration
-
-{{EXISTING_CONFIG_JSON}}
-
-# Changes to Apply
-
-## New Projects to Add
-{{NEW_PROJECTS}}
-
-## Projects to Update (new commits since last scan)
-{{UPDATED_PROJECTS}}
-
-## Projects to Remove
-{{REMOVED_PROJECTS}}
-
-## Updated Personal Info
-{{PERSONAL_INFO_DIFF}}
-
-# Rules
-
-1. Do NOT change the overall layout, color scheme, or design system
-2. Do NOT reorganize existing components or rename files
-3. Only modify files that need changes for the specified updates
-4. For new projects: follow the exact same card format and component pattern
-   as existing project cards
-5. Preserve all custom CSS, custom components, and manual edits
-6. Update src/data/projects.ts with new/changed/removed project data
-7. Update src/data/owner.ts if personal info changed
-8. Update shipfolio.config.json with new timestamps and project list
-9. If a new section type is needed, create it following the existing
-   component patterns and design tokens in the codebase
-10. No emoji anywhere
-
-# Technical Notes
-
-- The site uses Next.js 15 + Tailwind CSS + shadcn/ui
-- Static export via \`output: 'export'\` in next.config.ts
-- Do not break the build -- \`npm run build\` must succeed
-- Do not add new dependencies unless absolutely necessary
-- Keep the existing @media print styles working
-`;
+    init_fs();
+    promptTemplateCache = /* @__PURE__ */ new Map();
   }
 });
 
 // src/utils/exec.ts
-import { execa } from "execa";
-async function run(command, args, options) {
+import {
+  execa
+} from "execa";
+function run(command, args, options) {
   return execa(command, args, {
     stdio: "pipe",
     ...options
@@ -1460,7 +1767,16 @@ async function runWithOutput(command, args, options) {
     stdio: "pipe",
     ...options
   });
-  return result.stdout;
+  if (typeof result.stdout === "string") {
+    return result.stdout;
+  }
+  if (result.stdout instanceof Uint8Array) {
+    return Buffer.from(result.stdout).toString("utf-8");
+  }
+  if (Array.isArray(result.stdout)) {
+    return result.stdout.join("\n");
+  }
+  return "";
 }
 var init_exec = __esm({
   "src/utils/exec.ts"() {
@@ -1537,9 +1853,11 @@ async function generateWithCodex(prompt, outputDir) {
     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], {
+    await execa3("codex", ["exec", "--full-auto", "--skip-git-repo-check", fullPrompt], {
       cwd: outputDir,
-      stdio: "pipe",
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "pipe",
       timeout: 6e5
     });
     spinner.succeed("Site generated with Codex");
@@ -1558,7 +1876,7 @@ var init_codex = __esm({
 // src/orchestrator/engines/v0.ts
 import OpenAI from "openai";
 import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join2, dirname } from "path";
+import { join as join2, dirname as dirname2 } from "path";
 import ora4 from "ora";
 async function generateWithV0(prompt, outputDir, apiKey) {
   const spinner = ora4("Generating site with v0...").start();
@@ -1592,7 +1910,7 @@ async function generateWithV0(prompt, outputDir, apiKey) {
     spinner.text = `Writing ${files.length} files...`;
     for (const file of files) {
       const filePath = join2(outputDir, file.filename);
-      await mkdir2(dirname(filePath), { recursive: true });
+      await mkdir2(dirname2(filePath), { recursive: true });
       await writeFile2(filePath, file.content, "utf-8");
     }
     const hasPkgJson = files.some((f) => f.filename === "package.json");
@@ -2310,6 +2628,44 @@ var init_draft = __esm({
   }
 });
 
+// src/spec/io.ts
+import { ZodError } from "zod";
+function formatValidationError(error) {
+  return error.issues.map((issue) => {
+    const path2 = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+    return `${path2}: ${issue.message}`;
+  }).join("; ");
+}
+function toValidationError(label, error) {
+  if (error instanceof ZodError) {
+    return new Error(`${label} is invalid: ${formatValidationError(error)}`);
+  }
+  return error instanceof Error ? error : new Error(`${label} is invalid`);
+}
+async function readShipfolioConfig(path2) {
+  try {
+    return parseShipfolioConfig(await readJson(path2));
+  } catch (error) {
+    throw toValidationError("shipfolio.config.json", error);
+  }
+}
+async function writeShipfolioConfig(path2, config) {
+  const validated = parseShipfolioConfig(config);
+  await writeJson(path2, validated);
+}
+async function writeShipfolioSpec(path2, spec) {
+  const validated = parseShipfolioSpec(spec);
+  await writeJson(path2, validated);
+}
+var init_io = __esm({
+  "src/spec/io.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_fs();
+    init_schema();
+  }
+});
+
 // src/commands/init.ts
 var init_exports = {};
 __export(init_exports, {
@@ -2318,8 +2674,45 @@ __export(init_exports, {
 import { resolve } from "path";
 import { join as join6 } from "path";
 import * as p3 from "@clack/prompts";
+function resolveEngineOption(value, available) {
+  if (!value) return void 0;
+  if (!["claude", "codex", "v0"].includes(value)) {
+    logger.warn(`Ignoring invalid engine "${value}".`);
+    return void 0;
+  }
+  const engine = value;
+  if (!available.includes(engine)) {
+    logger.warn(`Engine "${value}" is not available in the current environment.`);
+    return void 0;
+  }
+  return engine;
+}
+function resolveDeployOption(value) {
+  if (!value) return void 0;
+  if (!["cloudflare", "vercel", "local"].includes(value)) {
+    logger.warn(`Ignoring invalid deploy target "${value}".`);
+    return void 0;
+  }
+  return value;
+}
+function resolveStyleOption(value) {
+  if (!value) return void 0;
+  if (!["dark-minimal", "light-clean", "monochrome", "custom"].includes(value)) {
+    logger.warn(`Ignoring invalid theme "${value}".`);
+    return void 0;
+  }
+  return value;
+}
+function resolveAccentOption(value) {
+  if (!value) return void 0;
+  if (!/^#[0-9a-fA-F]{6}$/.test(value)) {
+    logger.warn(`Ignoring invalid accent color "${value}". Expected #RRGGBB.`);
+    return void 0;
+  }
+  return value;
+}
 async function initCommand(options) {
-  logger.header("shipfolio v1.0.9");
+  logger.header("shipfolio v1.1.0");
   logger.info("Detecting AI engines...");
   const engines = await detectEngines();
   const availableTypes = getAvailableEngineTypes(engines);
@@ -2353,8 +2746,15 @@ async function initCommand(options) {
   ]);
   logger.table(tableRows);
   logger.blank();
+  const interviewOptions = {
+    engine: resolveEngineOption(options.engine, availableTypes),
+    deploy: resolveDeployOption(options.deploy),
+    style: resolveStyleOption(options.style),
+    accent: resolveAccentOption(options.accent),
+    auto: options.auto === true
+  };
   let interviewResult;
-  const draft = await loadDraft();
+  const draft = options.auto ? null : await loadDraft();
   if (draft) {
     logger.info(t().draftFound);
     const useDraft = await p3.confirm({
@@ -2365,10 +2765,18 @@ async function initCommand(options) {
       interviewResult = draft.interviewResult;
       await clearDraft();
     } else {
-      interviewResult = await runInterview(scannedProjects, availableTypes);
+      interviewResult = await runInterview(
+        scannedProjects,
+        availableTypes,
+        interviewOptions
+      );
     }
   } else {
-    interviewResult = await runInterview(scannedProjects, availableTypes);
+    interviewResult = await runInterview(
+      scannedProjects,
+      availableTypes,
+      interviewOptions
+    );
   }
   await saveDraft(interviewResult, true);
   const spec = buildSpec(interviewResult);
@@ -2384,15 +2792,9 @@ async function initCommand(options) {
       process.exit(1);
     }
   }
-  if (!options.noPdf) {
-    try {
-      await exportPdf(outputDir);
-    } catch {
-      logger.warn("PDF export skipped due to error.");
-    }
-  }
   let shouldDeploy = spec.deploy.platform !== "local";
-  if (!options.noPreview) {
+  const shouldPreview = !options.noPreview && !options.auto;
+  if (shouldPreview) {
     const server = await startPreviewServer(outputDir);
     logger.blank();
     if (shouldDeploy) {
@@ -2410,6 +2812,13 @@ async function initCommand(options) {
       server.close();
     }
   }
+  if (!options.noPdf) {
+    try {
+      await exportPdf(outputDir);
+    } catch {
+      logger.warn("PDF export skipped due to error.");
+    }
+  }
   if (shouldDeploy) {
     try {
       const url = await deploy(
@@ -2426,7 +2835,7 @@ async function initCommand(options) {
       logger.info("You can retry later with: npx shipfolio deploy --site " + outputDir);
     }
   }
-  await writeJson(join6(outputDir, "shipfolio.config.json"), {
+  await writeShipfolioConfig(join6(outputDir, "shipfolio.config.json"), {
     ...spec,
     sitePath: outputDir
   });
@@ -2457,6 +2866,7 @@ var init_init = __esm({
     init_logger();
     init_draft();
     init_i18n();
+    init_io();
   }
 });
 
@@ -2468,38 +2878,113 @@ import { Command } from "commander";
 // src/commands/update.ts
 init_esm_shims();
 init_scanner();
-import { resolve as resolve2, dirname as dirname2 } from "path";
+import { resolve as resolve2, dirname as dirname3 } from "path";
 
 // src/spec/diff.ts
 init_esm_shims();
+init_project_utils();
 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 trackedOldPaths = /* @__PURE__ */ new Set();
   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;
+  for (const oldProject of oldConfig.projects) {
+    const trackedPaths = getTrackedProjectPaths(oldProject);
+    for (const trackedPath of trackedPaths) {
+      trackedOldPaths.add(trackedPath);
+    }
+    const currentMatches = trackedPaths.map((path2) => newProjectMap.get(path2)).filter((project) => Boolean(project));
+    const removedPaths = trackedPaths.filter((path2) => !newProjectMap.has(path2));
+    if (currentMatches.length === 0) {
+      removedProjects.push(oldProject);
+      continue;
+    }
+    if (trackedPaths.length > 1) {
+      const mergedMeta = buildMergedProjectMeta(currentMatches, oldProject.name);
+      const oldChildrenByPath = new Map(
+        (oldProject.children || []).map((child) => [child.localPath, child])
+      );
+      const oldTrackingSignature = oldProject.children && oldProject.children.length > 0 ? buildTrackingSignature(oldProject.children) : oldProject.lastScannedCommit;
+      let readmeChanged = removedPaths.length > 0;
+      let depsChanged = removedPaths.length > 0;
+      let newCommits = 0;
+      for (const currentProject2 of currentMatches) {
+        const oldChild = oldChildrenByPath.get(currentProject2.localPath);
+        if (!oldChild) {
+          readmeChanged = true;
+          depsChanged = true;
+          newCommits += currentProject2.totalCommits;
+          continue;
+        }
+        if (currentProject2.readmeContent !== oldChild.readmeContent) {
+          readmeChanged = true;
+        }
+        if (JSON.stringify(currentProject2.techStack) !== JSON.stringify(oldChild.techStack)) {
+          depsChanged = true;
+        }
+        newCommits += Math.max(
+          currentProject2.totalCommits - oldChild.totalCommits,
+          0
+        );
+      }
+      const changedPaths = currentMatches.filter((currentProject2) => {
+        const oldChild = oldChildrenByPath.get(currentProject2.localPath);
+        if (!oldChild) return true;
+        return currentProject2.lastScannedCommit !== oldChild.lastScannedCommit;
+      }).map((project) => project.localPath);
+      const hasUpdate = removedPaths.length > 0 || trackedPaths.length !== currentMatches.length || mergedMeta.lastScannedCommit !== oldTrackingSignature || readmeChanged || depsChanged;
+      if (hasUpdate) {
+        updatedProjects.push({
+          project: createProjectEntry(mergedMeta, {
+            included: oldProject.included,
+            overrideDescription: oldProject.overrideDescription,
+            showSourceLink: oldProject.showSourceLink,
+            role: oldProject.role,
+            metrics: oldProject.metrics,
+            caseStudy: oldProject.caseStudy,
+            trackedProjectPaths: currentMatches.map((project) => project.localPath),
+            children: currentMatches
+          }),
+          newCommits,
+          readmeChanged,
+          depsChanged,
+          changedPaths,
+          removedPaths
+        });
+      } else {
+        unchangedProjects.push(oldProject);
+      }
+      continue;
+    }
+    const currentProject = currentMatches[0];
+    if (currentProject.lastScannedCommit !== oldProject.lastScannedCommit) {
+      const newCommits = currentProject.totalCommits - oldProject.totalCommits;
       updatedProjects.push({
-        project: meta,
+        project: createProjectEntry(currentProject, {
+          included: oldProject.included,
+          overrideDescription: oldProject.overrideDescription,
+          showSourceLink: oldProject.showSourceLink,
+          role: oldProject.role,
+          metrics: oldProject.metrics,
+          caseStudy: oldProject.caseStudy,
+          trackedProjectPaths: trackedPaths,
+          children: oldProject.children
+        }),
         newCommits: Math.max(newCommits, 0),
-        readmeChanged: meta.readmeContent !== oldProject.readmeContent,
-        depsChanged: JSON.stringify(meta.techStack) !== JSON.stringify(oldProject.techStack)
+        readmeChanged: currentProject.readmeContent !== oldProject.readmeContent,
+        depsChanged: JSON.stringify(currentProject.techStack) !== JSON.stringify(oldProject.techStack),
+        changedPaths: [currentProject.localPath],
+        removedPaths
       });
     } else {
       unchangedProjects.push(oldProject);
     }
   }
-  for (const [path2, project] of oldProjectMap) {
-    if (!newProjectMap.has(path2)) {
-      removedProjects.push(project);
+  for (const [path2, meta] of newProjectMap) {
+    if (!trackedOldPaths.has(path2)) {
+      newProjects.push(meta);
     }
   }
   return {
@@ -2518,7 +3003,54 @@ init_deployer();
 init_pdf();
 init_fs();
 init_logger();
+init_io();
+init_project_utils();
+init_questions();
+init_interviewer();
+init_i18n();
 import * as p4 from "@clack/prompts";
+function parseCommaSeparatedList2(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function buildPersonalInfoDiff(previousOwner, nextOwner, previousSections, nextSections) {
+  const changes = [];
+  if (previousOwner.name !== nextOwner.name) {
+    changes.push(`Name: ${previousOwner.name || "none"} -> ${nextOwner.name || "none"}`);
+  }
+  if (previousOwner.tagline !== nextOwner.tagline) {
+    changes.push(`Tagline: ${previousOwner.tagline || "none"} -> ${nextOwner.tagline || "none"}`);
+  }
+  if (previousOwner.bio !== nextOwner.bio) {
+    changes.push("Bio updated");
+  }
+  if (previousOwner.photoUrl !== nextOwner.photoUrl) {
+    changes.push(`Photo URL: ${previousOwner.photoUrl || "none"} -> ${nextOwner.photoUrl || "none"}`);
+  }
+  const socialKeys = [
+    "github",
+    "twitter",
+    "linkedin",
+    "blog",
+    "email"
+  ];
+  for (const key of socialKeys) {
+    if (previousOwner.social[key] !== nextOwner.social[key]) {
+      changes.push(`${key}: ${previousOwner.social[key] || "none"} -> ${nextOwner.social[key] || "none"}`);
+    }
+  }
+  if (JSON.stringify(previousSections) !== JSON.stringify(nextSections)) {
+    changes.push(`Sections: ${previousSections.join(", ")} -> ${nextSections.join(", ")}`);
+  }
+  if (changes.length === 0) {
+    return "No changes";
+  }
+  return [
+    ...changes,
+    "",
+    `Final owner: ${JSON.stringify(nextOwner, null, 2)}`,
+    `Final sections: ${nextSections.join(", ")}`
+  ].join("\n");
+}
 async function updateCommand(options) {
   logger.header("shipfolio update");
   const siteDir = resolve2(options.site);
@@ -2538,7 +3070,7 @@ async function updateCommand(options) {
     await initCommand2({ output: siteDir });
     return;
   }
-  const config = await readJson(configPath);
+  const config = await readShipfolioConfig(configPath);
   const generatedDate = config.generatedAt?.slice(0, 10) || "unknown";
   logger.info(
     `Site: ${config.deploy.projectName || "local"} (generated ${generatedDate})`
@@ -2551,7 +3083,13 @@ async function updateCommand(options) {
     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) => dirname2(p6.localPath)))];
+  const scanDirs = options.scan?.map((d) => resolve2(d)) || [
+    ...new Set(
+      config.projects.flatMap(
+        (project) => getTrackedProjectPaths(project).map((path2) => dirname3(path2))
+      )
+    )
+  ];
   const scannedProjects = await scanProjects(scanDirs);
   const diff = computeDiff(config, scannedProjects);
   logger.header("Changes detected:");
@@ -2564,9 +3102,16 @@ async function updateCommand(options) {
   if (diff.updatedProjects.length > 0) {
     logger.plain("  Updated:");
     for (const upd of diff.updatedProjects) {
+      const changedSummary = upd.changedPaths.length > 0 ? `    paths: ${upd.changedPaths.join(", ")}` : "";
       logger.plain(
         `    ~ ${upd.project.name}    ${upd.newCommits} new commits`
       );
+      if (changedSummary) {
+        logger.plain(changedSummary);
+      }
+      if (upd.removedPaths.length > 0) {
+        logger.plain(`    removed: ${upd.removedPaths.join(", ")}`);
+      }
     }
   }
   if (diff.removedProjects.length > 0) {
@@ -2586,8 +3131,251 @@ async function updateCommand(options) {
   if (p4.isCancel(proceed) || !proceed) {
     process.exit(0);
   }
+  const preparedNewProjects = [];
+  for (const project of diff.newProjects) {
+    logger.plain(`
+  ${t().configuring(project.name)}`);
+    const overrideDesc = await p4.text({
+      message: t().descriptionFor(project.name),
+      placeholder: project.description?.slice(0, 80) || t().descriptionPlaceholder,
+      defaultValue: ""
+    });
+    if (p4.isCancel(overrideDesc)) process.exit(0);
+    const demoUrl = await p4.text({
+      message: t().demoUrlFor(project.name),
+      placeholder: project.demoUrl || "none",
+      defaultValue: project.demoUrl || ""
+    });
+    if (p4.isCancel(demoUrl)) process.exit(0);
+    const showSource = await p4.confirm({
+      message: t().showSourceFor(project.name),
+      initialValue: !!project.remoteUrl
+    });
+    if (p4.isCancel(showSource)) process.exit(0);
+    const role = await p4.select({
+      message: t().roleFor(project.name),
+      options: ROLE_OPTIONS()
+    });
+    if (p4.isCancel(role)) process.exit(0);
+    const metricsInput = await p4.text({
+      message: t().metricsFor(project.name),
+      placeholder: t().optional,
+      defaultValue: ""
+    });
+    if (p4.isCancel(metricsInput)) process.exit(0);
+    const featured = await p4.confirm({
+      message: t().featureProjectFor(project.name),
+      initialValue: false
+    });
+    if (p4.isCancel(featured)) process.exit(0);
+    const addCaseStudyDetails = await p4.confirm({
+      message: t().caseStudyDetailsFor(project.name),
+      initialValue: false
+    });
+    if (p4.isCancel(addCaseStudyDetails)) process.exit(0);
+    let audience = null;
+    let problem = null;
+    let solution = null;
+    let impact = null;
+    let evidence = [];
+    let screenshots = [];
+    if (addCaseStudyDetails) {
+      const audienceInput = await p4.text({
+        message: t().audienceFor(project.name),
+        placeholder: t().optional,
+        defaultValue: ""
+      });
+      if (p4.isCancel(audienceInput)) process.exit(0);
+      audience = audienceInput || null;
+      const problemInput = await p4.text({
+        message: t().problemFor(project.name),
+        placeholder: t().optional,
+        defaultValue: ""
+      });
+      if (p4.isCancel(problemInput)) process.exit(0);
+      problem = problemInput || null;
+      const solutionInput = await p4.text({
+        message: t().solutionFor(project.name),
+        placeholder: t().optional,
+        defaultValue: ""
+      });
+      if (p4.isCancel(solutionInput)) process.exit(0);
+      solution = solutionInput || null;
+      const impactInput = await p4.text({
+        message: t().impactFor(project.name),
+        placeholder: t().optional,
+        defaultValue: metricsInput || ""
+      });
+      if (p4.isCancel(impactInput)) process.exit(0);
+      impact = impactInput || null;
+      const evidenceInput = await p4.text({
+        message: t().evidenceFor(project.name),
+        placeholder: t().optional,
+        defaultValue: ""
+      });
+      if (p4.isCancel(evidenceInput)) process.exit(0);
+      evidence = parseCommaSeparatedList2(evidenceInput);
+      const screenshotsInput = await p4.text({
+        message: t().screenshotsFor(project.name),
+        placeholder: t().optional,
+        defaultValue: ""
+      });
+      if (p4.isCancel(screenshotsInput)) process.exit(0);
+      screenshots = parseCommaSeparatedList2(screenshotsInput);
+    }
+    const metrics = metricsInput ? { custom: { summary: metricsInput } } : {};
+    preparedNewProjects.push(
+      createProjectEntry(
+        {
+          ...project,
+          demoUrl: demoUrl || project.demoUrl
+        },
+        {
+          overrideDescription: overrideDesc || null,
+          showSourceLink: showSource,
+          role,
+          metrics,
+          caseStudy: {
+            ...defaultCaseStudy(featured),
+            audience,
+            problem,
+            solution,
+            impact,
+            evidence,
+            screenshots
+          }
+        }
+      )
+    );
+  }
+  let nextOwner = config.owner;
+  const shouldUpdateProfile = await p4.confirm({
+    message: t().updateProfilePrompt,
+    initialValue: false
+  });
+  if (p4.isCancel(shouldUpdateProfile)) {
+    process.exit(0);
+  }
+  if (shouldUpdateProfile) {
+    const name = await p4.text({
+      message: t().fullName,
+      defaultValue: config.owner.name,
+      validate: (v) => v.length === 0 ? t().nameRequired : void 0
+    });
+    if (p4.isCancel(name)) process.exit(0);
+    const tagline = await p4.text({
+      message: t().tagline,
+      placeholder: t().taglinePlaceholder,
+      defaultValue: config.owner.tagline
+    });
+    if (p4.isCancel(tagline)) process.exit(0);
+    const bioChoice = await p4.select({
+      message: t().bio,
+      options: [
+        { value: "auto", label: t().bioAuto },
+        { value: "manual", label: t().bioManual }
+      ],
+      initialValue: config.owner.bio === "auto" ? "auto" : "manual"
+    });
+    if (p4.isCancel(bioChoice)) process.exit(0);
+    let bio = "auto";
+    if (bioChoice === "manual") {
+      bio = await p4.text({
+        message: t().bioPrompt,
+        defaultValue: config.owner.bio === "auto" ? "" : config.owner.bio
+      });
+      if (p4.isCancel(bio)) process.exit(0);
+    }
+    const photoUrl = await p4.text({
+      message: t().photoUrl,
+      placeholder: "https://...",
+      defaultValue: config.owner.photoUrl || ""
+    });
+    if (p4.isCancel(photoUrl)) process.exit(0);
+    const github = await p4.text({
+      message: t().githubUser,
+      defaultValue: config.owner.social.github || ""
+    });
+    if (p4.isCancel(github)) process.exit(0);
+    const twitter = await p4.text({
+      message: t().twitterHandle,
+      defaultValue: config.owner.social.twitter || ""
+    });
+    if (p4.isCancel(twitter)) process.exit(0);
+    const linkedin = await p4.text({
+      message: t().linkedinUrl,
+      defaultValue: config.owner.social.linkedin || ""
+    });
+    if (p4.isCancel(linkedin)) process.exit(0);
+    const blog = await p4.text({
+      message: t().blogUrl,
+      defaultValue: config.owner.social.blog || ""
+    });
+    if (p4.isCancel(blog)) process.exit(0);
+    const email = await p4.text({
+      message: t().contactEmail,
+      defaultValue: config.owner.social.email || ""
+    });
+    if (p4.isCancel(email)) process.exit(0);
+    nextOwner = {
+      name,
+      tagline,
+      bio,
+      photoUrl: photoUrl || null,
+      social: {
+        github: github || void 0,
+        twitter: twitter || void 0,
+        linkedin: linkedin || void 0,
+        blog: blog || void 0,
+        email: email || void 0
+      }
+    };
+  }
+  const projectedProjects = [
+    ...diff.unchangedProjects,
+    ...diff.updatedProjects.map((update) => update.project),
+    ...preparedNewProjects
+  ];
+  let nextSections = config.sections;
+  const shouldReviewSections = await p4.confirm({
+    message: t().reviewSectionsPrompt,
+    initialValue: shouldUpdateProfile
+  });
+  if (p4.isCancel(shouldReviewSections)) {
+    process.exit(0);
+  }
+  if (shouldReviewSections) {
+    const sectionOptions = getAdditionalSectionOptions(projectedProjects, nextOwner);
+    const currentAdditionalSections = config.sections.filter(
+      (section) => section !== "hero" && section !== "projects"
+    );
+    const allowedCurrentValues = currentAdditionalSections.filter(
+      (section) => sectionOptions.some((option) => option.value === section)
+    );
+    const additionalSections = sectionOptions.length > 0 ? await p4.multiselect({
+      message: t().additionalSections,
+      options: sectionOptions,
+      required: false,
+      initialValues: allowedCurrentValues
+    }) : [];
+    if (sectionOptions.length > 0 && p4.isCancel(additionalSections)) {
+      process.exit(0);
+    }
+    nextSections = ["hero", "projects", ...additionalSections];
+  }
+  const personalInfoDiff = buildPersonalInfoDiff(
+    config.owner,
+    nextOwner,
+    config.sections,
+    nextSections
+  );
   const engine = availableTypes.includes(config.engine) ? config.engine : availableTypes[0];
-  const prompt = await buildUpdatePrompt(config, diff);
+  const prompt = await buildUpdatePrompt(
+    config,
+    diff,
+    preparedNewProjects,
+    personalInfoDiff
+  );
   await generateSite(engine, prompt, siteDir);
   let buildResult = await buildSite(siteDir);
   if (!buildResult.success) {
@@ -2627,34 +3415,15 @@ async function updateCommand(options) {
   const updatedConfig = {
     ...config,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    owner: nextOwner,
+    sections: nextSections,
     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: {}
-        })
-      )
+      ...diff.updatedProjects.map((u) => u.project),
+      ...preparedNewProjects
     ]
   };
-  await writeJson(join(siteDir, "shipfolio.config.json"), updatedConfig);
+  await writeShipfolioConfig(join(siteDir, "shipfolio.config.json"), updatedConfig);
   logger.success("Update complete.");
 }
 
@@ -2663,6 +3432,7 @@ init_esm_shims();
 init_scanner();
 init_interviewer();
 init_builder();
+init_io();
 init_prompt_builder();
 init_detect();
 init_fs();
@@ -2691,7 +3461,7 @@ async function specCommand(options) {
   const outputDir = options.output || ".";
   const specPath = resolve3(outputDir, "shipfolio-spec.json");
   const promptPath = resolve3(outputDir, "shipfolio-prompt.md");
-  await writeJson(specPath, spec);
+  await writeShipfolioSpec(specPath, spec);
   await writeText(promptPath, prompt);
   logger.success(`Spec saved: ${specPath}`);
   logger.success(`Prompt saved: ${promptPath}`);
@@ -2706,6 +3476,7 @@ init_esm_shims();
 init_deployer();
 init_fs();
 init_logger();
+init_io();
 import { resolve as resolve4 } from "path";
 import * as p5 from "@clack/prompts";
 async function deployCommand(options) {
@@ -2715,7 +3486,7 @@ async function deployCommand(options) {
   let projectName;
   let customDomain;
   if (await fileExists(configPath)) {
-    const config = await readJson(configPath);
+    const config = await readShipfolioConfig(configPath);
     platform = options.platform || config.deploy.platform;
     projectName = config.deploy.projectName;
     customDomain = config.deploy.customDomain;
@@ -2785,8 +3556,8 @@ initLocale();
 var program = new Command();
 program.name("shipfolio").description(
   "Generate and deploy your personal portfolio site from local projects using AI"
-).version("1.0.9");
-program.command("init", { isDefault: true }).description("Generate a new portfolio site").option("-s, --scan <dirs...>", "Directories to scan for projects").option("-o, --output <dir>", "Output directory", "./shipfolio-site").option("--no-pdf", "Skip PDF export").option("--no-preview", "Skip local preview").action(initCommand);
+).version("1.1.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 | custom").option("--accent <hex>", "Accent color (hex)").option("--auto", "Skip prompts and use safe defaults").option("-o, --output <dir>", "Output directory", "./shipfolio-site").option("--no-pdf", "Skip PDF export").option("--no-preview", "Skip local preview").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);