create-thally-docs 0.10.78 → 0.10.79

package/dist/chunk-IZQHRVPV.js

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+import {
+  findPublicSpecs,
+  shadowNote
+} from "./chunk-KDLP27DS.js";
+import {
+  initGit,
+  installDeps,
+  runProjectCommand,
+  scaffold
+} from "./chunk-KGKSB3PU.js";
+import {
+  pruneMissingSiteLinks
+} from "./chunk-4VKRBJV2.js";
+import {
+  terminal
+} from "./chunk-L2YCVQBR.js";
+
+// src/migrate/index.ts
+import { existsSync as existsSync2, mkdirSync, mkdtempSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { setImmediate } from "timers/promises";
+import { basename, dirname, isAbsolute, join as join2, relative, resolve, sep } from "path";
+import {
+  cloneGitHubRepository,
+  hydrateRemoteApiSpecs,
+  migrateUrl,
+  parseGitHubRepositoryUrl
+} from "@thallylabs/migrate";
+
+// src/migration-work.ts
+import { Worker } from "worker_threads";
+async function runMigrationWork(request, options) {
+  const worker = new Worker(options.workerUrl ?? new URL("./migration-worker.js", import.meta.url), {
+    workerData: request,
+    stdout: true,
+    stderr: true
+  });
+  worker.stdout.resume();
+  worker.stderr.resume();
+  try {
+    return await new Promise((complete, reject) => {
+      worker.once("message", (response) => {
+        if (response.error) reject(response.error);
+        else complete(response.result);
+      });
+      worker.once("error", reject);
+      worker.once("exit", (code) => reject(new Error(`Migration worker exited before returning a result (exit ${code}).`)));
+    });
+  } finally {
+    await worker.terminate();
+  }
+}
+function convertRepository(options, workerOptions = {}) {
+  return runMigrationWork({ operation: "repository", args: [options] }, workerOptions);
+}
+function renderFiles(bundle, options, workerOptions = {}) {
+  return runMigrationWork({ operation: "render", args: [bundle, options] }, workerOptions);
+}
+function discoverUrl(options, workerOptions = {}) {
+  return runMigrationWork({ operation: "url", args: [options] }, workerOptions);
+}
+function checkContent(projectDir, workerOptions = {}) {
+  return runMigrationWork({ operation: "check", args: [projectDir] }, workerOptions);
+}
+
+// src/migrate/validate.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+async function validateMigration(projectDir, skip = false, installationFailed = false) {
+  const result = { content: "skipped", build: "skipped", messages: [], diagnostics: [] };
+  if (skip) {
+    result.messages.push("Validation was explicitly skipped; this import is not verified.");
+    return result;
+  }
+  try {
+    const isQuiet = terminal.isRich && !terminal.isVerbose;
+    await terminal.step("Validate content", async () => {
+      const checked = await checkContent(projectDir);
+      const code = checked.code;
+      result.diagnostics = checked.diagnostics;
+      if (!isQuiet) {
+        for (const issue of checked.diagnostics) {
+          const location = issue.file ? `file=${issue.file}${issue.line ? `,line=${issue.line}` : ""}` : "";
+          console.log(`::${issue.severity} ${location}::${issue.message}`);
+        }
+        const errors = checked.diagnostics.filter((issue) => issue.severity === "error").length;
+        const warnings = checked.diagnostics.length - errors;
+        console.log(`
+thally check: ${errors} error(s), ${warnings} warning(s)`);
+      }
+      if (isQuiet) {
+        for (const issue of result.diagnostics) {
+          result.messages.push(`${issue.file ? `${issue.file}${issue.line ? `:${issue.line}` : ""}: ` : ""}${issue.message}`);
+        }
+      }
+      if (code !== 0) throw new Error("Review the content diagnostics; source links are not silently rewritten.");
+    }, "Content validated");
+    result.content = "passed";
+  } catch (error) {
+    if ([130, 143].includes(error.exitCode ?? 0)) throw error;
+    result.content = "failed";
+    result.messages.push(`Content validation failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (installationFailed) {
+    result.build = "failed";
+    result.messages.push("Dependency installation failed; production build was not attempted. Review the installation output before retrying.");
+    return result;
+  }
+  const packagePath = join(projectDir, "package.json");
+  try {
+    const manifest = existsSync(packagePath) ? JSON.parse(readFileSync(packagePath, "utf8")) : void 0;
+    if (!manifest?.scripts?.build) {
+      result.messages.push("No build script is available; production rendering is not verified.");
+      return result;
+    }
+    try {
+      await terminal.step("Validate production build", (update) => runProjectCommand("npm", ["run", "build"], projectDir, 10 * 60 * 1e3, (message) => update(`Production build: ${message}`)), "Production build validated");
+      result.build = "passed";
+    } catch (error) {
+      const failure = error;
+      if (failure.output?.trim()) terminal.error(failure.output.trimEnd());
+      throw error;
+    }
+  } catch (error) {
+    if ([130, 143].includes(error.exitCode ?? 0)) throw error;
+    result.build = "failed";
+    result.messages.push(`Production build failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return result;
+}
+
+// src/migrate/index.ts
+function projectPath(projectDir, candidate) {
+  const target = resolve(projectDir, candidate);
+  const fromRoot = relative(resolve(projectDir), target);
+  if (isAbsolute(fromRoot) || fromRoot === ".." || fromRoot.startsWith(`..${sep}`)) {
+    throw new Error(`Generated migration path escapes the project: ${candidate}`);
+  }
+  return target;
+}
+function ignoreQuarantineDirectory(projectDir) {
+  const ignorePath = projectPath(projectDir, ".gitignore");
+  const existing = existsSync2(ignorePath) ? readFileSync2(ignorePath, "utf8") : "";
+  const rules = existing.split(/\r?\n/).map((line) => line.trim()).filter((line) => /^!?\/?migration-quarantine(?:\/(?:\*\*?)?)?$/.test(line));
+  if (rules.length > 0 && !rules[rules.length - 1].startsWith("!")) return;
+  const separator = existing === "" || existing.endsWith("\n") ? "" : "\n";
+  writeFileSync(ignorePath, `${existing}${separator}
+# Access-restricted pages withheld by migration: local only, never commit or deploy
+/migration-quarantine/
+`);
+}
+function readExistingConfig(projectDir) {
+  const configPath = projectPath(projectDir, "docs.json");
+  if (!existsSync2(configPath)) return void 0;
+  return JSON.parse(readFileSync2(configPath, "utf8"));
+}
+function resetFreshMigrationContent(projectDir) {
+  const contentDirectory = projectPath(projectDir, "src/content");
+  rmSync(contentDirectory, { recursive: true, force: true });
+  mkdirSync(contentDirectory, { recursive: true });
+  for (const sampleSpec of ["openapi.yaml", "openapi.json"]) {
+    rmSync(projectPath(projectDir, sampleSpec), { force: true });
+  }
+}
+async function discoverMigration(options) {
+  const url = new URL(options.sourceUrl);
+  if (url.hostname.toLowerCase() !== "github.com") {
+    return terminal.step("Discovering public documentation", () => {
+      const discovery = {
+        sourceUrl: options.sourceUrl,
+        platform: options.platform,
+        maxPages: options.maxPages
+      };
+      return options.fetcher ? migrateUrl({ ...discovery, fetcher: options.fetcher }) : discoverUrl(discovery);
+    }, "Public documentation discovered");
+  }
+  const source = parseGitHubRepositoryUrl(options.sourceUrl);
+  if (options.branch) source.branch = options.branch;
+  const temporaryRoot = mkdtempSync(join2(tmpdir(), "thally-migrate-"));
+  const cloneDir = join2(temporaryRoot, "repository");
+  try {
+    const cloneWarnings = [];
+    await terminal.step(`Cloning ${source.owner}/${source.repo}`, () => cloneGitHubRepository(source, cloneDir, cloneWarnings), "Source repository cloned");
+    const bundle = await terminal.step("Converting repository documentation", () => convertRepository({
+      repositoryDir: cloneDir,
+      sourceUrl: options.sourceUrl,
+      docsDir: options.docsDir ?? (source.docsDir || void 0),
+      platform: options.platform
+    }), "Repository documentation converted");
+    const hydrated = await terminal.step("Loading remote API specifications", () => hydrateRemoteApiSpecs(bundle, options.fetcher), "Remote API specifications loaded");
+    return cloneWarnings.length > 0 ? { ...hydrated, warnings: [...cloneWarnings, ...hydrated.warnings] } : hydrated;
+  } finally {
+    rmSync(temporaryRoot, { recursive: true, force: true });
+  }
+}
+function publicSpecWarning(projectDir, bundle) {
+  const { specs, skipped } = findPublicSpecs(projectDir);
+  if (specs.length === 0 && skipped.length === 0) return null;
+  const migrated = new Set(bundle.assets.filter((asset) => asset.projectRelative).map((asset) => basename(asset.path)));
+  const lines = [
+    ...specs.map((spec) => `${spec.path}${migrated.has(basename(spec.path)) ? " (same file name as a migrated spec)" : ""}${spec.hasHiddenOperations ? " (contains x-excluded/x-hidden operations)" : ""}${shadowNote(spec.urlPath) ? ` (answers /${spec.urlPath} in place of the filtered specification)` : ""}`),
+    ...skipped.map((path) => `${path} (too large to inspect)`)
+  ];
+  return {
+    code: "unsupported-config",
+    message: `Existing OpenAPI files under public/ are served publicly as-is: ${lines.join("; ")}. Migrated specs are written to openapi/, and re-running migration does not remove old copies from public/. Delete any old copy manually (nothing was deleted), or its hidden operations stay downloadable.`
+  };
+}
+async function migrateDocs(options) {
+  const projectDir = resolve(options.projectDir);
+  const bundle = await discoverMigration(options);
+  if (!options.into) {
+    terminal.detail("Project", projectDir);
+    await scaffold({
+      projectDir,
+      projectName: options.projectName ?? bundle.site?.name ?? "My Docs",
+      description: bundle.site?.description ?? `Documentation migrated from ${new URL(options.sourceUrl).hostname}`,
+      brandPreset: "primary",
+      // Source provenance is not the destination repository. Migrated pages
+      // live at new paths, so source URLs cannot power edit/issue actions.
+      repoUrl: "",
+      doInstall: false,
+      colors: bundle.site?.colors
+    });
+    resetFreshMigrationContent(projectDir);
+    pruneMissingSiteLinks(projectDir, new Set(bundle.pages.map((page) => page.id)));
+  } else if (!existsSync2(projectDir)) {
+    throw new Error(`Project directory "${projectDir}" does not exist. Use without --into to scaffold a new one.`);
+  }
+  if (!options.into) {
+    const starterConfig = readExistingConfig(projectDir);
+    if (starterConfig?.markdown) bundle.docsConfig.markdown ??= starterConfig.markdown;
+    if (!bundle.docsConfig.navbar?.primary) {
+      bundle.docsConfig.navbar = { ...bundle.docsConfig.navbar, primary: null };
+    }
+    bundle.docsConfig.i18n ??= { defaultLocale: "en", locales: [{ code: "en", label: "English" }] };
+  }
+  if (options.into) {
+    const stale = publicSpecWarning(projectDir, bundle);
+    if (stale) bundle.warnings.unshift(stale);
+  }
+  const rendered = await terminal.step("Rendering documentation", () => renderFiles(bundle, {
+    existingConfig: options.into ? readExistingConfig(projectDir) : void 0,
+    existingComponentRegistry: existsSync2(projectPath(projectDir, "src/mdx/custom-components.tsx")) ? readFileSync2(projectPath(projectDir, "src/mdx/custom-components.tsx"), "utf8") : void 0
+  }), "Documentation rendered");
+  await terminal.step("Writing documentation", async (update) => {
+    let written = 0;
+    for (const file of rendered) {
+      const destination = projectPath(projectDir, file.path);
+      mkdirSync(dirname(destination), { recursive: true });
+      writeFileSync(destination, file.content);
+      written += 1;
+      if (written % 32 === 0) {
+        update(`Writing documentation (${written}/${rendered.length} files)`);
+        await setImmediate();
+      }
+    }
+    if (bundle.quarantinedFiles?.length) ignoreQuarantineDirectory(projectDir);
+  }, `Imported ${bundle.pages.length} pages and ${bundle.assets.length} assets from ${bundle.platform}`);
+  const format = (warning) => `${warning.message}${warning.source ? ` (${warning.source})` : ""}`;
+  for (const warning of bundle.warnings.filter((item) => item.code !== "gated-page")) terminal.warn(format(warning));
+  const gatedWarnings = bundle.warnings.filter((item) => item.code === "gated-page");
+  if (gatedWarnings.length > 0) {
+    terminal.warn("ACCESS-RESTRICTED CONTENT \u2014 review before publishing");
+    for (const warning of gatedWarnings) terminal.warn(format(warning));
+    if (bundle.droppedGatedPages) {
+      terminal.warn(`${bundle.droppedGatedPages} access-restricted page(s) were dropped by the file limit: not published and not saved under migration-quarantine/; recover them from the source repository.`);
+    }
+    if (bundle.quarantinedFiles?.length || gatedWarnings.some((warning) => !/dashboard access settings/i.test(warning.message))) {
+      terminal.warn("Before publishing, review migration-quarantine/assets/ and the dashboard access settings of the source site.");
+    }
+  }
+  let installationFailed = false;
+  if (!options.skipValidation) terminal.info("Migration validation runs project code locally, including imported MDX and components.");
+  if (!options.into && !options.skipValidation) {
+    try {
+      await installDeps(projectDir);
+    } catch (error) {
+      const exitCode = error.exitCode;
+      if (exitCode === 130 || exitCode === 143) throw error;
+      installationFailed = true;
+    }
+  }
+  terminal.info("Validating imported documentation...");
+  const validation = await validateMigration(projectDir, options.skipValidation, installationFailed);
+  const quarantinedPages = (bundle.quarantinedFiles ?? []).filter((file) => /\.mdx?$/i.test(file.path)).length;
+  const reportPath = projectPath(projectDir, "migration-report.json");
+  writeFileSync(reportPath, `${JSON.stringify({
+    version: 1,
+    sourceUrl: `${new URL(options.sourceUrl).origin}${new URL(options.sourceUrl).pathname}`,
+    platform: bundle.platform,
+    pages: bundle.pages.length,
+    assets: bundle.assets.length,
+    components: bundle.componentFiles?.length ?? 0,
+    quarantined: quarantinedPages,
+    quarantinedAssets: (bundle.quarantinedFiles?.length ?? 0) - quarantinedPages,
+    droppedGatedPages: bundle.droppedGatedPages ?? 0,
+    warnings: bundle.warnings,
+    validation
+  }, null, 2)}
+`);
+  for (const message of validation.messages) terminal.warn(message);
+  terminal.detail("Migration report", reportPath);
+  if (validation.content === "passed" && validation.build === "passed") {
+    terminal.success(`Content and production build passed.${bundle.warnings.length ? " Review the migration warnings for compatibility limitations." : ""}`);
+  } else {
+    terminal.warn("Import retained, but validation is incomplete. Do not publish without reviewing the report.");
+  }
+  if (!options.into) await initGit(projectDir);
+  return {
+    pagesWritten: bundle.pages.length,
+    assetsWritten: bundle.assets.length,
+    projectDir,
+    platform: bundle.platform,
+    warnings: bundle.warnings,
+    validation,
+    reportPath
+  };
+}
+
+export {
+  migrateDocs
+};

package/dist/chunk-J7255UQA.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+// src/docs-json.ts
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+function readDocsJson(projectDir) {
+  const docsPath = join(projectDir, "docs.json");
+  const raw = readFileSync(docsPath, "utf8");
+  return JSON.parse(raw);
+}
+function writeDocsJson(projectDir, config) {
+  const docsPath = join(projectDir, "docs.json");
+  writeFileSync(docsPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+function resetTrackingConfig(projectDir) {
+  const config = readDocsJson(projectDir);
+  if (config.tracking) {
+    delete config.tracking;
+    writeDocsJson(projectDir, config);
+  }
+}
+function writeTrackingConfig(projectDir, repos) {
+  if (repos.length === 0) return;
+  const config = readDocsJson(projectDir);
+  config.tracking = { repos: repos.map((r) => ({ owner: r.owner, repo: r.repo, branch: "main" })) };
+  writeDocsJson(projectDir, config);
+}
+
+export {
+  readDocsJson,
+  writeDocsJson,
+  resetTrackingConfig,
+  writeTrackingConfig
+};

package/dist/chunk-KDLP27DS.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+// src/public-specs.ts
+import { lstatSync, readFileSync, readdirSync, statSync } from "fs";
+import { join, relative } from "path";
+import { parse as parseYaml } from "yaml";
+var OPENAPI_METHODS = ["get", "post", "put", "patch", "delete", "options", "head", "trace"];
+var SPEC_EXTENSIONS = /\.(?:json|ya?ml)$/i;
+var MAX_SPEC_BYTES = 1e7;
+var MAX_DEPTH = 8;
+var MAX_ENTRIES = 5e3;
+function shadowNote(urlPath) {
+  return urlPath === "openapi.json" || urlPath === "openapi.yaml" ? ` It is also served at /${urlPath} in place of the filtered specification, so visitors get this raw file there.` : "";
+}
+var isFlagged = (value) => value === true || value === "true";
+function specHasHiddenOperations(spec, overrides) {
+  if (overrides && typeof overrides === "object" && Object.values(overrides).some((o) => o?.hidden === true)) return true;
+  const components = spec.components;
+  for (const group of [spec.paths, spec.webhooks, spec["x-webhooks"], components?.pathItems]) {
+    if (!group || typeof group !== "object") continue;
+    for (const item of Object.values(group)) {
+      if (!item || typeof item !== "object") continue;
+      const record = item;
+      if (isFlagged(record["x-excluded"]) || isFlagged(record["x-hidden"])) return true;
+      for (const method of OPENAPI_METHODS) {
+        const op = record[method];
+        if (op && typeof op === "object" && (isFlagged(op["x-excluded"]) || isFlagged(op["x-hidden"]))) return true;
+      }
+    }
+  }
+  return false;
+}
+function findPublicSpecs(projectDir) {
+  const publicDir = join(projectDir, "public");
+  const scan = { specs: [], skipped: [] };
+  let seen = 0;
+  const walk = (dir, depth) => {
+    let entries;
+    try {
+      entries = readdirSync(dir).sort();
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (++seen > MAX_ENTRIES) return;
+      const full = join(dir, entry);
+      let stat;
+      try {
+        stat = lstatSync(full);
+        if (stat.isSymbolicLink()) {
+          const target = statSync(full);
+          if (!target.isFile()) continue;
+          stat = target;
+        }
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        if (depth < MAX_DEPTH && entry !== "node_modules") walk(full, depth + 1);
+        continue;
+      }
+      if (!stat.isFile() || !SPEC_EXTENSIONS.test(entry)) continue;
+      const urlPath = relative(publicDir, full).split(/[\\/]/).join("/");
+      if (stat.size > MAX_SPEC_BYTES) {
+        scan.skipped.push(`public/${urlPath}`);
+        continue;
+      }
+      try {
+        const raw = readFileSync(full, "utf8");
+        const parsed = /\.json$/i.test(entry) ? JSON.parse(raw) : parseYaml(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+        const spec = parsed;
+        if (typeof spec.openapi !== "string" && typeof spec.swagger !== "string") continue;
+        scan.specs.push({ path: `public/${urlPath}`, urlPath, hasHiddenOperations: specHasHiddenOperations(spec) });
+      } catch {
+      }
+    }
+  };
+  walk(publicDir, 0);
+  return scan;
+}
+
+export {
+  shadowNote,
+  specHasHiddenOperations,
+  findPublicSpecs
+};

package/dist/chunk-KGKSB3PU.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+import {
+  personalizeStarter,
+  updateEnvExample
+} from "./chunk-4VKRBJV2.js";
+import {
+  resetTrackingConfig,
+  writeTrackingConfig
+} from "./chunk-J7255UQA.js";
+import {
+  downloadStarter
+} from "./chunk-WWIATVAD.js";
+import {
+  terminal
+} from "./chunk-L2YCVQBR.js";
+
+// src/scaffold.ts
+import { existsSync, mkdirSync, readdirSync } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/utils.ts
+import { execFileSync, execSync, spawn } from "child_process";
+import { resolve } from "path";
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+}
+async function runProjectCommand(command, args, cwd, timeout, onProgress) {
+  const isQuiet = terminal.isRich && !terminal.isVerbose;
+  await new Promise((complete, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      detached: process.platform !== "win32",
+      stdio: isQuiet ? ["ignore", "pipe", "pipe"] : "inherit",
+      // Windows resolves npm via a .cmd shim; command and arguments here are
+      // fixed by the toolchain, never interpolated from imported content.
+      shell: process.platform === "win32" && command === "npm"
+    });
+    let tail = Buffer.alloc(0);
+    let omitted = false;
+    const collect = (chunk) => {
+      const combined = Buffer.concat([tail, chunk]);
+      omitted ||= combined.length > 64 * 1024;
+      tail = combined.subarray(Math.max(0, combined.length - 64 * 1024));
+      const stages = chunk.toString("utf8").split(/[\r\n]+/).map((line) => line.trim()).filter((line) => /^(?:>|npm (?:warn|error)|added \d+|.*(?:Creating an optimized|Compiled successfully|Collecting page data|Generating static pages|Finalizing page optimization))/.test(line));
+      if (stages.length) onProgress?.(stages.at(-1));
+    };
+    child.stdout?.on("data", collect);
+    child.stderr?.on("data", collect);
+    let interrupted;
+    let didTimeOut = false;
+    let escalation;
+    const killTree = (signal) => {
+      if (!child.pid) return;
+      try {
+        if (process.platform === "win32") {
+          execFileSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+        } else {
+          process.kill(-child.pid, signal);
+        }
+      } catch {
+        child.kill(signal);
+      }
+    };
+    const interrupt = (signal) => {
+      interrupted = signal;
+      killTree(signal);
+      escalation = setTimeout(() => killTree("SIGKILL"), 1e3);
+    };
+    const onInterrupt = () => interrupt("SIGINT");
+    const onTerminate = () => interrupt("SIGTERM");
+    const onExit = () => killTree("SIGKILL");
+    const deadline = timeout ? setTimeout(() => {
+      didTimeOut = true;
+      interrupt("SIGTERM");
+    }, timeout) : void 0;
+    process.once("SIGINT", onInterrupt);
+    process.once("SIGTERM", onTerminate);
+    process.once("exit", onExit);
+    const cleanup = () => {
+      if (interrupted) killTree("SIGKILL");
+      if (deadline) clearTimeout(deadline);
+      if (escalation) clearTimeout(escalation);
+      process.removeListener("SIGINT", onInterrupt);
+      process.removeListener("SIGTERM", onTerminate);
+      process.removeListener("exit", onExit);
+    };
+    child.once("error", (error) => {
+      cleanup();
+      reject(error);
+    });
+    child.once("close", (code, signal) => {
+      cleanup();
+      if (code === 0 && !interrupted) {
+        complete();
+        return;
+      }
+      const failure = new Error(`${command} ${args.join(" ")} failed (${interrupted ?? signal ?? `exit ${code}`}).`);
+      if (didTimeOut) failure.message += ` Timed out after ${timeout}ms.`;
+      if (interrupted && !didTimeOut) failure.exitCode = interrupted === "SIGINT" ? 130 : 143;
+      failure.output = `${omitted ? "Earlier output omitted; use --verbose for the full log.\n" : ""}${tail.toString("utf8")}`;
+      reject(failure);
+    });
+  });
+}
+async function initGit(targetDir) {
+  try {
+    await terminal.step("Initialize Git repository", async (update) => {
+      update("Initialize Git repository");
+      await runProjectCommand("git", ["init"], targetDir);
+      update("Stage generated project files");
+      await runProjectCommand("git", ["add", "-A"], targetDir);
+      update("Create initial project commit");
+      await runProjectCommand("git", ["commit", "-m", "Initial commit from create-thally-docs"], targetDir);
+    }, "Git repository initialized");
+  } catch (error) {
+    if (error.exitCode === 130 || error.exitCode === 143) throw error;
+    const failure = error;
+    const diagnostic = [failure.output, failure.stdout, failure.stderr].filter(Boolean).map((value) => String(value)).join("\n").slice(-64 * 1024);
+    if (diagnostic.trim()) terminal.error(diagnostic.trimEnd());
+    terminal.warn("Could not finish Git setup. Run git status in the project directory, fix the reported issue, then retry the commit.");
+  }
+}
+async function installDeps(targetDir) {
+  try {
+    await terminal.step("Install dependencies", (update) => runProjectCommand("npm", [
+      "install",
+      "--prefer-offline",
+      "--no-audit",
+      "--no-fund",
+      "--progress=false"
+    ], targetDir, void 0, (message) => update(`Install dependencies: ${message}`)), "Dependencies installed");
+  } catch (error) {
+    const failure = error;
+    if (failure.output?.trim()) terminal.error(failure.output.trimEnd());
+    throw error;
+  }
+}
+function quoteDirectory(directory) {
+  const absolute = resolve(directory);
+  return process.platform === "win32" ? `"${absolute.replace(/"/g, '""')}"` : `'${absolute.replace(/'/g, "'\\''")}'`;
+}
+function previewCommand(directory, needsInstall = false) {
+  return `cd ${quoteDirectory(directory)} && ${needsInstall ? "npm install && " : ""}npm run dev`;
+}
+function logo(version) {
+  terminal.intro("init", version, "Build and publish docs for people and AI tools.");
+}
+function success(projectDir, projectName, dependenciesInstalled) {
+  terminal.detail("Project", projectName);
+  terminal.detail("Output", projectDir);
+  terminal.section("Make it yours", [
+    "src/content/      Write your documentation",
+    "docs.json         Set up navigation",
+    "src/data/site.ts  Name, links, and branding"
+  ]);
+  terminal.outro("Your docs project is ready. The dev server will print your preview URL.");
+  terminal.nextAction("Preview locally", previewCommand(projectDir, !dependenciesInstalled));
+}
+
+// src/scaffold.ts
+async function scaffold(options) {
+  const {
+    projectDir,
+    projectName,
+    description,
+    brandPreset,
+    repoUrl,
+    doInstall,
+    enableAiChat = true,
+    i18nLocales,
+    trackRepos,
+    colors
+  } = options;
+  const targetDir = resolve2(projectDir);
+  if (existsSync(targetDir) && readdirSync(targetDir).length > 0) {
+    throw new Error(`Directory "${targetDir}" already exists and is not empty.`);
+  }
+  mkdirSync(targetDir, { recursive: true });
+  const slug = slugify(projectName);
+  await terminal.step(
+    "Downloading starter",
+    () => downloadStarter(targetDir, projectName, void 0, { announce: false }),
+    "Starter downloaded"
+  );
+  await terminal.step("Configuring project", () => {
+    personalizeStarter(targetDir, {
+      projectName,
+      packageName: slug,
+      description,
+      brandPreset,
+      repoUrl,
+      enableAiChat,
+      i18nLocales,
+      colors
+    });
+    resetTrackingConfig(targetDir);
+    if (trackRepos?.length) writeTrackingConfig(targetDir, trackRepos);
+    updateEnvExample(targetDir);
+  }, "Project configured");
+  if (trackRepos?.length) {
+    const list = trackRepos.map((r) => `${r.owner}/${r.repo}`).join(", ");
+    terminal.info(`Thally Track enabled \u2014 watching ${list} (branch main, all files; refine in docs.json).`);
+    terminal.info("To finish wiring it: `thally track setup` (pick a trigger) + `thally agent init`,");
+    terminal.info("then add your ANTHROPIC_API_KEY. See /guides/thally-track.");
+  }
+  if (doInstall) {
+    await installDeps(targetDir);
+  }
+  await initGit(targetDir);
+  return { projectDir: targetDir };
+}
+
+export {
+  slugify,
+  runProjectCommand,
+  initGit,
+  installDeps,
+  previewCommand,
+  logo,
+  success,
+  scaffold
+};