@conceptcraft/mindframes 0.1.1

package/dist/index.js

@@ -0,0 +1,2757 @@
+#!/usr/bin/env node
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+
+// src/index.ts
+import { Command as Command13 } from "commander";
+import chalk12 from "chalk";
+
+// src/lib/brand.ts
+import path from "path";
+var BRANDS = {
+  conceptcraft: {
+    id: "conceptcraft",
+    name: "conceptcraft",
+    displayName: "Conceptcraft",
+    description: "CLI tool for Conceptcraft presentation generation",
+    commands: ["cc", "conceptcraft"],
+    apiUrl: "https://conceptcraft.ai",
+    docsUrl: "https://docs.conceptcraft.ai"
+  },
+  mindframes: {
+    id: "mindframes",
+    name: "mindframes",
+    displayName: "Mindframes",
+    description: "CLI tool for Mindframes presentation generation",
+    commands: ["mf", "mindframes"],
+    apiUrl: "https://mindframes.app",
+    docsUrl: "https://docs.mindframes.app"
+  }
+};
+var COMMAND_TO_BRAND = {
+  cc: "conceptcraft",
+  conceptcraft: "conceptcraft",
+  mf: "mindframes",
+  mindframes: "mindframes"
+};
+function detectBrand() {
+  const binaryPath = process.argv[1] || "";
+  const binaryName = path.basename(binaryPath).replace(/\.(js|ts)$/, "");
+  const brandId = COMMAND_TO_BRAND[binaryName];
+  if (brandId) {
+    return BRANDS[brandId];
+  }
+  for (const [cmd2, id] of Object.entries(COMMAND_TO_BRAND)) {
+    if (binaryPath.includes(`/${cmd2}`) || binaryPath.includes(`\\${cmd2}`)) {
+      return BRANDS[id];
+    }
+  }
+  return BRANDS.mindframes;
+}
+var brand = detectBrand();
+
+// src/commands/config.ts
+import { Command } from "commander";
+import chalk3 from "chalk";
+import { input, password, confirm, select } from "@inquirer/prompts";
+import ora from "ora";
+
+// src/lib/config.ts
+import Conf from "conf";
+var DEFAULT_API_URL = "https://www.mindframes.app";
+var schema = {
+  apiKey: {
+    type: "string"
+  },
+  apiUrl: {
+    type: "string",
+    default: DEFAULT_API_URL
+  },
+  defaultTeamId: {
+    type: "string"
+  }
+};
+var config = new Conf({
+  projectName: "conceptcraft",
+  schema
+});
+function getConfig() {
+  return {
+    apiKey: getApiKey(),
+    apiUrl: getApiUrl(),
+    defaultTeamId: config.get("defaultTeamId")
+  };
+}
+function getApiKey() {
+  const envKey = process.env.CC_SLIDES_API_KEY ?? process.env.CONCEPTCRAFT_API_KEY;
+  if (envKey) {
+    return envKey;
+  }
+  return config.get("apiKey");
+}
+function setApiKey(key) {
+  config.set("apiKey", key);
+}
+function getApiUrl() {
+  const envUrl = process.env.CC_SLIDES_API_URL ?? process.env.CONCEPTCRAFT_API_URL;
+  if (envUrl) {
+    return envUrl;
+  }
+  return config.get("apiUrl") ?? DEFAULT_API_URL;
+}
+function setApiUrl(url) {
+  config.set("apiUrl", url);
+}
+function getDefaultTeamId() {
+  return config.get("defaultTeamId");
+}
+function setDefaultTeamId(teamId) {
+  config.set("defaultTeamId", teamId);
+}
+function clearConfig() {
+  config.clear();
+}
+function getConfigPath() {
+  return config.path;
+}
+function hasApiKey() {
+  return !!getApiKey();
+}
+
+// src/lib/auth.ts
+import chalk from "chalk";
+
+// src/types/index.ts
+var EXIT_CODES = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  AUTH_ERROR: 2,
+  NOT_FOUND: 3,
+  RATE_LIMIT: 4,
+  NETWORK_ERROR: 5,
+  INVALID_INPUT: 6
+};
+
+// src/lib/auth.ts
+function requireAuth() {
+  if (!hasApiKey()) {
+    console.error(chalk.red("Error: Not authenticated."));
+    console.error();
+    console.error("To authenticate, either:");
+    console.error(
+      chalk.gray("  1. Set the CC_SLIDES_API_KEY environment variable")
+    );
+    console.error(
+      chalk.gray("  2. Run: conceptcraft config init")
+    );
+    console.error();
+    console.error(
+      chalk.gray(`Config file location: ${getConfigPath()}`)
+    );
+    process.exit(EXIT_CODES.AUTH_ERROR);
+  }
+}
+function maskApiKey(key) {
+  if (key.length <= 14) {
+    return "****";
+  }
+  return `${key.slice(0, 10)}...${key.slice(-4)}`;
+}
+function getMaskedApiKey() {
+  const key = getApiKey();
+  if (!key) return void 0;
+  return maskApiKey(key);
+}
+function isValidApiKeyFormat(key) {
+  const validPrefixes = ["cc_slides_", "mcp_", "cc_sk_", "sk_"];
+  return validPrefixes.some((prefix) => key.startsWith(prefix));
+}
+
+// src/lib/api.ts
+import { readFileSync, statSync } from "fs";
+import { basename } from "path";
+import { randomUUID } from "crypto";
+var ApiError = class extends Error {
+  constructor(message, statusCode, exitCode = 1) {
+    super(message);
+    this.statusCode = statusCode;
+    this.exitCode = exitCode;
+    this.name = "ApiError";
+  }
+};
+async function request(endpoint, options = {}) {
+  const apiKey = getApiKey();
+  const apiUrl = getApiUrl();
+  if (!apiKey) {
+    throw new ApiError(
+      "API key not configured. Run 'conceptcraft config init' or set CC_SLIDES_API_KEY environment variable.",
+      401,
+      2
+      // AUTH_ERROR
+    );
+  }
+  const url = `${apiUrl}${endpoint}`;
+  const headers = {
+    "x-api-key": apiKey,
+    ...options.headers
+  };
+  if (options.body && !options.stream) {
+    headers["Content-Type"] = "application/json";
+  }
+  const fetchOptions = {
+    method: options.method ?? "GET",
+    headers
+  };
+  if (options.body) {
+    fetchOptions.body = JSON.stringify(options.body);
+  }
+  let response;
+  try {
+    response = await fetch(url, fetchOptions);
+  } catch (error2) {
+    throw new ApiError(
+      `Network error: ${error2 instanceof Error ? error2.message : "Unknown error"}`,
+      0,
+      5
+      // NETWORK_ERROR
+    );
+  }
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "");
+    let exitCode = 1;
+    switch (response.status) {
+      case 401:
+        exitCode = 2;
+        break;
+      case 403:
+        exitCode = 2;
+        break;
+      case 404:
+        exitCode = 3;
+        break;
+      case 429:
+        exitCode = 4;
+        break;
+      case 500:
+        exitCode = 1;
+        break;
+    }
+    const message = errorText.trim() || `HTTP ${response.status}: ${response.statusText || "Server error"}`;
+    throw new ApiError(message, response.status, exitCode);
+  }
+  if (options.stream) {
+    return response;
+  }
+  const contentType = response.headers.get("content-type");
+  if (contentType?.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+}
+async function streamRequest(endpoint, body) {
+  const apiKey = getApiKey();
+  const apiUrl = getApiUrl();
+  if (!apiKey) {
+    throw new ApiError(
+      "API key not configured. Run 'conceptcraft config init' or set CC_SLIDES_API_KEY environment variable.",
+      401,
+      2
+    );
+  }
+  const url = `${apiUrl}${endpoint}`;
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      body: JSON.stringify(body)
+    });
+  } catch (error2) {
+    throw new ApiError(
+      `Network error: ${error2 instanceof Error ? error2.message : "Unknown error"}`,
+      0,
+      5
+    );
+  }
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "Unknown error");
+    let exitCode = 1;
+    switch (response.status) {
+      case 401:
+        exitCode = 2;
+        break;
+      case 403:
+        exitCode = 2;
+        break;
+      case 404:
+        exitCode = 3;
+        break;
+      case 429:
+        exitCode = 4;
+        break;
+    }
+    throw new ApiError(errorText, response.status, exitCode);
+  }
+  return response;
+}
+function getMimeType(filePath) {
+  const ext = filePath.toLowerCase().split(".").pop();
+  const mimeTypes = {
+    // Documents
+    pdf: "application/pdf",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    // Images
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    // Text
+    txt: "text/plain",
+    md: "text/markdown",
+    csv: "text/csv",
+    json: "application/json",
+    html: "text/html",
+    css: "text/css",
+    js: "application/javascript",
+    ts: "text/x-typescript",
+    py: "text/x-python"
+  };
+  return mimeTypes[ext || ""] || "application/octet-stream";
+}
+async function uploadFile(filePath) {
+  const apiKey = getApiKey();
+  const apiUrl = getApiUrl();
+  if (!apiKey) {
+    throw new ApiError(
+      "API key not configured. Run 'conceptcraft config init' or set CC_SLIDES_API_KEY environment variable.",
+      401,
+      2
+    );
+  }
+  const stat = statSync(filePath);
+  const fileName = basename(filePath);
+  const mimeType = getMimeType(filePath);
+  const presignedResponse = await fetch(`${apiUrl}/api/cli/files/upload`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey
+    },
+    body: JSON.stringify({
+      fileMetadata: {
+        name: fileName,
+        type: mimeType,
+        size: stat.size
+      }
+    })
+  });
+  if (!presignedResponse.ok) {
+    const errorText = await presignedResponse.text();
+    throw new ApiError(
+      errorText || "Failed to get upload URL",
+      presignedResponse.status,
+      1
+    );
+  }
+  const presigned = await presignedResponse.json();
+  const fileBuffer = readFileSync(filePath);
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(presigned.fields || {})) {
+    formData.append(key, value);
+  }
+  const blob = new Blob([fileBuffer], { type: mimeType });
+  formData.append("file", blob, fileName);
+  const uploadResponse = await fetch(presigned.url, {
+    method: "POST",
+    body: formData
+  });
+  if (!uploadResponse.ok) {
+    throw new ApiError(
+      "Failed to upload file to storage",
+      uploadResponse.status,
+      1
+    );
+  }
+  return {
+    id: randomUUID(),
+    name: fileName,
+    url: presigned.fileUrl,
+    size: stat.size,
+    type: mimeType,
+    selected: true
+  };
+}
+async function uploadFiles(filePaths, onProgress) {
+  const results = [];
+  for (let i = 0; i < filePaths.length; i++) {
+    const filePath = filePaths[i];
+    const fileName = basename(filePath);
+    onProgress?.(i, filePaths.length, fileName);
+    const result = await uploadFile(filePath);
+    results.push(result);
+  }
+  onProgress?.(filePaths.length, filePaths.length, "");
+  return results;
+}
+async function createPresentation(options) {
+  const body = {
+    topic: options.topic,
+    slideCount: options.slideCount ?? 10,
+    mode: options.mode ?? "balanced",
+    tone: options.tone ?? "professional",
+    amount: options.amount ?? "concise",
+    audience: options.audience ?? "General Audience",
+    language: options.language ?? "en",
+    stylingMode: options.stylingMode ?? "freeform"
+  };
+  if (options.referenceUrl) {
+    body.referenceUrl = options.referenceUrl;
+  }
+  if (options.thinkingDepth) {
+    body.thinkingDepth = options.thinkingDepth;
+  }
+  if (options.goal) {
+    body.goal = options.goal;
+  }
+  if (options.customGoal) {
+    body.goal = options.customGoal;
+  }
+  const uploadedFiles = [];
+  const contextFiles = [];
+  if (options.uploadedFiles && options.uploadedFiles.length > 0) {
+    uploadedFiles.push(...options.uploadedFiles);
+  }
+  if (options.sources && options.sources.length > 0) {
+    for (const url of options.sources) {
+      contextFiles.push({ url });
+    }
+  }
+  if (options.stdinContent) {
+    uploadedFiles.push({
+      id: `stdin-${Date.now()}`,
+      content: options.stdinContent,
+      title: "Piped Content",
+      mime: "text/plain",
+      selected: true
+    });
+  }
+  if (options.context) {
+    uploadedFiles.push({
+      id: `context-${Date.now()}`,
+      content: options.context,
+      title: "Context",
+      mime: "text/plain",
+      selected: true
+    });
+  }
+  if (uploadedFiles.length > 0 || contextFiles.length > 0) {
+    body.contentSources = {
+      uploadedFiles,
+      contextFiles
+    };
+  }
+  if (options.brandId) {
+    body.designBrandReference = options.brandId;
+  }
+  if (options.teamId) {
+    body.teamId = options.teamId;
+  }
+  return streamRequest("/api/slides/skills/create-presentation", body);
+}
+async function listPresentations(teamId, limit = 20) {
+  const params = new URLSearchParams();
+  params.set("limit", String(limit));
+  if (teamId) {
+    params.set("teamId", teamId);
+  }
+  const response = await request(
+    `/api/cli/presentations?${params}`
+  );
+  return response.presentations;
+}
+async function getPresentation(slugOrId) {
+  return request(`/api/cli/presentation/${slugOrId}`);
+}
+async function deletePresentation(slugOrId) {
+  await request(`/api/cli/presentation/${slugOrId}`, { method: "DELETE" });
+}
+async function exportPresentation(presentationId, options = {}) {
+  const apiKey = getApiKey();
+  const apiUrl = getApiUrl();
+  if (!apiKey) {
+    throw new ApiError(
+      "API key not configured. Run 'conceptcraft config init' or set CC_SLIDES_API_KEY environment variable.",
+      401,
+      2
+    );
+  }
+  const response = await fetch(`${apiUrl}/api/presentations/export`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey
+    },
+    body: JSON.stringify({
+      presentationId,
+      options: {
+        includeImages: options.includeImages ?? true,
+        includeBranding: options.includeBranding ?? true,
+        downloadExternalImages: options.includeExternal ?? true
+      }
+    })
+  });
+  if (!response.ok) {
+    throw new ApiError(
+      await response.text(),
+      response.status,
+      response.status === 404 ? 3 : 1
+    );
+  }
+  return response.arrayBuffer();
+}
+async function importPresentation(fileBuffer, fileName, options = {}) {
+  const apiKey = getApiKey();
+  const apiUrl = getApiUrl();
+  if (!apiKey) {
+    throw new ApiError(
+      "API key not configured. Run 'conceptcraft config init' or set CC_SLIDES_API_KEY environment variable.",
+      401,
+      2
+    );
+  }
+  const formData = new FormData();
+  const blob = new Blob([fileBuffer], { type: "application/zip" });
+  formData.append("file", blob, fileName);
+  formData.append(
+    "options",
+    JSON.stringify({
+      dryRun: options.dryRun ?? false,
+      remapIds: true
+    })
+  );
+  const response = await fetch(`${apiUrl}/api/presentations/import`, {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey
+    },
+    body: formData
+  });
+  const result = await response.json();
+  if (!response.ok) {
+    throw new ApiError(
+      result.errors?.[0]?.message ?? "Import failed",
+      response.status,
+      1
+    );
+  }
+  return result;
+}
+async function listBrandings() {
+  return request("/api/branding");
+}
+async function getBranding(id) {
+  return request(`/api/branding/${id}`);
+}
+async function extractBranding(url, teamId) {
+  return request("/api/branding/extract", {
+    method: "POST",
+    body: { url, teamId }
+  });
+}
+async function whoami() {
+  return request("/api/cli/whoami");
+}
+async function getFeatureFlags() {
+  return request("/api/cli/features");
+}
+async function generateBlog(presentationId, documentCreatedAt, options = {}) {
+  const apiKey = getApiKey();
+  const apiUrl = getApiUrl();
+  if (!apiKey) {
+    throw new ApiError(
+      "API key not configured. Run 'conceptcraft config init' or set CC_SLIDES_API_KEY environment variable.",
+      401,
+      2
+    );
+  }
+  const response = await fetch(
+    `${apiUrl}/api/presentations/${presentationId}/generate-blog`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      body: JSON.stringify({
+        documentCreatedAt,
+        targetWordCount: options.targetWordCount ?? 300,
+        tone: options.tone ?? "professional",
+        language: options.language ?? "en",
+        targetAudience: options.targetAudience ?? "General Audience",
+        blogFormat: options.blogFormat ?? "narrative",
+        customInstructions: options.customInstructions ?? "",
+        includeImages: options.includeImages ?? true,
+        includeTableOfContents: options.includeTableOfContents ?? false
+      })
+    }
+  );
+  if (!response.ok) {
+    throw new ApiError(
+      await response.text(),
+      response.status,
+      response.status === 404 ? 3 : 1
+    );
+  }
+  return response;
+}
+async function checkLimits(teamId) {
+  const params = new URLSearchParams();
+  if (teamId) {
+    params.set("teamId", teamId);
+  }
+  const query = params.toString();
+  return request(`/api/cli/limits${query ? `?${query}` : ""}`);
+}
+async function validateGeneration(mode, slideCount, teamId) {
+  const limits = await checkLimits(teamId);
+  if (!limits.canGenerate[mode]) {
+    const remaining = limits.remaining[mode] ?? 0;
+    const limit = limits.limits[mode] ?? 0;
+    if (limit === 0) {
+      throw new ApiError(
+        `The "${mode}" mode is not available on your ${limits.planName} plan. Available modes: ${limits.availableModes.join(", ") || "none"}`,
+        403,
+        2
+      );
+    }
+    throw new ApiError(
+      `You have reached your ${mode} generation limit for this billing cycle (${limits.usage[mode] ?? 0}/${limit} used). Try a different mode: ${limits.availableModes.join(", ") || "none available"}`,
+      403,
+      4
+    );
+  }
+  if (slideCount > limits.maxSlidesPerPresentation) {
+    throw new ApiError(
+      `Maximum ${limits.maxSlidesPerPresentation} slides allowed on your ${limits.planName} plan (requested: ${slideCount})`,
+      403,
+      6
+    );
+  }
+  return limits;
+}
+
+// src/lib/feature-cache.ts
+import Conf2 from "conf";
+var cache = new Conf2({
+  projectName: "conceptcraft",
+  configName: "feature-cache"
+});
+var FRESH_TTL = 60 * 60 * 1e3;
+var STALE_TTL = 24 * 60 * 60 * 1e3;
+function hashApiKey(key) {
+  let hash = 0;
+  for (let i = 0; i < key.length; i++) {
+    const char = key.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return hash.toString(16);
+}
+function getCachedFlags() {
+  if (!hasApiKey()) return null;
+  const cached = cache.get("featureFlags");
+  if (!cached) return null;
+  const currentKeyHash = hashApiKey(getApiKey());
+  if (cached.apiKeyHash && cached.apiKeyHash !== currentKeyHash) {
+    invalidateCache();
+    return null;
+  }
+  const age = Date.now() - cached.fetchedAt;
+  if (age > STALE_TTL) return null;
+  if (age > FRESH_TTL) {
+    refreshInBackground();
+  }
+  return cached.flags;
+}
+function refreshInBackground() {
+  fetchAndCache().catch(() => {
+  });
+}
+async function fetchAndCache() {
+  const flags = await getFeatureFlags();
+  const apiKey = getApiKey();
+  cache.set("featureFlags", {
+    flags,
+    fetchedAt: Date.now(),
+    apiKeyHash: apiKey ? hashApiKey(apiKey) : void 0
+  });
+  return flags;
+}
+function invalidateCache() {
+  cache.delete("featureFlags");
+}
+function getCachePath() {
+  return cache.path;
+}
+
+// src/lib/output.ts
+import chalk2 from "chalk";
+import Table from "cli-table3";
+function isTTY() {
+  return process.stdout.isTTY ?? false;
+}
+function success(message, format = "human") {
+  if (format === "quiet") return;
+  if (format === "json") return;
+  console.log(chalk2.green("\u2713"), message);
+}
+function error(message, format = "human") {
+  if (format === "quiet") return;
+  if (format === "json") {
+    console.error(JSON.stringify({ error: message }));
+    return;
+  }
+  console.error(chalk2.red("\u2717"), message);
+}
+function warn(message, format = "human") {
+  if (format === "quiet") return;
+  if (format === "json") return;
+  console.warn(chalk2.yellow("\u26A0"), message);
+}
+function info(message, format = "human") {
+  if (format === "quiet") return;
+  if (format === "json") return;
+  console.log(chalk2.blue("\u2139"), message);
+}
+function buildViewUrl(slug, language = "en") {
+  if (!slug) return "N/A";
+  const apiUrl = getApiUrl();
+  return `${apiUrl}/${language}/view/presentations/${slug}`;
+}
+function formatPresentationTable(presentations, options = {}) {
+  const { showLinks = false, language = "en" } = options;
+  const truncate = (str, len) => str.length > len ? str.slice(0, len - 1) + "\u2026" : str;
+  const shortDateTime = (dateStr) => {
+    try {
+      const d = new Date(dateStr);
+      return d.toLocaleString("en-US", {
+        month: "short",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit",
+        hour12: true
+      }).replace(" at ", ", ");
+    } catch {
+      return "-";
+    }
+  };
+  if (showLinks) {
+    const table2 = new Table({
+      head: [
+        chalk2.cyan("Slug"),
+        chalk2.cyan("Title"),
+        chalk2.cyan("Slides"),
+        chalk2.cyan("Created"),
+        chalk2.cyan("URL")
+      ]
+    });
+    for (const p of presentations) {
+      table2.push([
+        truncate(p.slug || p.id.slice(0, 8), 30),
+        truncate(p.title || "Untitled", 22),
+        String(p.numberOfSlides || "-"),
+        shortDateTime(p.createdAt),
+        buildViewUrl(p.slug, language)
+      ]);
+    }
+    return table2.toString();
+  }
+  const table = new Table({
+    head: [
+      chalk2.cyan("Slug"),
+      chalk2.cyan("Title"),
+      chalk2.cyan("Slides"),
+      chalk2.cyan("Mode"),
+      chalk2.cyan("Created")
+    ],
+    colWidths: [32, 28, 8, 11, 18]
+  });
+  for (const p of presentations) {
+    table.push([
+      p.slug || p.id.slice(0, 8),
+      p.title || "Untitled",
+      String(p.numberOfSlides || "-"),
+      p.mode || "-",
+      shortDateTime(p.createdAt)
+    ]);
+  }
+  return table.toString();
+}
+function formatPresentationIds(presentations) {
+  return presentations.map((p) => p.slug || p.id).join("\n");
+}
+function formatBrandingTable(brandings) {
+  const sorted = [...brandings].sort((a, b) => {
+    if (a.isDefault && !b.isDefault) return -1;
+    if (!a.isDefault && b.isDefault) return 1;
+    const dateA = a.createdAt ? new Date(a.createdAt).getTime() : 0;
+    const dateB = b.createdAt ? new Date(b.createdAt).getTime() : 0;
+    return dateB - dateA;
+  });
+  const formatUrl = (url) => {
+    if (!url) return "-";
+    try {
+      const u = new URL(url);
+      return u.href;
+    } catch {
+      return url.startsWith("http") ? url : `https://${url}`;
+    }
+  };
+  const table = new Table({
+    head: [
+      chalk2.cyan("Name"),
+      chalk2.cyan("Source"),
+      chalk2.cyan("Color"),
+      chalk2.cyan("Logo"),
+      chalk2.cyan("Default"),
+      chalk2.cyan("ID")
+    ]
+  });
+  for (const b of sorted) {
+    const colorDisplay = b.primaryColor ? `${chalk2.bgHex(b.primaryColor)("  ")} ${b.primaryColor}` : "-";
+    table.push([
+      b.name,
+      formatUrl(b.sourceUrl),
+      colorDisplay,
+      b.logoUrl ? chalk2.green("\u2713") : chalk2.gray("\u2717"),
+      b.isDefault ? chalk2.green("\u2605") : "",
+      b.id
+    ]);
+  }
+  return table.toString();
+}
+function formatDate(dateStr) {
+  try {
+    const date = new Date(dateStr);
+    return date.toLocaleString();
+  } catch {
+    return dateStr;
+  }
+}
+function header(text) {
+  console.log();
+  console.log(chalk2.bold(text));
+  console.log(chalk2.gray("\u2500".repeat(text.length)));
+}
+function keyValue(key, value) {
+  console.log(`  ${chalk2.gray(key + ":")} ${value ?? "-"}`);
+}
+function progressBar(current, total, width = 30, showPercentage = true) {
+  const percentage = Math.min(100, Math.round(current / total * 100));
+  const filled = Math.round(width * current / total);
+  const empty = width - filled;
+  const bar = chalk2.green("\u2588".repeat(filled)) + chalk2.gray("\u2591".repeat(empty));
+  return showPercentage ? `[${bar}] ${percentage}%` : `[${bar}]`;
+}
+
+// src/commands/config.ts
+var configCommand = new Command("config").description("Manage CLI configuration").addCommand(
+  new Command("init").description("Initialize configuration interactively").action(async () => {
+    console.log();
+    console.log(chalk3.bold("ConceptCraft CLI Configuration"));
+    console.log(chalk3.gray("\u2500".repeat(35)));
+    console.log();
+    try {
+      const apiKey = await password({
+        message: "Enter your API key:",
+        mask: "*",
+        validate: (value) => {
+          if (!value || value.trim().length === 0) {
+            return "API key is required";
+          }
+          if (!isValidApiKeyFormat(value.trim())) {
+            return "Invalid API key format. Keys should start with 'cc_slides_' or 'mcp_'";
+          }
+          return true;
+        }
+      });
+      setApiKey(apiKey.trim());
+      const useCustomUrl = await confirm({
+        message: "Use a custom API URL? (default: www.mindframes.app)",
+        default: false
+      });
+      if (useCustomUrl) {
+        const customUrl = await input({
+          message: "Enter API URL:",
+          default: getApiUrl(),
+          validate: (value) => {
+            try {
+              new URL(value);
+              return true;
+            } catch {
+              return "Invalid URL format";
+            }
+          }
+        });
+        setApiUrl(customUrl);
+      }
+      console.log();
+      const spinner = ora("Verifying API key...").start();
+      try {
+        const result = await whoami();
+        spinner.succeed("API key verified!");
+        console.log();
+        info(`Logged in as: ${result.user.email}`);
+        if (result.teams.length === 0) {
+          warn("No teams found for this user.");
+        } else if (result.teams.length === 1) {
+          const team = result.teams[0];
+          setDefaultTeamId(team.id);
+          info(`Team: ${team.name} (${team.planName})`);
+        } else {
+          console.log();
+          info(`You have access to ${result.teams.length} teams.`);
+          const selectedTeamId = await select({
+            message: "Select your default team:",
+            choices: result.teams.map((team) => ({
+              name: `${team.name} (${team.planName}) - ${team.role}${team.isCurrent ? " [current]" : ""}`,
+              value: team.id
+            })),
+            default: result.currentTeam?.id
+          });
+          setDefaultTeamId(selectedTeamId);
+          const selectedTeam = result.teams.find((t) => t.id === selectedTeamId);
+          success(`Selected team: ${selectedTeam?.name}`);
+        }
+        try {
+          await fetchAndCache();
+        } catch {
+        }
+      } catch (apiErr) {
+        spinner.fail("Failed to verify API key");
+        warn(
+          `Could not verify API key: ${apiErr instanceof Error ? apiErr.message : String(apiErr)}`
+        );
+        warn("You may need to set the team ID manually: conceptcraft config set team-id <id>");
+      }
+      console.log();
+      success("Configuration saved!");
+      info(`Config file: ${getConfigPath()}`);
+      console.log();
+    } catch (err) {
+      if (err.name === "ExitPromptError") {
+        console.log();
+        info("Configuration cancelled.");
+        return;
+      }
+      throw err;
+    }
+  })
+).addCommand(
+  new Command("show").description("Show current configuration").option("--verify", "Verify API key and show team details").action(async (options) => {
+    const config2 = getConfig();
+    header("Current Configuration");
+    console.log();
+    keyValue("API Key", getMaskedApiKey() ?? chalk3.red("Not set"));
+    keyValue("API URL", config2.apiUrl);
+    keyValue("Default Team ID", config2.defaultTeamId ?? chalk3.gray("Not set"));
+    console.log();
+    keyValue("Config file", getConfigPath());
+    if (options.verify && config2.apiKey) {
+      console.log();
+      const spinner = ora("Verifying...").start();
+      try {
+        const result = await whoami();
+        spinner.succeed("Verified");
+        console.log();
+        keyValue("User", result.user.email);
+        if (result.currentTeam) {
+          keyValue("Current Team", `${result.currentTeam.name} (${result.currentTeam.planName})`);
+        }
+        if (result.teams.length > 1) {
+          keyValue("Total Teams", String(result.teams.length));
+        }
+      } catch (err) {
+        spinner.fail("Verification failed");
+        warn(err instanceof Error ? err.message : String(err));
+      }
+    }
+    console.log();
+  })
+).addCommand(
+  new Command("set").description("Set a configuration value").argument("<key>", "Configuration key (api-key, api-url, team-id)").argument("<value>", "Value to set").action(async (key, value) => {
+    switch (key) {
+      case "api-key":
+        if (!isValidApiKeyFormat(value)) {
+          error("Invalid API key format. Keys should start with 'cc_slides_' or 'mcp_'");
+          process.exit(6);
+        }
+        setApiKey(value);
+        invalidateCache();
+        success("API key updated");
+        fetchAndCache().catch(() => {
+        });
+        break;
+      case "api-url":
+        try {
+          new URL(value);
+          setApiUrl(value);
+          success(`API URL set to: ${value}`);
+        } catch {
+          error("Invalid URL format");
+          process.exit(6);
+        }
+        break;
+      case "team-id":
+        setDefaultTeamId(value);
+        success(`Default team ID set to: ${value}`);
+        break;
+      default:
+        error(`Unknown config key: ${key}`);
+        console.log(chalk3.gray("Valid keys: api-key, api-url, team-id"));
+        process.exit(6);
+    }
+  })
+).addCommand(
+  new Command("clear").description("Clear all configuration").action(async () => {
+    try {
+      const confirmed = await confirm({
+        message: "Are you sure you want to clear all configuration?",
+        default: false
+      });
+      if (confirmed) {
+        clearConfig();
+        invalidateCache();
+        success("Configuration cleared");
+      } else {
+        info("Cancelled");
+      }
+    } catch {
+      info("Cancelled");
+    }
+  })
+).addCommand(
+  new Command("refresh").description("Refresh cached feature flags").action(async () => {
+    const spinner = ora("Refreshing feature flags...").start();
+    try {
+      await fetchAndCache();
+      spinner.succeed("Feature flags refreshed");
+      info("Run 'conceptcraft --help' to see updated commands");
+    } catch (err) {
+      spinner.fail("Failed to refresh");
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  })
+).addCommand(
+  new Command("path").description("Show configuration file path").option("--cache", "Show feature cache file path").action((options) => {
+    if (options.cache) {
+      console.log(getCachePath());
+    } else {
+      console.log(getConfigPath());
+    }
+  })
+);
+
+// src/commands/create.ts
+import { Command as Command2 } from "commander";
+import chalk5 from "chalk";
+
+// src/lib/streaming.ts
+import { createParser } from "eventsource-parser";
+import chalk4 from "chalk";
+import ora2 from "ora";
+async function handleStream(response, callbacks, options = {}) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("Response body is not readable");
+  }
+  const decoder = new TextDecoder();
+  let documentId;
+  let slug;
+  let title;
+  let totalSlides = 0;
+  let currentSlide = 0;
+  let totalTokens = 0;
+  let slideTokens = {};
+  const parser = createParser({
+    onEvent: (event) => {
+      if (event.data === "[DONE]") return;
+      try {
+        const parsed = JSON.parse(event.data);
+        const { type, data } = parsed;
+        if (options.debug) {
+          console.log(chalk4.gray(`[SSE] ${type}:`), data);
+        }
+        callbacks.onData?.(type, data);
+        switch (type) {
+          case "data-id":
+            documentId = data;
+            break;
+          case "data-slug":
+            slug = data;
+            break;
+          case "data-title":
+            title = data;
+            break;
+          case "data-slides-number-of-slides":
+            totalSlides = data;
+            break;
+          case "data-slide-progress": {
+            const progress = data;
+            currentSlide = progress.current;
+            totalSlides = progress.total;
+            callbacks.onProgress?.(currentSlide, totalSlides);
+            callbacks.onSlide?.(currentSlide, totalSlides);
+            break;
+          }
+          case "data-overall-progress": {
+            const progress = data;
+            callbacks.onPhase?.(progress.phase, progress.percentage);
+            if (progress.details?.slides) {
+              currentSlide = progress.details.slides.complete;
+              totalSlides = progress.details.slides.total;
+              callbacks.onProgress?.(currentSlide, totalSlides);
+              callbacks.onSlide?.(currentSlide, totalSlides);
+            }
+            break;
+          }
+          case "data-structure-tokens": {
+            totalTokens = data;
+            callbacks.onTokens?.(totalTokens);
+            break;
+          }
+          case "data-slide-meta-tokens": {
+            const [slideId, tokens] = data.split(":");
+            if (slideId && tokens) {
+              slideTokens[slideId] = parseInt(tokens, 10);
+              const allSlideTokens = Object.values(slideTokens).reduce((sum, t) => sum + t, 0);
+              totalTokens = Math.max(totalTokens, allSlideTokens);
+              callbacks.onTokens?.(totalTokens + allSlideTokens);
+            }
+            break;
+          }
+          case "data-generation-meta-estimated-time": {
+            callbacks.onEstimatedTime?.(data);
+            break;
+          }
+          case "data-finish":
+            callbacks.onComplete?.({
+              id: documentId,
+              slug,
+              title,
+              slidesCount: totalSlides
+            });
+            break;
+          case "error":
+            if (data) {
+              callbacks.onError?.(data);
+            }
+            break;
+        }
+      } catch (e) {
+        if (options.debug) {
+          console.log(chalk4.gray("[SSE Raw]"), event.data);
+        }
+      }
+    }
+  });
+  let done = false;
+  while (!done) {
+    const result = await reader.read();
+    done = result.done;
+    if (result.value) {
+      const chunk = decoder.decode(result.value, { stream: true });
+      parser.feed(chunk);
+    }
+  }
+  return {
+    id: documentId,
+    slug,
+    title,
+    slidesCount: totalSlides
+  };
+}
+async function streamWithProgress(response, topic, options) {
+  const useTTY = isTTY() && !options.noStream && !options.quiet && !options.json;
+  if (!options.json) {
+    console.log();
+    console.log(chalk4.bold(`Creating presentation: "${topic}"`));
+    console.log(
+      chalk4.gray(
+        `Quality: ${options.mode} | Tone: ${options.tone ?? "professional"} | Slides: ${options.slideCount} | Language: ${options.language}`
+      )
+    );
+    console.log();
+  }
+  let spinner;
+  let lastProgress = "";
+  let currentPhase = "Preparing";
+  let currentPercentage = 0;
+  let currentSlides = { done: 0, total: options.slideCount };
+  let currentTokens = 0;
+  let estimatedTime = 0;
+  let startTime = Date.now();
+  let timer;
+  const formatTime = (seconds) => {
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${mins}:${secs.toString().padStart(2, "0")}`;
+  };
+  const getElapsed = () => Math.floor((Date.now() - startTime) / 1e3);
+  const getRemaining = () => {
+    if (!estimatedTime) return " \u2014:\u2014\u2014";
+    const remaining = Math.max(0, estimatedTime - getElapsed());
+    if (remaining === 0 && currentPercentage < 100) return "soon!";
+    return formatTime(remaining);
+  };
+  const formatTokens = (tokens) => {
+    if (tokens >= 1e3) {
+      return `${(tokens / 1e3).toFixed(1)}k`.padStart(5, " ");
+    }
+    return `${tokens}tk`.padStart(5, " ");
+  };
+  const getPhaseLabel = (phase) => {
+    const phaseMap = {
+      "structure-generation": "Planning ",
+      "slide-generation": "Writing  ",
+      "image-generation": "Images   ",
+      "assembling": "Finishing",
+      "completed": "Done     "
+    };
+    return phaseMap[phase] || "Working  ";
+  };
+  const buildProgressLine = () => {
+    const bar = progressBar(currentPercentage, 100, 20, false);
+    const pct = String(currentPercentage).padStart(3, " ");
+    const phase = getPhaseLabel(currentPhase);
+    const slides = `${String(currentSlides.done).padStart(2, " ")}/${String(currentSlides.total).padEnd(2, " ")}`;
+    const tokens = formatTokens(currentTokens);
+    const elapsed = formatTime(getElapsed()).padStart(5, " ");
+    const remaining = getRemaining().padStart(5, " ");
+    return `${bar} ${chalk4.bold(pct)}${chalk4.gray("%")} ${chalk4.cyan(phase)} ${chalk4.gray(slides)} ${chalk4.yellow(tokens)} ${chalk4.gray(elapsed)} ${chalk4.green(remaining + " left")}`;
+  };
+  if (useTTY) {
+    spinner = ora2({
+      text: buildProgressLine(),
+      spinner: "dots"
+    }).start();
+    timer = setInterval(() => {
+      if (spinner && spinner.isSpinning) {
+        spinner.text = buildProgressLine();
+      }
+    }, 100);
+  }
+  const result = await handleStream(
+    response,
+    {
+      onProgress: (current, total) => {
+        currentSlides = { done: current, total };
+        if (!useTTY && !options.quiet && !options.json) {
+          const progress = `${currentPhase.trim()}: slide ${current}/${total}`;
+          if (progress !== lastProgress) {
+            console.log(progress);
+            lastProgress = progress;
+          }
+        }
+      },
+      onPhase: (phase, percentage) => {
+        currentPhase = getPhaseLabel(phase);
+        currentPercentage = percentage;
+      },
+      onTokens: (tokens) => {
+        currentTokens = tokens;
+      },
+      onEstimatedTime: (seconds) => {
+        estimatedTime = seconds;
+      },
+      onError: (error2) => {
+        if (timer) clearInterval(timer);
+        if (spinner) {
+          spinner.fail(chalk4.red(`Error: ${error2}`));
+        } else if (!options.json) {
+          console.error(chalk4.red(`Error: ${error2}`));
+        }
+      },
+      onComplete: (data) => {
+        if (timer) clearInterval(timer);
+        if (spinner) {
+          currentPercentage = 100;
+          currentPhase = "Done";
+          spinner.succeed(buildProgressLine());
+        } else if (!options.json) {
+          const tokenStr = currentTokens > 0 ? ` | ${currentTokens.toLocaleString()} tokens` : "";
+          console.log(`Done! [${formatTime(getElapsed())}${tokenStr}]`);
+        }
+      }
+    },
+    { debug: options.debug }
+  );
+  return {
+    ...result,
+    elapsedSeconds: getElapsed(),
+    totalTokens: currentTokens
+  };
+}
+async function streamTextContent(response, options = {}) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("Response body is not readable");
+  }
+  const decoder = new TextDecoder();
+  let content = "";
+  let done = false;
+  while (!done) {
+    const result = await reader.read();
+    done = result.done;
+    if (result.value) {
+      const chunk = decoder.decode(result.value, { stream: true });
+      content += chunk;
+      if (!options.quiet) {
+        process.stdout.write(chunk);
+      }
+    }
+  }
+  if (!options.quiet) {
+    console.log();
+  }
+  return content;
+}
+
+// src/commands/create.ts
+import { readFileSync as readFileSync2, existsSync } from "fs";
+import { resolve } from "path";
+var VALID_GOALS = [
+  "inform",
+  "persuade",
+  "train",
+  "learn",
+  "entertain",
+  "report"
+];
+var createCommand = new Command2("create").description("Create a new presentation").argument("<topic>", "The topic or title for the presentation").option("-n, --slides <count>", "Number of slides (1-20)", "10").option(
+  "-m, --mode <mode>",
+  "Generation quality mode (best, balanced, fast, ultrafast, instant)",
+  "balanced"
+).option(
+  "-t, --tone <tone>",
+  "Presentation tone (creative, professional, educational, formal, casual)",
+  "professional"
+).option(
+  "--amount <amount>",
+  "Content density (minimal, concise, detailed, extensive)",
+  "concise"
+).option("--audience <text>", "Target audience description", "General Audience").option("-l, --language <lang>", "Output language", "en").option("-b, --brand <id|url>", "Branding ID or URL to extract from").option(
+  "-c, --context <text>",
+  "Text context to inform slide content (e.g., research notes, key facts)"
+).option(
+  "--context-file <path>",
+  "Path to a file containing context (text, markdown, or JSON)"
+).option(
+  "--sources <urls...>",
+  "URLs to scrape for context (space-separated). Content will be fetched and used"
+).option("--stdin", "Read context content from stdin (pipe data into the command)").option(
+  "-f, --file <paths...>",
+  "Files to upload (PDF, PPTX, DOCX, images). Use multiple times for multiple files"
+).option(
+  "-g, --goal <type>",
+  "Presentation goal (inform, persuade, train, learn, entertain, report)"
+).option(
+  "--custom-goal <text>",
+  "Custom goal description (overrides --goal)"
+).option(
+  "--styling <mode>",
+  "Styling mode (freeform, brand-only, brand-plus-style, style-only, no-styling)",
+  "freeform"
+).option(
+  "--reference-url <url>",
+  "URL to an image or template to use as a style reference"
+).option(
+  "--thinking-depth <depth>",
+  "AI thinking depth (quick, moderate, deep, profound)",
+  "moderate"
+).option("-o, --output <format>", "Output format (human, json, quiet)", "human").option("--no-stream", "Wait for completion without progress display").option("--debug", "Enable debug logging").option("--team-id <id>", "Team ID to create presentation for (switch teams)").addHelpText(
+  "after",
+  `
+${chalk5.bold("Recommended Usage:")}
+  Always specify slides (-n), mode (-m), audience, and context for best results.
+
+${chalk5.bold("Examples:")}
+  ${chalk5.gray("# Content from PDF + style from image reference")}
+  $ conceptcraft create "Quarterly Report" \\
+      --file ./report.pdf \\
+      --reference-url https://example.com/style-template.png \\
+      -n 12 -m best --audience "Executive team"
+
+  ${chalk5.gray("# Upload content files (PDF, PPTX, DOCX)")}
+  $ conceptcraft create "Product Demo" \\
+      --file ./existing-deck.pptx --file ./specs.pdf \\
+      --goal persuade --audience "Enterprise buyers"
+
+  ${chalk5.gray("# Inline context with custom styling")}
+  $ conceptcraft create "Q4 Business Review" \\
+      -n 12 -m best --goal inform \\
+      --context "Revenue: $50M (+25% YoY), EBITDA: $8M" \\
+      --reference-url https://example.com/brand-style.jpg
+
+  ${chalk5.gray("# Research presentation from URLs")}
+  $ conceptcraft create "AI Industry Trends" \\
+      -n 10 -m best -t educational \\
+      --sources https://example.com/ai-report.pdf
+
+  ${chalk5.gray("# Pipe content from another command")}
+  $ cat meeting-notes.md | conceptcraft create "Meeting Summary" \\
+      -n 6 -m balanced --goal inform
+
+${chalk5.bold("Content Options (what to include in slides):")}
+  -f, --file <paths...>      Upload files for content extraction (PDF, PPTX, DOCX)
+  -c, --context <text>       Inline text (key facts, data points)
+  --context-file <path>      Read content from file (markdown, text, JSON)
+  --sources <urls...>        URLs to scrape for content
+  --stdin                    Pipe content from another command
+
+${chalk5.bold("Styling Options (how slides look):")}
+  --reference-url <url>      ${chalk5.yellow("Image URL to guide visual style")} (colors, layout, feel)
+  --styling <mode>           freeform, brand-only, style-only, no-styling
+  -b, --brand <id>           Apply saved brand settings
+
+  ${chalk5.gray("NOTE: --file uploads provide CONTENT (data, text to include)")}
+  ${chalk5.gray("      --reference-url provides STYLE (visual design inspiration)")}
+
+${chalk5.bold("Goal Options:")}
+  -g, --goal <type>          inform, persuade, train, learn, entertain, report
+  --custom-goal <text>       Custom goal description
+
+${chalk5.bold("Mode Reference:")}
+  best       Highest quality, thorough research (recommended for important decks)
+  balanced   Good quality with reasonable speed (default)
+  fast       Quick generation, less refinement
+  ultrafast  Very quick, minimal processing
+  instant    Fastest, basic output
+`
+).action(async (topic, options) => {
+  requireAuth();
+  const slideCount = parseInt(options.slides, 10);
+  if (isNaN(slideCount) || slideCount < 1 || slideCount > 20) {
+    error("Slide count must be between 1 and 20");
+    process.exit(6);
+  }
+  const validModes = [
+    "best",
+    "balanced",
+    "fast",
+    "ultrafast",
+    "instant"
+  ];
+  if (!validModes.includes(options.mode)) {
+    error(
+      `Invalid mode: ${options.mode}. Valid modes: ${validModes.join(", ")}`
+    );
+    process.exit(6);
+  }
+  const validTones = [
+    "creative",
+    "professional",
+    "educational",
+    "formal",
+    "casual"
+  ];
+  if (!validTones.includes(options.tone)) {
+    error(
+      `Invalid tone: ${options.tone}. Valid tones: ${validTones.join(", ")}`
+    );
+    process.exit(6);
+  }
+  const validAmounts = [
+    "minimal",
+    "concise",
+    "detailed",
+    "extensive"
+  ];
+  if (!validAmounts.includes(options.amount)) {
+    error(
+      `Invalid amount: ${options.amount}. Valid amounts: ${validAmounts.join(", ")}`
+    );
+    process.exit(6);
+  }
+  const validStyling = [
+    "freeform",
+    "brand-only",
+    "brand-plus-style",
+    "style-only",
+    "no-styling"
+  ];
+  if (!validStyling.includes(options.styling)) {
+    error(
+      `Invalid styling: ${options.styling}. Valid modes: ${validStyling.join(", ")}`
+    );
+    process.exit(6);
+  }
+  const validThinkingDepths = [
+    "quick",
+    "moderate",
+    "deep",
+    "profound"
+  ];
+  if (!validThinkingDepths.includes(options.thinkingDepth)) {
+    error(
+      `Invalid thinking depth: ${options.thinkingDepth}. Valid depths: ${validThinkingDepths.join(", ")}`
+    );
+    process.exit(6);
+  }
+  if (options.goal && !VALID_GOALS.includes(options.goal)) {
+    error(
+      `Invalid goal: ${options.goal}. Valid goals: ${VALID_GOALS.join(", ")}`
+    );
+    process.exit(6);
+  }
+  try {
+    if (options.output !== "json" && options.output !== "quiet") {
+      process.stdout.write(chalk5.gray("Checking generation limits... "));
+    }
+    const limits = await validateGeneration(options.mode, slideCount, options.teamId);
+    if (options.output !== "json" && options.output !== "quiet") {
+      console.log(chalk5.green("\u2713"));
+      console.log(
+        chalk5.gray(
+          `  Plan: ${limits.planName} | ${options.mode}: ${limits.remaining[options.mode]}/${limits.limits[options.mode]} remaining`
+        )
+      );
+    }
+  } catch (err) {
+    if (options.output === "json") {
+      console.log(
+        JSON.stringify({
+          success: false,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    } else {
+      console.log(chalk5.red("\u2717"));
+      error(err instanceof Error ? err.message : String(err));
+    }
+    process.exit(err.exitCode ?? 1);
+  }
+  let uploadedFiles = [];
+  if (options.file && options.file.length > 0) {
+    for (const filePath of options.file) {
+      const resolved = resolve(filePath);
+      if (!existsSync(resolved)) {
+        error(`File not found: ${filePath}`);
+        process.exit(6);
+      }
+    }
+    if (options.output !== "json" && options.output !== "quiet") {
+      console.log(chalk5.gray(`
+Uploading ${options.file.length} file(s)...`));
+    }
+    try {
+      uploadedFiles = await uploadFiles(
+        options.file.map((f) => resolve(f)),
+        (completed, total, fileName) => {
+          if (options.output !== "json" && options.output !== "quiet" && fileName) {
+            process.stdout.write(
+              `\r  ${chalk5.cyan("\u2B06")} Uploading: ${fileName} (${completed + 1}/${total})`
+            );
+          }
+        }
+      );
+      if (options.output !== "json" && options.output !== "quiet") {
+        console.log(`\r  ${chalk5.green("\u2713")} Uploaded ${uploadedFiles.length} file(s)          `);
+      }
+    } catch (err) {
+      error(
+        `Failed to upload files: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+  }
+  let stdinContent;
+  const hasStdinData = !process.stdin.isTTY;
+  if (options.stdin || hasStdinData) {
+    stdinContent = await readStdin();
+    if (options.stdin && !stdinContent) {
+      error("No content received from stdin");
+      process.exit(6);
+    }
+  }
+  let contextContent = options.context;
+  if (options.contextFile) {
+    try {
+      contextContent = readFileSync2(options.contextFile, "utf-8");
+      if (!contextContent.trim()) {
+        error(`Context file is empty: ${options.contextFile}`);
+        process.exit(6);
+      }
+    } catch (err) {
+      error(`Failed to read context file: ${options.contextFile}`);
+      process.exit(6);
+    }
+  }
+  let brandId = options.brand;
+  if (options.brand && isUrl(options.brand)) {
+    brandId = options.brand;
+  }
+  const hasContext = stdinContent || contextContent || options.sources && options.sources.length > 0 || uploadedFiles.length > 0;
+  if (!hasContext) {
+    error("Context is required to create a presentation.");
+    console.log();
+    console.log(chalk5.gray("Provide context using one of these methods:"));
+    console.log(chalk5.gray("  -f, --file <paths...>     Upload files (PDF, PPTX, images)"));
+    console.log(chalk5.gray("  -c, --context <text>      Direct text context"));
+    console.log(chalk5.gray("  --context-file <path>     Read from a file"));
+    console.log(chalk5.gray("  --sources <urls...>       URLs to scrape"));
+    console.log(chalk5.gray("  cat file | conceptcraft   Pipe content"));
+    console.log();
+    console.log(chalk5.gray("Example:"));
+    console.log(chalk5.cyan('  conceptcraft create "Q4 Report" --file ./report.pdf'));
+    console.log(chalk5.cyan('  conceptcraft create "Q4 Report" --context "Revenue: $10M, Growth: 25%"'));
+    process.exit(6);
+  }
+  try {
+    const response = await createPresentation({
+      topic,
+      slideCount,
+      mode: options.mode,
+      tone: options.tone,
+      amount: options.amount,
+      audience: options.audience,
+      language: options.language,
+      brandId,
+      sources: options.sources,
+      stdinContent,
+      context: contextContent,
+      stylingMode: options.styling,
+      referenceUrl: options.referenceUrl,
+      thinkingDepth: options.thinkingDepth,
+      // New options
+      uploadedFiles: uploadedFiles.length > 0 ? uploadedFiles : void 0,
+      goal: options.goal,
+      customGoal: options.customGoal,
+      teamId: options.teamId
+    });
+    const result = await streamWithProgress(response, topic, {
+      slideCount,
+      mode: options.mode,
+      tone: options.tone,
+      language: options.language,
+      noStream: options.noStream,
+      debug: options.debug,
+      quiet: options.output === "quiet",
+      json: options.output === "json"
+    });
+    if (options.output === "json") {
+      console.log(
+        JSON.stringify(
+          {
+            success: true,
+            presentation: {
+              slug: result.slug,
+              title: result.title ?? topic,
+              slidesCount: result.slidesCount,
+              elapsedSeconds: result.elapsedSeconds,
+              totalTokens: result.totalTokens
+            },
+            viewUrl: buildViewUrl(result.slug, options.language)
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log();
+      success("Presentation created successfully");
+      console.log();
+      keyValue("Title", result.title ?? topic);
+      keyValue("Slides", String(result.slidesCount ?? slideCount));
+      const stats = [];
+      if (result.elapsedSeconds) {
+        const mins = Math.floor(result.elapsedSeconds / 60);
+        const secs = result.elapsedSeconds % 60;
+        stats.push(mins > 0 ? `${mins}m ${secs}s` : `${secs}s`);
+      }
+      if (result.totalTokens) {
+        stats.push(`${result.totalTokens.toLocaleString()} tokens`);
+      }
+      if (stats.length > 0) {
+        keyValue("Generated in", stats.join(" \xB7 "));
+      }
+      console.log();
+      const viewUrl = buildViewUrl(result.slug, options.language);
+      if (viewUrl !== "N/A") {
+        console.log(chalk5.bold("  Open: ") + chalk5.cyan.underline(viewUrl));
+      }
+      console.log();
+    }
+  } catch (err) {
+    if (options.output === "json") {
+      console.log(
+        JSON.stringify({
+          success: false,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    } else {
+      error(err instanceof Error ? err.message : String(err));
+    }
+    process.exit(err.exitCode ?? 1);
+  }
+});
+async function readStdin() {
+  return new Promise((resolve4) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    if (process.stdin.isTTY) {
+      resolve4("");
+      return;
+    }
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      resolve4(data.trim());
+    });
+    setTimeout(() => {
+      resolve4(data.trim());
+    }, 100);
+  });
+}
+function isUrl(str) {
+  try {
+    new URL(str);
+    return true;
+  } catch {
+    return str.startsWith("http://") || str.startsWith("https://");
+  }
+}
+
+// src/commands/list.ts
+import { Command as Command3 } from "commander";
+var listCommand = new Command3("list").description("List presentations").option("-n, --limit <count>", "Number of results to return", "20").option(
+  "-f, --format <format>",
+  "Output format (table, json, ids)",
+  "table"
+).option("--sort <field>", "Sort by field (created, updated, title)").option("--team-id <id>", "Team ID (uses default if not specified)").option("-d, --detail", "Show detailed output including URLs").option("-l, --language <lang>", "Language for URLs", "en").action(async (options) => {
+  requireAuth();
+  const limit = parseInt(options.limit, 10);
+  if (isNaN(limit) || limit < 1) {
+    error("Invalid limit value");
+    process.exit(6);
+  }
+  const teamId = options.teamId ?? getDefaultTeamId();
+  if (!teamId) {
+    error(
+      "Team ID required. Set a default with 'conceptcraft config set team-id <id>' or use --team-id"
+    );
+    process.exit(6);
+  }
+  try {
+    const presentations = await listPresentations(teamId, limit);
+    if (presentations.length === 0) {
+      if (options.format === "json") {
+        console.log(JSON.stringify([]));
+      } else if (options.format !== "ids") {
+        info("No presentations found");
+      }
+      return;
+    }
+    if (options.sort) {
+      presentations.sort((a, b) => {
+        switch (options.sort) {
+          case "created":
+            return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+          case "title":
+            return (a.title || "").localeCompare(b.title || "");
+          default:
+            return 0;
+        }
+      });
+    }
+    switch (options.format) {
+      case "json":
+        console.log(JSON.stringify(presentations, null, 2));
+        break;
+      case "ids":
+        console.log(formatPresentationIds(presentations));
+        break;
+      case "table":
+      default:
+        console.log(formatPresentationTable(presentations, {
+          showLinks: options.detail,
+          language: options.language
+        }));
+        break;
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(err.exitCode ?? 1);
+  }
+});
+
+// src/commands/get.ts
+import { Command as Command4 } from "commander";
+import chalk6 from "chalk";
+var getCommand = new Command4("get").description("Get presentation details").argument("<slug>", "Presentation slug (e.g., my-presentation-v1-abc123)").option(
+  "-f, --format <format>",
+  "Output format (summary, full, json)",
+  "summary"
+).option("--include <fields>", "Fields to include (comma-separated: slides,styling)").option("-l, --language <lang>", "Language for view URL", "en").action(async (slug, options) => {
+  requireAuth();
+  try {
+    const presentation = await getPresentation(slug);
+    if (options.format === "json") {
+      console.log(JSON.stringify(presentation, null, 2));
+      return;
+    }
+    const viewUrl = buildViewUrl(presentation.slug, options.language);
+    header("Presentation Details");
+    console.log();
+    keyValue("Slug", presentation.slug);
+    keyValue("Title", presentation.title || "Untitled");
+    keyValue("Description", presentation.description || chalk6.gray("None"));
+    keyValue("Slides", String(presentation.numberOfSlides || "-"));
+    keyValue("Mode", presentation.mode || "-");
+    keyValue("Created", formatDate(presentation.createdAt));
+    if (presentation.updatedAt) {
+      keyValue("Updated", formatDate(presentation.updatedAt));
+    }
+    console.log();
+    if (viewUrl !== "N/A") {
+      console.log(chalk6.bold("  Open: ") + chalk6.cyan.underline(viewUrl));
+    }
+    console.log();
+    if (options.format === "full" && options.include?.includes("slides")) {
+      console.log(chalk6.gray("(Full slide content available in JSON format)"));
+      console.log();
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(err.exitCode ?? 1);
+  }
+});
+
+// src/commands/delete.ts
+import { Command as Command5 } from "commander";
+import { confirm as confirm2 } from "@inquirer/prompts";
+var deleteCommand = new Command5("delete").description("Delete a presentation").argument("<slug>", "Presentation slug (e.g., my-presentation-v1-abc123)").option("-f, --force", "Skip confirmation prompt").option("-q, --quiet", "Suppress output").action(async (slug, options) => {
+  requireAuth();
+  if (!options.force) {
+    try {
+      const confirmed = await confirm2({
+        message: `Are you sure you want to delete presentation "${slug}"?`,
+        default: false
+      });
+      if (!confirmed) {
+        if (!options.quiet) {
+          warn("Deletion cancelled");
+        }
+        return;
+      }
+    } catch {
+      if (!options.quiet) {
+        warn("Deletion cancelled");
+      }
+      return;
+    }
+  }
+  try {
+    await deletePresentation(slug);
+    if (!options.quiet) {
+      success(`Presentation "${slug}" deleted`);
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(err.exitCode ?? 1);
+  }
+});
+
+// src/commands/export.ts
+import { Command as Command6 } from "commander";
+import { writeFile } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import ora3 from "ora";
+var exportCommand = new Command6("export").description("Export a presentation to ZIP").argument("<slug>", "Presentation slug (e.g., my-presentation-v1-abc123)").option("-o, --output <path>", "Output file path").option("--include-images", "Include images (default: true)", true).option("--include-branding", "Include branding (default: true)", true).option("--no-external", "Skip external image downloads").action(async (slug, options) => {
+  requireAuth();
+  const spinner = ora3("Fetching presentation...").start();
+  try {
+    const presentation = await getPresentation(slug);
+    const title = presentation.title || slug;
+    const presentationId = presentation.id;
+    const sanitizedSlug = slug.replace(/[^a-z0-9-]/gi, "_").toLowerCase().substring(0, 50);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const defaultFileName = `${sanitizedSlug}_${timestamp}.zip`;
+    const outputPath = options.output ? resolve2(options.output) : resolve2(process.cwd(), defaultFileName);
+    spinner.text = `Exporting "${title}"...`;
+    const buffer = await exportPresentation(presentationId, {
+      includeImages: options.includeImages,
+      includeBranding: options.includeBranding,
+      includeExternal: !options.noExternal
+    });
+    spinner.text = "Saving file...";
+    await writeFile(outputPath, Buffer.from(buffer));
+    spinner.succeed("Export complete!");
+    console.log();
+    info(`File saved: ${outputPath}`);
+    info(`Size: ${formatBytes(buffer.byteLength)}`);
+    console.log();
+  } catch (err) {
+    spinner.fail("Export failed");
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(err.exitCode ?? 1);
+  }
+});
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/commands/import.ts
+import { Command as Command7 } from "commander";
+import { readFile } from "fs/promises";
+import { resolve as resolve3, basename as basename2 } from "path";
+import ora4 from "ora";
+var cmd = new Command7("import").description("Import a presentation from ZIP (admin only)").argument("<file>", "Path to ZIP file");
+cmd._hidden = true;
+var importCommand = cmd.option("--dry-run", "Validate without importing").option("--overwrite", "Overwrite existing presentations").option("--remap-ids", "Generate new IDs (default: true)", true).action(async (file, options) => {
+  requireAuth();
+  try {
+    const me = await whoami();
+    if (me.user.role !== "admin") {
+      error("This command is only available to administrators");
+      process.exit(2);
+    }
+  } catch (err) {
+    error("Failed to verify permissions");
+    process.exit(2);
+  }
+  const filePath = resolve3(file);
+  const fileName = basename2(filePath);
+  if (!fileName.endsWith(".zip")) {
+    error("File must be a ZIP archive");
+    process.exit(6);
+  }
+  const spinner = ora4("Reading file...").start();
+  try {
+    const fileBuffer = await readFile(filePath);
+    if (options.dryRun) {
+      spinner.text = "Validating...";
+    } else {
+      spinner.text = "Importing presentation...";
+    }
+    const result = await importPresentation(fileBuffer, fileName, {
+      dryRun: options.dryRun
+    });
+    if (result.success) {
+      if (options.dryRun) {
+        spinner.succeed("Validation passed!");
+        console.log();
+        info("The file is valid and can be imported.");
+        if (result.statistics) {
+          console.log();
+          keyValue("Slides", String(result.statistics.slidesImported));
+          keyValue("Images", String(result.statistics.imagesUploaded));
+        }
+      } else {
+        spinner.succeed("Import complete!");
+        console.log();
+        keyValue("Presentation ID", result.presentationId ?? "N/A");
+        keyValue("Document ID", result.documentId ?? "N/A");
+        if (result.statistics) {
+          keyValue("Slides imported", String(result.statistics.slidesImported));
+          keyValue("Images uploaded", String(result.statistics.imagesUploaded));
+          keyValue("Time", `${result.statistics.totalTimeMs}ms`);
+        }
+        if (result.presentationId) {
+          const apiUrl = getApiUrl();
+          keyValue("View URL", `${apiUrl}/p/${result.presentationId}`);
+        }
+      }
+      if (result.warnings && result.warnings.length > 0) {
+        console.log();
+        for (const warning of result.warnings) {
+          warn(warning);
+        }
+      }
+      console.log();
+    } else {
+      spinner.fail("Import failed");
+      console.log();
+      if (result.errors) {
+        for (const err of result.errors) {
+          error(`${err.type}: ${err.message}`);
+        }
+      }
+      process.exit(1);
+    }
+  } catch (err) {
+    spinner.fail("Import failed");
+    if (err.code === "ENOENT") {
+      error(`File not found: ${filePath}`);
+      process.exit(3);
+    }
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(err.exitCode ?? 1);
+  }
+});
+
+// src/commands/branding.ts
+import { Command as Command8 } from "commander";
+import chalk7 from "chalk";
+import ora5 from "ora";
+var brandingCommand = new Command8("branding").description("Manage brand profiles").addCommand(
+  new Command8("list").description("List brand profiles").option("-f, --format <format>", "Output format (table, json)", "table").action(async (options) => {
+    requireAuth();
+    try {
+      const result = await listBrandings();
+      if (result.brandings.length === 0) {
+        if (options.format === "json") {
+          console.log(JSON.stringify([]));
+        } else {
+          info("No brand profiles found");
+          console.log();
+          console.log(
+            chalk7.gray(
+              "Create one with: conceptcraft branding extract <url>"
+            )
+          );
+        }
+        return;
+      }
+      if (options.format === "json") {
+        console.log(JSON.stringify(result.brandings, null, 2));
+      } else {
+        console.log(formatBrandingTable(result.brandings));
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(err.exitCode ?? 1);
+    }
+  })
+).addCommand(
+  new Command8("get").description("Get brand profile details").argument("<id>", "Brand profile ID").option("-f, --format <format>", "Output format (summary, json)", "summary").action(async (id, options) => {
+    requireAuth();
+    try {
+      const brand2 = await getBranding(id);
+      if (options.format === "json") {
+        console.log(JSON.stringify(brand2, null, 2));
+      } else {
+        header("Brand Profile");
+        console.log();
+        keyValue("ID", brand2.id);
+        keyValue("Name", brand2.name);
+        keyValue("Source URL", brand2.sourceUrl ?? chalk7.gray("None"));
+        keyValue("Default", brand2.isDefault ? chalk7.green("Yes") : "No");
+        if (brand2.createdAt) {
+          keyValue("Created", new Date(brand2.createdAt).toLocaleString());
+        }
+        console.log();
+        if (brand2.primaryColor || brand2.colors.length > 0) {
+          console.log(chalk7.bold("  Colors"));
+          if (brand2.primaryColor) {
+            const swatch = chalk7.bgHex(brand2.primaryColor)("  ");
+            console.log(`    Primary: ${swatch} ${brand2.primaryColor}`);
+          }
+          if (brand2.colors.length > 0) {
+            console.log("    Palette:");
+            for (const c of brand2.colors.slice(0, 10)) {
+              const swatch = chalk7.bgHex(c.hex)("  ");
+              const role = c.role ? chalk7.gray(` (${c.role})`) : "";
+              console.log(`      ${swatch} ${c.hex}${role}`);
+            }
+          }
+          console.log();
+        }
+        if (brand2.logoUrl) {
+          console.log(chalk7.bold("  Logo"));
+          console.log(`    ${brand2.logoUrl}`);
+          console.log();
+        }
+        const typo = brand2.typography;
+        if (typo && Object.keys(typo).length > 0) {
+          console.log(chalk7.bold("  Typography"));
+          if (typo.primary || typo.headings) {
+            console.log(`    Headings: ${typo.primary || typo.headings || "-"}`);
+          }
+          if (typo.secondary || typo.body) {
+            console.log(`    Body: ${typo.secondary || typo.body || "-"}`);
+          }
+          console.log();
+        }
+        if (brand2.confidence || brand2.extractionMethod) {
+          console.log(chalk7.bold("  Extraction"));
+          if (brand2.confidence) {
+            console.log(`    Confidence: ${Math.round(brand2.confidence * 100)}%`);
+          }
+          if (brand2.extractionMethod) {
+            console.log(`    Method: ${brand2.extractionMethod}`);
+          }
+          console.log();
+        }
+        console.log(chalk7.gray("  Use --format json for full details"));
+        console.log();
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(err.exitCode ?? 1);
+    }
+  })
+).addCommand(
+  new Command8("extract").description("Extract brand profile from a website").argument("<url>", "Website URL to extract branding from").option("--team-id <id>", "Team ID").option("--no-save", "Extract without saving").action(async (url, options) => {
+    requireAuth();
+    try {
+      new URL(url.startsWith("http") ? url : `https://${url}`);
+    } catch {
+      error("Invalid URL format");
+      process.exit(6);
+    }
+    const fullUrl = url.startsWith("http") ? url : `https://${url}`;
+    const teamId = options.teamId ?? getDefaultTeamId();
+    const spinner = ora5({ text: `Extracting branding from ${fullUrl}...`, stream: process.stdout }).start();
+    try {
+      const result = await extractBranding(fullUrl, teamId);
+      const brand2 = await getBranding(result.id);
+      spinner.succeed("Branding extracted!");
+      console.log();
+      header("Brand Profile");
+      console.log();
+      keyValue("ID", brand2.id);
+      keyValue("Name", brand2.name);
+      keyValue("Source URL", brand2.sourceUrl ?? fullUrl);
+      console.log();
+      if (brand2.primaryColor || brand2.colors.length > 0) {
+        console.log(chalk7.bold("  Colors"));
+        if (brand2.primaryColor) {
+          const swatch = chalk7.bgHex(brand2.primaryColor)("  ");
+          console.log(`    Primary: ${swatch} ${brand2.primaryColor}`);
+        }
+        if (brand2.colors.length > 0) {
+          console.log("    Palette:");
+          for (const c of brand2.colors.slice(0, 6)) {
+            const swatch = chalk7.bgHex(c.hex)("  ");
+            const role = c.role ? chalk7.gray(` (${c.role})`) : "";
+            console.log(`      ${swatch} ${c.hex}${role}`);
+          }
+        }
+        console.log();
+      }
+      if (brand2.logoUrl) {
+        console.log(chalk7.bold("  Logo"));
+        console.log(`    ${brand2.logoUrl}`);
+        console.log();
+      }
+      if (brand2.confidence) {
+        console.log(chalk7.bold("  Extraction"));
+        console.log(`    Confidence: ${Math.round(brand2.confidence * 100)}%`);
+        console.log();
+      }
+      info(`Create a presentation with this brand: conceptcraft create "Your Topic" -b ${result.id}`);
+      console.log();
+    } catch (err) {
+      spinner.fail("Extraction failed");
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(err.exitCode ?? 1);
+    }
+  })
+).addCommand(
+  new Command8("set-default").description("Set a brand profile as default").argument("<id>", "Brand profile ID").action(async (id) => {
+    requireAuth();
+    info(
+      `To set brand ${id} as default, use the web dashboard.`
+    );
+    console.log();
+    console.log(
+      chalk7.gray(
+        "API support for setting default brand is coming soon."
+      )
+    );
+  })
+);
+
+// src/commands/derive.ts
+import { Command as Command9 } from "commander";
+import chalk8 from "chalk";
+import ora6 from "ora";
+function createBlogCommand() {
+  return new Command9("blog").description("Generate a blog post from a presentation").argument("<slug>", "Presentation slug").option("--words <count>", "Target word count (50-2000)", "300").option(
+    "--tone <tone>",
+    "Writing tone (professional, casual, educational)",
+    "professional"
+  ).option("--audience <text>", "Target audience description").option(
+    "-f, --format <format>",
+    "Output format (human, json, markdown)",
+    "human"
+  ).option("--instructions <text>", "Custom instructions for the blog").option("--no-images", "Exclude image references").option("--toc", "Include table of contents").action(async (presentationId, options) => {
+    requireAuth();
+    const wordCount = parseInt(options.words, 10);
+    if (isNaN(wordCount) || wordCount < 50 || wordCount > 2e3) {
+      error("Word count must be between 50 and 2000");
+      process.exit(6);
+    }
+    const validTones = ["professional", "casual", "educational"];
+    if (!validTones.includes(options.tone)) {
+      error(`Invalid tone. Valid options: ${validTones.join(", ")}`);
+      process.exit(6);
+    }
+    const spinner = ora6("Fetching presentation...").start();
+    try {
+      const presentation = await getPresentation(presentationId);
+      spinner.text = "Generating blog post...";
+      const response = await generateBlog(
+        presentation.id,
+        presentation.documentCreatedAt || presentation.createdAt,
+        {
+          targetWordCount: wordCount,
+          tone: options.tone,
+          targetAudience: options.audience ?? "General Audience",
+          customInstructions: options.instructions ?? "",
+          includeImages: !options.noImages,
+          includeTableOfContents: options.toc ?? false
+        }
+      );
+      const content = await streamTextContent(response, { quiet: true });
+      spinner.succeed("Blog generated");
+      if (options.format === "json") {
+        console.log(
+          JSON.stringify(
+            {
+              presentationId,
+              title: presentation.title,
+              wordCount,
+              tone: options.tone,
+              content
+            },
+            null,
+            2
+          )
+        );
+      } else if (options.format === "markdown") {
+        console.log(content);
+      } else {
+        console.log();
+        console.log(chalk8.bold(`Blog: ${presentation.title}`));
+        console.log(chalk8.gray("\u2500".repeat(40)));
+        console.log();
+        console.log(content);
+        console.log();
+      }
+    } catch (err) {
+      spinner.fail("Generation failed");
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(err.exitCode ?? 1);
+    }
+  });
+}
+function createTweetsCommand() {
+  return new Command9("tweets").description("Generate tweets from a presentation").argument("<slug>", "Presentation slug").option("--count <n>", "Number of tweets to generate", "5").option("-f, --format <format>", "Output format (human, json)", "human").action(async (presentationId, options) => {
+    requireAuth();
+    info("Tweet generation coming soon.");
+  });
+}
+function createLinkedInCommand() {
+  return new Command9("linkedin").description("Generate a LinkedIn carousel from a presentation").argument("<slug>", "Presentation slug").option("-f, --format <format>", "Output format (human, json)", "human").action(async (presentationId) => {
+    requireAuth();
+    info("LinkedIn carousel generation coming soon.");
+  });
+}
+function createQuestionsCommand() {
+  return new Command9("questions").description("Generate questions for a presentation").argument("<slug>", "Presentation slug").option("--count <n>", "Number of questions", "10").option("-f, --format <format>", "Output format (human, json)", "human").action(async (presentationId, options) => {
+    requireAuth();
+    info("Question generation coming soon.");
+  });
+}
+function createCheatsheetCommand() {
+  return new Command9("cheatsheet").description("Generate a presenter cheat sheet").argument("<slug>", "Presentation slug").option("--mode <mode>", "Cheat sheet mode (qa-prep, talking-points)", "qa-prep").option(
+    "-f, --format <format>",
+    "Output format (human, json, markdown)",
+    "human"
+  ).action(async (presentationId, options) => {
+    requireAuth();
+    info("Cheat sheet generation coming soon.");
+  });
+}
+function buildDeriveCommand() {
+  const derive = new Command9("derive").description("Generate derivative content from a presentation");
+  const flags = getCachedFlags();
+  if (!flags) {
+    return derive;
+  }
+  if (flags.deckToBlog) {
+    derive.addCommand(createBlogCommand());
+  }
+  if (flags.deckToTweets) {
+    derive.addCommand(createTweetsCommand());
+  }
+  if (flags.linkedInCarousel) {
+    derive.addCommand(createLinkedInCommand());
+  }
+  if (flags.redTeamQuestions) {
+    derive.addCommand(createQuestionsCommand());
+  }
+  if (flags.presenterCheatSheet) {
+    derive.addCommand(createCheatsheetCommand());
+  }
+  return derive;
+}
+
+// src/commands/ideas.ts
+import { Command as Command10 } from "commander";
+import chalk9 from "chalk";
+var ideasCommand = new Command10("ideas").description("Generate presentation topic ideas").option("--context <text>", "Custom context for idea generation").option("--count <n>", "Number of ideas to generate", "5").option("-f, --format <format>", "Output format (human, json)", "human").action(async (options) => {
+  requireAuth();
+  info("Idea generation is available in the web dashboard.");
+  console.log();
+  console.log(
+    chalk9.gray("The CLI will support idea generation in a future release.")
+  );
+  console.log();
+  console.log("For now, try these approaches:");
+  console.log(
+    chalk9.gray(
+      "  1. Visit the ConceptCraft dashboard and use the idea generator"
+    )
+  );
+  console.log(
+    chalk9.gray("  2. Create a presentation with a broad topic and refine it")
+  );
+  console.log();
+});
+
+// src/commands/whoami.ts
+import { Command as Command11 } from "commander";
+import chalk10 from "chalk";
+var whoamiCommand = new Command11("whoami").description("Show current user and team information").option("-f, --format <format>", "Output format (human, json)", "human").action(async (options) => {
+  requireAuth();
+  try {
+    const result = await whoami();
+    refreshInBackground();
+    if (options.format === "json") {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    header("User");
+    console.log();
+    keyValue("Email", result.user.email);
+    if (result.user.username) {
+      keyValue("Username", result.user.username);
+    }
+    if (result.user.firstName || result.user.lastName) {
+      keyValue(
+        "Name",
+        [result.user.firstName, result.user.lastName].filter(Boolean).join(" ")
+      );
+    }
+    keyValue("Auth Type", result.authType === "apiKey" ? "API Key" : "Session");
+    if (result.currentTeam) {
+      console.log();
+      header("Current Team");
+      console.log();
+      keyValue("ID", result.currentTeam.id);
+      keyValue("Name", result.currentTeam.name);
+      keyValue("Plan", result.currentTeam.planName);
+      keyValue("Role", result.currentTeam.isOwner ? "Owner" : "Member");
+    }
+    if (result.teams.length > 1) {
+      console.log();
+      header("All Teams");
+      console.log();
+      for (const team of result.teams) {
+        const current = team.isCurrent ? chalk10.green(" (current)") : "";
+        console.log(
+          `  ${chalk10.bold(team.name)}${current}`
+        );
+        console.log(
+          chalk10.gray(`    ID: ${team.id} | Plan: ${team.planName} | Role: ${team.role}`)
+        );
+      }
+    }
+    console.log();
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(err.exitCode ?? 1);
+  }
+});
+
+// src/commands/skill.ts
+import { Command as Command12 } from "commander";
+import chalk11 from "chalk";
+import { mkdirSync, writeFileSync, existsSync as existsSync2 } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var SKILL_CONTENT = `---
+name: conceptcraft
+description: Create AI-powered presentations from code, documentation, files, or any content. Use when the user wants to generate slides, presentations, or decks about their project, codebase, research, or ideas.
+---
+
+# ConceptCraft CLI
+
+Create professional presentations directly from your terminal. The CLI generates AI-powered slides from any context you provide - text, files, URLs, or piped content.
+
+## Prerequisites
+
+\`\`\`bash
+# Install globally
+npm install -g @conceptcraft/cli
+
+# Configure API key (get from https://conceptcraft.ai/settings/api-keys)
+conceptcraft config init
+\`\`\`
+
+## Core Workflow
+
+1. **Gather context** - Read relevant files, code, or documentation
+2. **Create presentation** - Pass context to \`conceptcraft create\`
+3. **Share URL** - Return the presentation link to the user
+
+## Commands
+
+### Create Presentation
+
+Context is **required**. Provide it via one of these methods:
+
+\`\`\`bash
+# Upload files (PDFs, PPTX, images, docs)
+conceptcraft create "Product Overview" --file ./deck.pptx --file ./logo.png
+
+# Direct text context
+conceptcraft create "Topic Title" --context "Key points, data, facts..."
+
+# From a text file
+conceptcraft create "Topic Title" --context-file ./notes.md
+
+# Pipe content (auto-detected)
+cat README.md | conceptcraft create "Project Overview"
+
+# From URLs (scraped automatically)
+conceptcraft create "Competitor Analysis" --sources https://example.com/report
+
+# Combine multiple sources
+cat src/auth/*.ts | conceptcraft create "Auth System" \\
+  --file ./architecture.png \\
+  --context "Focus on security patterns"
+\`\`\`
+
+### Create Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| \`-n, --slides <count>\` | Number of slides (1-20) | 10 |
+| \`-m, --mode <mode>\` | Quality: \`instant\`, \`fast\`, \`balanced\`, \`best\` | balanced |
+| \`-t, --tone <tone>\` | Tone: \`professional\`, \`educational\`, \`creative\`, \`formal\`, \`casual\` | professional |
+| \`--amount <amount>\` | Density: \`minimal\`, \`concise\`, \`detailed\`, \`extensive\` | concise |
+| \`--audience <text>\` | Target audience | General Audience |
+| \`-g, --goal <type>\` | Purpose: \`inform\`, \`persuade\`, \`train\`, \`learn\`, \`entertain\`, \`report\` | - |
+| \`--custom-goal <text>\` | Custom goal description | - |
+| \`-f, --file <paths...>\` | Files to upload (PDF, PPTX, images, docs) | - |
+| \`-l, --language <lang>\` | Output language | en |
+| \`-b, --brand <id>\` | Branding ID to apply | - |
+| \`-o, --output <format>\` | Output: \`human\`, \`json\`, \`quiet\` | human |
+
+### Other Commands
+
+\`\`\`bash
+# Check authentication
+conceptcraft whoami
+
+# List presentations
+conceptcraft list
+conceptcraft list --format json
+
+# Get presentation details
+conceptcraft get <id-or-slug>
+
+# Export to ZIP
+conceptcraft export <id-or-slug> -o presentation.zip
+
+# Import presentation
+conceptcraft import ./presentation.zip
+
+# Manage branding
+conceptcraft branding list
+conceptcraft branding extract https://company.com
+
+# Install/manage this skill
+conceptcraft skill install
+conceptcraft skill show
+\`\`\`
+
+## Examples
+
+### Present a Codebase Feature
+
+\`\`\`bash
+# Read the relevant files and create presentation
+cat src/lib/auth.ts src/lib/session.ts | conceptcraft create "Authentication System" \\
+  --slides 8 --tone educational --audience "New developers" \\
+  --goal train
+\`\`\`
+
+### Technical Documentation with Diagrams
+
+\`\`\`bash
+conceptcraft create "API Reference" \\
+  --file ./docs/api.md \\
+  --file ./diagrams/architecture.png \\
+  --mode best --amount detailed \\
+  --goal inform
+\`\`\`
+
+### Quick Project Overview
+
+\`\`\`bash
+cat README.md package.json | conceptcraft create "Project Introduction" \\
+  -m instant --slides 5
+\`\`\`
+
+### Sales Deck from Existing Presentation
+
+\`\`\`bash
+conceptcraft create "Product Demo" \\
+  --file ./existing-deck.pptx \\
+  --goal persuade \\
+  --audience "Enterprise buyers" \\
+  --tone professional
+\`\`\`
+
+### Research Presentation
+
+\`\`\`bash
+conceptcraft create "Market Analysis" \\
+  --file ./research.pdf \\
+  --sources https://report.com/industry.pdf \\
+  --tone formal --audience "Executive team" \\
+  --goal report
+\`\`\`
+
+## Output
+
+Successful creation returns:
+\`\`\`
+\u2713 Presentation created successfully
+
+  Title: Authentication System
+  Slides: 8
+  Generated in: 45s \xB7 12,500 tokens
+
+  Open: https://conceptcraft.ai/en/view/presentations/auth-system-v1-abc123
+\`\`\`
+
+For scripting, use JSON output:
+\`\`\`bash
+URL=$(conceptcraft create "Demo" --context "..." -o json | jq -r '.viewUrl')
+\`\`\`
+
+## Best Practices
+
+1. **Provide rich context** - More context = better slides. Include code, docs, data.
+2. **Use file uploads for binary content** - PDFs, images, PPTX files need \`--file\`.
+3. **Specify a goal** - Helps tailor the presentation structure and messaging.
+4. **Use appropriate mode** - \`instant\` for quick drafts, \`best\` for important presentations.
+5. **Specify audience** - Helps tailor complexity and terminology.
+6. **Combine sources** - Pipe multiple files for comprehensive presentations.
+
+## Supported File Types
+
+- **Documents**: PDF, DOCX, XLSX, PPTX
+- **Images**: JPEG, PNG, GIF, WebP
+- **Text**: Markdown, TXT, CSV, JSON
+
+## Troubleshooting
+
+\`\`\`bash
+# Check if authenticated
+conceptcraft whoami
+
+# Verify API key
+conceptcraft config show
+
+# Debug mode
+conceptcraft create "Test" --context "test" --debug
+\`\`\`
+`;
+var EDITORS = [
+  { name: "Claude Code", dir: ".claude" },
+  { name: "Cursor", dir: ".cursor" },
+  { name: "Codex", dir: ".codex" },
+  { name: "OpenCode", dir: ".opencode" },
+  { name: "Windsurf", dir: ".windsurf" },
+  { name: "Agent", dir: ".agent" }
+];
+var skillCommand = new Command12("skill").description("Manage ConceptCraft skill for AI coding assistants").addHelpText(
+  "after",
+  `
+${chalk11.bold("Examples:")}
+  ${chalk11.gray("# Install skill for all detected editors")}
+  $ conceptcraft skill install
+
+  ${chalk11.gray("# Install to specific directory")}
+  $ conceptcraft skill install --dir ~/.claude
+
+  ${chalk11.gray("# Show skill content")}
+  $ conceptcraft skill show
+`
+);
+skillCommand.command("install").description("Install the ConceptCraft skill for AI coding assistants").option("-d, --dir <path>", "Install to specific directory").option("-g, --global", "Install globally (to home directory)", true).option("-l, --local", "Install locally (to current directory)").option("-f, --force", "Overwrite existing skill files").action(async (options) => {
+  const installed = [];
+  const skipped = [];
+  const errors = [];
+  const baseDir = options.local ? process.cwd() : homedir();
+  if (options.dir) {
+    const skillPath = join(options.dir, "skills", "conceptcraft");
+    try {
+      installSkill(skillPath, options.force);
+      installed.push(options.dir);
+    } catch (err) {
+      errors.push(`${options.dir}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  } else {
+    for (const editor of EDITORS) {
+      const editorDir = join(baseDir, editor.dir);
+      const skillPath = join(editorDir, "skills", "conceptcraft");
+      const skillFile = join(skillPath, "SKILL.md");
+      if (!existsSync2(editorDir)) {
+        continue;
+      }
+      if (existsSync2(skillFile) && !options.force) {
+        skipped.push(editor.name);
+        continue;
+      }
+      try {
+        installSkill(skillPath, options.force);
+        installed.push(editor.name);
+      } catch (err) {
+        errors.push(`${editor.name}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  console.log();
+  if (installed.length > 0) {
+    success("Skill installed successfully");
+    console.log();
+    keyValue("Installed to", installed.join(", "));
+  }
+  if (skipped.length > 0) {
+    console.log();
+    info(`Skipped (already exists): ${skipped.join(", ")}`);
+    console.log(chalk11.gray("  Use --force to overwrite"));
+  }
+  if (errors.length > 0) {
+    console.log();
+    for (const err of errors) {
+      error(err);
+    }
+  }
+  if (installed.length === 0 && skipped.length === 0 && errors.length === 0) {
+    info("No supported AI coding assistants detected.");
+    console.log();
+    console.log(chalk11.gray("Supported editors: " + EDITORS.map((e) => e.name).join(", ")));
+    console.log(chalk11.gray("Use --dir <path> to install to a specific directory"));
+  }
+  console.log();
+});
+skillCommand.command("show").description("Display the skill content").action(() => {
+  console.log(SKILL_CONTENT);
+});
+skillCommand.command("uninstall").description("Remove the ConceptCraft skill from AI coding assistants").option("-g, --global", "Uninstall globally (from home directory)", true).option("-l, --local", "Uninstall locally (from current directory)").action(async (options) => {
+  const { rmSync } = await import("fs");
+  const removed = [];
+  const baseDir = options.local ? process.cwd() : homedir();
+  for (const editor of EDITORS) {
+    const skillPath = join(baseDir, editor.dir, "skills", "conceptcraft");
+    if (existsSync2(skillPath)) {
+      try {
+        rmSync(skillPath, { recursive: true });
+        removed.push(editor.name);
+      } catch {
+      }
+    }
+  }
+  console.log();
+  if (removed.length > 0) {
+    success("Skill uninstalled");
+    keyValue("Removed from", removed.join(", "));
+  } else {
+    info("No installed skills found");
+  }
+  console.log();
+});
+function installSkill(skillPath, force) {
+  const skillFile = join(skillPath, "SKILL.md");
+  mkdirSync(skillPath, { recursive: true });
+  writeFileSync(skillFile, SKILL_CONTENT, "utf-8");
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+var program = new Command13();
+var cmdName = brand.commands[0];
+program.name(cmdName).description(brand.description).version(VERSION, "-v, --version", "Show version number").option("--debug", "Enable debug logging").option("--no-color", "Disable colored output").configureOutput({
+  outputError: (str, write) => {
+    write(chalk12.red(str));
+  }
+});
+program.addCommand(configCommand);
+program.addCommand(createCommand);
+program.addCommand(listCommand);
+program.addCommand(getCommand);
+program.addCommand(deleteCommand);
+program.addCommand(exportCommand);
+program.addCommand(importCommand);
+program.addCommand(brandingCommand);
+program.addCommand(ideasCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(skillCommand);
+var deriveCommand = buildDeriveCommand();
+if (deriveCommand.commands.length > 0) {
+  program.addCommand(deriveCommand);
+}
+program.on("command:*", (operands) => {
+  console.error(chalk12.red(`Error: Unknown command '${operands[0]}'`));
+  console.error();
+  console.error(`Run '${cmdName} --help' to see available commands.`);
+  process.exit(1);
+});
+program.addHelpText(
+  "after",
+  `
+${chalk12.bold("Examples:")}
+  ${chalk12.gray("# Configure CLI")}
+  $ ${cmdName} config init
+
+  ${chalk12.gray("# Create a presentation (recommended pattern)")}
+  $ ${cmdName} create "Q4 Business Review" \\
+      -n 12 -m best \\
+      --audience "Executive leadership team" \\
+      --context "Revenue: $50M (+25% YoY), New customers: 150"
+
+  ${chalk12.gray("# Create from a file")}
+  $ ${cmdName} create "Product Launch" \\
+      -n 10 -m balanced \\
+      --audience "Sales team and partners" \\
+      --context-file ./launch-brief.md
+
+  ${chalk12.gray("# Create from URLs")}
+  $ ${cmdName} create "Market Analysis" \\
+      -n 15 -m best \\
+      --audience "Strategy team" \\
+      --sources https://example.com/report.pdf
+
+  ${chalk12.gray("# List and export")}
+  $ ${cmdName} list --format table
+  $ ${cmdName} export <slug> -o backup.zip
+
+${chalk12.bold("Environment Variables:")}
+  CC_SLIDES_API_KEY    API key for authentication
+  CC_SLIDES_API_URL    Custom API URL (optional)
+
+${chalk12.bold("More Info:")}
+  ${chalk12.blue(brand.docsUrl)}
+`
+);
+program.parse();
+//# sourceMappingURL=index.js.map