superlore-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,899 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import process2 from "process";
+import { cac } from "cac";
+
+// src/lib/log.ts
+var useColor = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+var truecolor = useColor && /truecolor|24bit/i.test(process.env.COLORTERM ?? "");
+function paint(open, text2) {
+  return useColor ? `${open}${text2}\x1B[0m` : text2;
+}
+var accent = (text2) => paint(truecolor ? "\x1B[38;2;109;92;240m" : "\x1B[38;5;99m", text2);
+var accentSoft = (text2) => paint(truecolor ? "\x1B[38;2;183;172;255m" : "\x1B[38;5;147m", text2);
+var bold = (text2) => paint("\x1B[1m", text2);
+var dim = (text2) => paint("\x1B[2m", text2);
+var green = (text2) => paint("\x1B[32m", text2);
+var yellow = (text2) => paint("\x1B[33m", text2);
+var red = (text2) => paint("\x1B[31m", text2);
+var cyan = (text2) => paint("\x1B[36m", text2);
+var wordmark = (text2) => paint(truecolor ? "\x1B[1m\x1B[38;2;109;92;240m" : "\x1B[1m\x1B[38;5;99m", text2);
+function banner() {
+  if (!useColor) {
+    process.stdout.write("superlore \u2014 the company knowledge base your agents run on.\n");
+    return;
+  }
+  const fold = `${accent("\u2588\u2588")}${accentSoft("\u2593\u2593")}`;
+  const lines = [
+    `  ${fold}`,
+    `  ${fold}   ${wordmark("superlore")}`,
+    `  ${fold}   ${dim("the company knowledge base your agents run on")}`,
+    `  ${fold}`
+  ];
+  process.stdout.write(`
+${lines.join("\n")}
+
+`);
+}
+var log = {
+  info(message) {
+    process.stdout.write(`${message}
+`);
+  },
+  step(message) {
+    process.stdout.write(`${accent("\u203A")} ${message}
+`);
+  },
+  success(message) {
+    process.stdout.write(`${green("\u2713")} ${message}
+`);
+  },
+  warn(message) {
+    process.stderr.write(`${yellow("!")} ${message}
+`);
+  },
+  error(message) {
+    process.stderr.write(`${red("\u2717")} ${message}
+`);
+  },
+  blank() {
+    process.stdout.write("\n");
+  }
+};
+
+// src/lib/project.ts
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+
+// src/config.ts
+var DEFAULT_MCP_PATH = "/api/mcp";
+var SUPERLORE_JSON_FILENAME = "superlore.json";
+var SUPERLORE_TYPES = ["company-kb", "product-docs"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateSuperloreJson(input) {
+  const issues = [];
+  if (!isRecord(input)) {
+    return { ok: false, issues: [{ path: "", message: "must be a JSON object" }] };
+  }
+  const name = input.name;
+  if (typeof name !== "string" || name.trim().length === 0) {
+    issues.push({ path: "name", message: "is required and must be a non-empty string" });
+  }
+  const type = input.type;
+  if (typeof type !== "string" || !SUPERLORE_TYPES.includes(type)) {
+    issues.push({
+      path: "type",
+      message: `is required and must be one of ${SUPERLORE_TYPES.map((t) => `"${t}"`).join(" | ")}`
+    });
+  }
+  const accent2 = input.accent;
+  if (accent2 !== void 0 && (typeof accent2 !== "string" || accent2.trim().length === 0)) {
+    issues.push({ path: "accent", message: "must be a non-empty string (a CSS colour)" });
+  }
+  let auth;
+  if (input.auth !== void 0) {
+    if (!isRecord(input.auth)) {
+      issues.push({ path: "auth", message: "must be an object" });
+    } else {
+      const a = input.auth;
+      if (typeof a.enabled !== "boolean") {
+        issues.push({ path: "auth.enabled", message: "is required and must be a boolean" });
+      }
+      if (a.provider !== void 0 && a.provider !== "google") {
+        issues.push({ path: "auth.provider", message: 'must be "google"' });
+      }
+      if (a.allowedDomain !== void 0 && (typeof a.allowedDomain !== "string" || a.allowedDomain.trim().length === 0)) {
+        issues.push({ path: "auth.allowedDomain", message: "must be a non-empty string" });
+      }
+      if (typeof a.enabled === "boolean") {
+        auth = {
+          enabled: a.enabled,
+          // Default the provider to Google when the gate is on.
+          provider: a.provider ?? (a.enabled ? "google" : void 0),
+          allowedDomain: typeof a.allowedDomain === "string" ? a.allowedDomain : void 0
+        };
+      }
+    }
+  }
+  let mcp;
+  if (input.mcp !== void 0) {
+    if (!isRecord(input.mcp)) {
+      issues.push({ path: "mcp", message: "must be an object" });
+    } else {
+      const m = input.mcp;
+      if (typeof m.enabled !== "boolean") {
+        issues.push({ path: "mcp.enabled", message: "is required and must be a boolean" });
+      }
+      if (m.path !== void 0 && (typeof m.path !== "string" || !m.path.startsWith("/"))) {
+        issues.push({ path: "mcp.path", message: 'must be a string starting with "/"' });
+      }
+      if (typeof m.enabled === "boolean") {
+        mcp = {
+          enabled: m.enabled,
+          path: typeof m.path === "string" ? m.path : m.enabled ? DEFAULT_MCP_PATH : void 0
+        };
+      }
+    }
+  }
+  if (issues.length > 0) {
+    return { ok: false, issues };
+  }
+  const value = {
+    name: name.trim(),
+    type
+  };
+  if (typeof accent2 === "string") value.accent = accent2.trim();
+  if (auth) value.auth = auth;
+  if (mcp) value.mcp = mcp;
+  return { ok: true, value };
+}
+function parseSuperloreJson(raw) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "invalid JSON";
+    return { ok: false, issues: [{ path: "", message: `not valid JSON: ${message}` }] };
+  }
+  return validateSuperloreJson(data);
+}
+function serializeSuperloreJson(config) {
+  return `${JSON.stringify(config, null, 2)}
+`;
+}
+function resolveMcpPath(config) {
+  if (!config.mcp || !config.mcp.enabled) return void 0;
+  return config.mcp.path ?? DEFAULT_MCP_PATH;
+}
+
+// src/lib/project.ts
+function findProjectRoot(start = process.cwd()) {
+  let dir = resolve(start);
+  for (; ; ) {
+    if (existsSync(join(dir, SUPERLORE_JSON_FILENAME))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+var LoadProjectError = class extends Error {
+};
+function loadProject(start = process.cwd()) {
+  const root = findProjectRoot(start);
+  if (!root) {
+    throw new LoadProjectError(
+      `No ${SUPERLORE_JSON_FILENAME} found here or in any parent directory. Run \`superlore init\` to scaffold a KB, or cd into one.`
+    );
+  }
+  const file = join(root, SUPERLORE_JSON_FILENAME);
+  const result = parseSuperloreJson(readFileSync(file, "utf8"));
+  if (!result.ok) {
+    const lines = result.issues.map((i) => `  - ${i.path ? `${i.path} ` : ""}${i.message}`);
+    throw new LoadProjectError(`Invalid ${SUPERLORE_JSON_FILENAME}:
+${lines.join("\n")}`);
+  }
+  return { root, config: result.value };
+}
+function detectPackageManager(root) {
+  if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(root, "yarn.lock"))) return "yarn";
+  if (existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock"))) return "bun";
+  if (existsSync(join(root, "package-lock.json"))) return "npm";
+  return "pnpm";
+}
+function isInstalled(root) {
+  return existsSync(join(root, "node_modules"));
+}
+function runScript(root, script, extraArgs = []) {
+  const pm = detectPackageManager(root);
+  const args = ["run", script, ...extraArgs.length ? ["--", ...extraArgs] : []];
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(pm, args, {
+      cwd: root,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolvePromise(code ?? 0));
+  });
+}
+
+// src/commands/build.ts
+async function buildCommand() {
+  let project;
+  try {
+    project = loadProject();
+  } catch (error) {
+    if (error instanceof LoadProjectError) {
+      log.error(error.message);
+      process.exit(1);
+    }
+    throw error;
+  }
+  if (project.config.type === "company-kb" && !project.config.auth?.enabled) {
+    log.warn(
+      `Building a company KB with auth disabled \u2014 anyone with the URL can read it. Enable ${cyan("auth in superlore.json")} before deploying.`
+    );
+    log.blank();
+  }
+  if (!isInstalled(project.root)) {
+    log.error(
+      `Dependencies aren't installed. Run ${cyan("pnpm install")} (or npm / yarn / bun) first.`
+    );
+    process.exit(1);
+  }
+  log.step(`Building ${accent(project.config.name)} for production`);
+  log.blank();
+  const code = await runScript(project.root, "build");
+  process.exit(code);
+}
+
+// src/commands/deploy.ts
+import { spawn as spawn2 } from "child_process";
+
+// src/lib/constants.ts
+var SUPERLORE_SITE = (process.env.SUPERLORE_SITE ?? "https://superlore.vercel.app").replace(/\/$/, "");
+var CLOUD_WAITLIST_URL = `${SUPERLORE_SITE}/cloud`;
+var SUPERLORE_VIOLET = "#6D5CF0";
+
+// src/commands/deploy.ts
+function openInBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    const child = spawn2(cmd, [url], {
+      stdio: "ignore",
+      detached: true,
+      shell: process.platform === "win32"
+    });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+async function deployCommand(flags) {
+  log.blank();
+  log.info(`${accent("superlore Cloud")} ${dim("\u2014 managed deploy")}`);
+  log.blank();
+  log.info(
+    `Managed deploy is in ${bold("private beta")} \u2014 one-click superlore Cloud hosting isn't open to`
+  );
+  log.info(`everyone yet.`);
+  log.blank();
+  log.info(`${bold("Join the waitlist:")} ${cyan(CLOUD_WAITLIST_URL)}`);
+  log.blank();
+  log.info(`${dim("In the meantime, superlore is open source \u2014 self-host free:")}`);
+  log.info(
+    `  ${accent("\u203A")} ${cyan("superlore build")} ${dim("then deploy the app to Vercel or any Next.js host.")}`
+  );
+  log.blank();
+  if (flags.open) {
+    log.step(`Opening ${cyan(CLOUD_WAITLIST_URL)} \u2026`);
+    openInBrowser(CLOUD_WAITLIST_URL);
+  }
+  process.exit(0);
+}
+
+// src/commands/dev.ts
+async function devCommand(flags) {
+  let project;
+  try {
+    project = loadProject();
+  } catch (error) {
+    if (error instanceof LoadProjectError) {
+      log.error(error.message);
+      process.exit(1);
+    }
+    throw error;
+  }
+  if (!isInstalled(project.root)) {
+    log.error(
+      `Dependencies aren't installed. Run ${cyan("pnpm install")} (or npm / yarn / bun) first.`
+    );
+    process.exit(1);
+  }
+  const port = flags.port ?? 3e3;
+  log.step(`Starting ${accent(project.config.name)} dev server`);
+  log.info(`  ${dim("Local:")} ${cyan(`http://localhost:${port}`)}`);
+  if (project.config.mcp?.enabled) {
+    log.info(
+      `  ${dim("MCP:  ")} ${cyan(`http://localhost:${port}${project.config.mcp.path ?? "/api/mcp"}`)}`
+    );
+  }
+  log.blank();
+  const args = flags.port ? ["--port", String(flags.port)] : [];
+  const code = await runScript(project.root, "dev", args);
+  process.exit(code);
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync3 } from "fs";
+import { basename, resolve as resolve3 } from "path";
+import { cancel, confirm, intro, isCancel, outro, select, text } from "@clack/prompts";
+
+// src/lib/scaffold.ts
+import { cpSync, existsSync as existsSync2, mkdirSync, readdirSync, writeFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+var here = dirname2(fileURLToPath(import.meta.url));
+function findStarterTemplate() {
+  let dir = here;
+  for (; ; ) {
+    const candidate = join2(dir, "templates", "starter");
+    if (existsSync2(candidate)) return candidate;
+    const bundled = join2(dir, "template");
+    if (existsSync2(bundled)) return bundled;
+    const parent = dirname2(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function isUsableTemplate(dir) {
+  if (!existsSync2(dir)) return false;
+  const entries = readdirSync(dir).filter((name) => name !== "README.md" && !name.startsWith("."));
+  return entries.length > 0;
+}
+function isEmptyDir(dir) {
+  if (!existsSync2(dir)) return true;
+  return readdirSync(dir).filter((n) => !n.startsWith(".")).length === 0;
+}
+function scaffold(options) {
+  const root = resolve2(options.dir);
+  mkdirSync(root, { recursive: true });
+  const template = findStarterTemplate();
+  let source;
+  if (template && isUsableTemplate(template)) {
+    cpSync(template, root, { recursive: true });
+    source = "template";
+  } else {
+    writeSkeleton(root, options.config);
+    source = "skeleton";
+  }
+  writeFileSync(join2(root, "superlore.json"), serializeSuperloreJson(options.config), "utf8");
+  return { root, source };
+}
+function writeSkeleton(root, config) {
+  const accent2 = config.accent ?? SUPERLORE_VIOLET;
+  const mcpEnabled = config.mcp?.enabled ?? true;
+  const slug = config.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "superlore-kb";
+  const write = (rel, body) => {
+    const file = join2(root, rel);
+    mkdirSync(dirname2(file), { recursive: true });
+    writeFileSync(file, body, "utf8");
+  };
+  write(
+    "package.json",
+    `${JSON.stringify(
+      {
+        name: slug,
+        version: "0.1.0",
+        private: true,
+        type: "module",
+        scripts: {
+          dev: "next dev",
+          build: "next build",
+          start: "next start",
+          postinstall: "fumadocs-mdx"
+        },
+        dependencies: {
+          "fumadocs-core": "16.8.2",
+          "fumadocs-mdx": "14.3.1",
+          "fumadocs-ui": "16.8.2",
+          superlore: "^0.1.0",
+          "lucide-react": "^1.21.0",
+          ...mcpEnabled ? { "@modelcontextprotocol/sdk": "^1.29.0", "mcp-handler": "^1.1.0" } : {},
+          next: "16.2.4",
+          "next-themes": "^0.4.6",
+          react: "^19.2.5",
+          "react-dom": "^19.2.5",
+          zod: "^4.4.3"
+        },
+        devDependencies: {
+          "@tailwindcss/postcss": "^4.2.2",
+          "@types/node": "^25.6.0",
+          "@types/react": "^19.2.14",
+          "@types/react-dom": "^19.2.3",
+          postcss: "^8.5.10",
+          tailwindcss: "^4.2.2",
+          typescript: "6.0.3"
+        }
+      },
+      null,
+      2
+    )}
+`
+  );
+  write(
+    "tsconfig.json",
+    `${JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          lib: ["dom", "dom.iterable", "esnext"],
+          module: "esnext",
+          moduleResolution: "bundler",
+          strict: true,
+          noEmit: true,
+          jsx: "preserve",
+          esModuleInterop: true,
+          resolveJsonModule: true,
+          isolatedModules: true,
+          skipLibCheck: true,
+          incremental: true,
+          paths: { "@/*": ["./*"] },
+          plugins: [{ name: "next" }]
+        },
+        include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+        exclude: ["node_modules", ".next", "out"]
+      },
+      null,
+      2
+    )}
+`
+  );
+  write(
+    "next.config.mjs",
+    `import { createMDX } from "fumadocs-mdx/next";
+
+const withMDX = createMDX();
+
+/** @type {import('next').NextConfig} */
+const config = {
+  reactStrictMode: true,
+  // \`superlore\` ships source (.ts/.tsx) for frictionless consumption \u2014 Next transpiles it.
+  transpilePackages: ["superlore"],
+};
+
+export default withMDX(config);
+`
+  );
+  write(
+    "source.config.ts",
+    `import { defineConfig, defineDocs } from "fumadocs-mdx/config";
+import { superloreFrontmatterSchema } from "superlore/frontmatter";
+
+// Extend the superlore frontmatter schema in ONE place if you add custom fields.
+export const docs = defineDocs({
+  dir: "content/docs",
+  docs: { schema: superloreFrontmatterSchema },
+});
+
+export default defineConfig();
+`
+  );
+  write(
+    "postcss.config.mjs",
+    `const config = {
+  plugins: { "@tailwindcss/postcss": {} },
+};
+
+export default config;
+`
+  );
+  write(
+    "app/global.css",
+    `@import "tailwindcss";
+/* superlore theme tokens (light + dark, co-equal). Re-skin the whole KB from one accent. */
+@import "superlore/css";
+
+:root {
+  /* Brand accent \u2014 superlore derives the hover/weak/border/text family for both themes. */
+  --kp-accent: ${accent2};
+}
+`
+  );
+  write(
+    "app/layout.tsx",
+    `import type { ReactNode } from "react";
+import { RootProvider } from "fumadocs-ui/provider";
+import "./global.css";
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+  // Light and dark are co-equal; default to the system preference.
+  return (
+    <html lang="en" suppressHydrationWarning>
+      <body>
+        <RootProvider>{children}</RootProvider>
+      </body>
+    </html>
+  );
+}
+`
+  );
+  write(
+    "app/page.tsx",
+    `import Link from "next/link";
+
+export default function HomePage() {
+  return (
+    <main style={{ maxWidth: "42rem", margin: "0 auto", padding: "6rem 1.5rem" }}>
+      <h1 style={{ fontSize: "2rem", fontWeight: 700 }}>${escapeForJsx(config.name)}</h1>
+      <p style={{ marginTop: "0.75rem", opacity: 0.7 }}>
+        One corpus. Humans and agents. Start in <Link href="/docs">the docs</Link>.
+      </p>
+    </main>
+  );
+}
+`
+  );
+  write(
+    "app/docs/layout.tsx",
+    `import type { ReactNode } from "react";
+import { DocsLayout } from "fumadocs-ui/layouts/docs";
+import { source } from "@/lib/source";
+
+export default function Layout({ children }: { children: ReactNode }) {
+  return (
+    <DocsLayout tree={source.pageTree} nav={{ title: "${escapeForJsx(config.name)}" }}>
+      {children}
+    </DocsLayout>
+  );
+}
+`
+  );
+  write(
+    "app/docs/[[...slug]]/page.tsx",
+    `import { notFound } from "next/navigation";
+import { DocsBody, DocsPage } from "fumadocs-ui/page";
+import { getMDXComponents } from "superlore";
+import { source } from "@/lib/source";
+
+export default async function Page(props: { params: Promise<{ slug?: string[] }> }) {
+  const params = await props.params;
+  const page = source.getPage(params.slug);
+  if (!page) notFound();
+  const MDX = page.data.body;
+  return (
+    <DocsPage toc={page.data.toc}>
+      <DocsBody>
+        <MDX components={getMDXComponents()} />
+      </DocsBody>
+    </DocsPage>
+  );
+}
+
+export function generateStaticParams() {
+  return source.generateParams();
+}
+`
+  );
+  write(
+    "lib/source.ts",
+    `import { loader } from "fumadocs-core/source";
+import { docs } from "@/.source";
+
+export const source = loader({
+  baseUrl: "/docs",
+  source: docs.toFumadocsSource(),
+});
+`
+  );
+  write(
+    "content/docs/index.mdx",
+    `---
+title: Welcome
+description: The home of your superlore knowledge base.
+summary: Landing page for the ${config.name} knowledge base.
+tags: [getting-started]
+---
+
+# Welcome to ${config.name}
+
+This is your superlore KB. Author once in MDX \u2014 humans get this clean, interactive site, and
+agents read the same structured content over MCP.
+
+Edit \`content/docs/index.mdx\` to make it yours, then run \`superlore dev\`.
+`
+  );
+  if (mcpEnabled) {
+    const mcpPath = config.mcp?.path ?? "/api/mcp";
+    write(
+      "app/api/[transport]/route.ts",
+      `import { createMcpHandler } from "mcp-handler";
+import { z } from "zod";
+import { getComponentData, getPage, list, navigate, search } from "superlore/mcp";
+
+// Your KB's MCP endpoint. Served at ${mcpPath} \u2014 the same structured content the site renders,
+// exposed to agents. Build the index from your content source and pass it to each tool.
+// See the superlore docs (Agents & MCP) for wiring the index from \`source\`.
+
+const json = (data: unknown) => ({
+  content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
+});
+
+const handler = createMcpHandler(
+  (server) => {
+    server.tool(
+      "search",
+      "Full-text search across the knowledge base.",
+      { query: z.string(), limit: z.number().int().positive().optional() },
+      async ({ query, limit }) => json(search(/* index */ {} as never, query, limit)),
+    );
+    server.tool(
+      "get_page",
+      "Get a page's full structured content by path.",
+      { path: z.string() },
+      async ({ path }) => json(getPage(/* index */ {} as never, path)),
+    );
+    server.tool(
+      "list",
+      "List knowledge nodes, filtered by kind / tag / entityType.",
+      { kind: z.string().optional(), tag: z.string().optional(), entityType: z.string().optional() },
+      async (args) => json(list(/* index */ {} as never, args)),
+    );
+    server.tool(
+      "navigate",
+      "Follow relations from a page path / node id / entity ref.",
+      { target: z.string() },
+      async ({ target }) => json(navigate(/* index */ {} as never, target)),
+    );
+    server.tool(
+      "get_component_data",
+      "Get the structured data behind a rendered component (its knowledge face).",
+      { id: z.string() },
+      async ({ id }) => json(getComponentData(/* index */ {} as never, id)),
+    );
+  },
+  {},
+  { basePath: "/api" },
+);
+
+export { handler as GET, handler as POST };
+`
+    );
+  }
+  write(
+    ".gitignore",
+    `node_modules
+.next
+.source
+out
+*.tsbuildinfo
+.env*.local
+`
+  );
+  write(
+    "README.md",
+    `# ${config.name}
+
+A superlore knowledge base. One corpus. Humans and agents.
+
+## Develop
+
+\`\`\`sh
+pnpm install   # or npm / yarn / bun
+superlore dev     # preview the site locally
+\`\`\`
+
+## Build
+
+\`\`\`sh
+superlore build
+\`\`\`
+
+Config lives in \`superlore.json\`. Author content in \`content/docs/\`.${mcpEnabled ? `
+
+The MCP endpoint is served at \`${config.mcp?.path ?? "/api/mcp"}\`.` : ""}
+`
+  );
+}
+function escapeForJsx(value) {
+  return value.replace(/[\\"]/g, "\\$&").replace(/[{}]/g, "");
+}
+
+// src/commands/init.ts
+function bail(message) {
+  cancel(message);
+  process.exit(1);
+}
+async function initCommand(dir, flags) {
+  banner();
+  intro(`${accent("superlore")} ${dim("init")}`);
+  const interactive = !flags.yes && process.stdout.isTTY;
+  let name = flags.name?.trim() || dir?.trim();
+  if (!name && interactive) {
+    const answer = await text({
+      message: "What's your knowledge base called?",
+      placeholder: "Acme Knowledge Base",
+      validate: (v) => (v ?? "").trim().length === 0 ? "A name is required." : void 0
+    });
+    if (isCancel(answer)) bail("Cancelled.");
+    name = answer.trim();
+  }
+  if (!name) bail("A name is required (pass --name, a [dir] argument, or run interactively).");
+  let type = flags.type;
+  if (type && type !== "company-kb" && type !== "product-docs") {
+    bail(`Invalid --type "${type}". Use "company-kb" or "product-docs".`);
+  }
+  if (!type && interactive) {
+    const answer = await select({
+      message: "What kind of KB is this?",
+      options: [
+        {
+          value: "company-kb",
+          label: "Company KB",
+          hint: "internal / private \u2014 should be gated"
+        },
+        {
+          value: "product-docs",
+          label: "Product docs",
+          hint: "public-facing documentation"
+        }
+      ]
+    });
+    if (isCancel(answer)) bail("Cancelled.");
+    type = answer;
+  }
+  if (!type) bail("A type is required (pass --type or run interactively).");
+  let authEnabled;
+  if (flags.auth !== void 0) {
+    authEnabled = flags.auth;
+  } else if (flags.allowedDomain) {
+    authEnabled = true;
+  } else if (interactive) {
+    const answer = await confirm({
+      message: "Gate the site behind Google SSO (auth)?",
+      initialValue: type === "company-kb"
+    });
+    if (isCancel(answer)) bail("Cancelled.");
+    authEnabled = answer;
+  } else {
+    authEnabled = type === "company-kb";
+  }
+  let allowedDomain = flags.allowedDomain?.trim();
+  if (authEnabled && !allowedDomain && interactive) {
+    const answer = await text({
+      message: "Restrict sign-in to an email domain? (optional)",
+      placeholder: "acme.com \u2014 leave blank for any Google account"
+    });
+    if (isCancel(answer)) bail("Cancelled.");
+    allowedDomain = answer.trim() || void 0;
+  }
+  const accentColor = flags.accent?.trim();
+  const mcpEnabled = flags.mcp ?? true;
+  const auth = authEnabled ? { enabled: true, provider: "google", ...allowedDomain ? { allowedDomain } : {} } : void 0;
+  const draft = { name, type };
+  if (accentColor) draft.accent = accentColor;
+  if (auth) draft.auth = auth;
+  draft.mcp = { enabled: mcpEnabled, ...mcpEnabled ? { path: DEFAULT_MCP_PATH } : {} };
+  const result = validateSuperloreJson(draft);
+  if (!result.ok) {
+    bail(
+      `Could not build a valid superlore.json:
+${result.issues.map((i) => `  - ${i.path} ${i.message}`).join("\n")}`
+    );
+  }
+  const config = result.value;
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  const targetName = dir ?? (slug || "superlore-kb");
+  const targetDir = resolve3(process.cwd(), targetName);
+  if (existsSync3(targetDir) && !isEmptyDir(targetDir)) {
+    if (interactive) {
+      const proceed = await confirm({
+        message: `${cyan(targetDir)} is not empty. Scaffold into it anyway?`,
+        initialValue: false
+      });
+      if (isCancel(proceed) || !proceed) bail("Cancelled \u2014 pick an empty directory.");
+    } else {
+      bail(`${targetDir} is not empty. Pick an empty directory.`);
+    }
+  }
+  const { root, source } = scaffold({ dir: targetDir, config });
+  outro(`${bold("Scaffolded")} ${config.name} ${dim(`(${source})`)}`);
+  if (config.type === "company-kb" && !config.auth?.enabled) {
+    log.blank();
+    log.warn(
+      `This is a ${bold("company KB")} but auth is ${bold("not enabled")}. A company KB should gate access before you deploy \u2014 re-run with ${cyan("--auth")} or set ${cyan('"auth": { "enabled": true }')} in superlore.json.`
+    );
+  }
+  printNextSteps(root, config);
+}
+function printNextSteps(root, config) {
+  const rel = basename(root);
+  const accentNote = config.accent ?? SUPERLORE_VIOLET;
+  log.blank();
+  log.info(bold("Next steps"));
+  log.info(`  ${accent("1.")} ${cyan(`cd ${rel}`)}`);
+  log.info(`  ${accent("2.")} ${cyan("pnpm install")} ${dim("(or npm / yarn / bun)")}`);
+  log.info(`  ${accent("3.")} ${cyan("superlore dev")} ${dim("\u2014 preview the site locally")}`);
+  log.blank();
+  log.info(`${dim("Config:")} ${cyan("superlore.json")}   ${dim("Brand accent:")} ${accentNote}`);
+  if (config.mcp?.enabled) {
+    log.info(`${dim("MCP endpoint:")} ${config.mcp.path ?? DEFAULT_MCP_PATH}`);
+  }
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+function buildCli(argv = process2.argv) {
+  const cli = cac("superlore");
+  cli.command("init [dir]", "Scaffold a new superlore knowledge base").option("--name <name>", "KB name").option("--type <type>", "KB type: company-kb | product-docs").option("--auth", "Enable the Google SSO auth gate").option("--no-auth", "Disable the auth gate").option("--allowed-domain <domain>", "Restrict SSO to one email domain (implies --auth)").option("--accent <color>", "Brand accent colour (any CSS colour)").option("--no-mcp", "Disable the MCP endpoint (on by default)").option("-y, --yes", "Skip prompts; use flags + defaults").example("superlore init my-kb --type product-docs").example("superlore init acme --type company-kb --auth --allowed-domain acme.com").action(
+    async (dir, flags) => {
+      const authExplicit = argv.includes("--auth");
+      const noAuthExplicit = argv.includes("--no-auth");
+      const auth = authExplicit ? true : noAuthExplicit ? false : void 0;
+      await initCommand(dir, {
+        name: flags.name,
+        type: flags.type,
+        auth,
+        allowedDomain: flags.allowedDomain,
+        accent: flags.accent,
+        // `--no-mcp` flips this to false; default true is the intended behaviour.
+        mcp: flags.mcp,
+        yes: flags.yes
+      });
+    }
+  );
+  cli.command("dev", "Run the local superlore site for preview").option("--port <port>", "Port for the dev server", { default: 3e3 }).action(async (flags) => {
+    await devCommand({ port: flags.port });
+  });
+  cli.command("build", "Production build of the KB").action(async () => {
+    await buildCommand();
+  });
+  cli.command("deploy", "Managed deploy (superlore Cloud) \u2014 private beta, joins the waitlist").option("--open", "Open the waitlist URL in your browser").action(async (flags) => {
+    await deployCommand({ open: flags.open });
+  });
+  cli.help();
+  cli.version(VERSION);
+  return cli;
+}
+async function run(argv = process2.argv) {
+  const cli = buildCli(argv);
+  const tokens = argv.slice(2);
+  const hasCommand = tokens.some((t) => !t.startsWith("-"));
+  const wantsVersion = tokens.includes("-v") || tokens.includes("--version");
+  if (!hasCommand && !wantsVersion) banner();
+  try {
+    cli.parse([...argv], { run: false });
+    if (!cli.matchedCommand && !cli.options.version) {
+      if (!cli.options.help) cli.outputHelp();
+      return;
+    }
+    await cli.runMatchedCommand();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(message);
+    process2.exit(1);
+  }
+}
+var isEntrypoint = Boolean(process2.argv[1]) && fileURLToPath2(import.meta.url) === process2.argv[1];
+if (isEntrypoint) {
+  void run();
+}
+export {
+  DEFAULT_MCP_PATH,
+  SUPERLORE_JSON_FILENAME,
+  SUPERLORE_TYPES,
+  VERSION,
+  buildCli,
+  parseSuperloreJson,
+  resolveMcpPath,
+  run,
+  serializeSuperloreJson,
+  validateSuperloreJson
+};