@flydocs/cli 0.5.0-beta.0

package/dist/cli.js

@@ -0,0 +1,2666 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/constants.ts
+import pc from "picocolors";
+var CLI_VERSION, CLI_NAME, PACKAGE_NAME;
+var init_constants = __esm({
+  "src/lib/constants.ts"() {
+    "use strict";
+    CLI_VERSION = "0.5.0-beta.0";
+    CLI_NAME = "flydocs";
+    PACKAGE_NAME = "@flydocs/cli";
+  }
+});
+
+// src/lib/fs-ops.ts
+import {
+  access,
+  cp,
+  mkdir,
+  rm,
+  copyFile as fsCopyFile
+} from "fs/promises";
+import { join } from "path";
+async function pathExists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDirectories(targetDir, tier) {
+  const dirs = [
+    ".flydocs",
+    ".claude/skills",
+    ".claude/agents",
+    ".claude/commands",
+    ".cursor/agents",
+    ".cursor/commands",
+    ".cursor/rules",
+    "flydocs/context",
+    "flydocs/knowledge/decisions",
+    "flydocs/knowledge/notes",
+    "flydocs/knowledge/product",
+    "flydocs/design-system"
+  ];
+  if (tier === "local") {
+    dirs.push("flydocs/issues");
+  }
+  for (const dir of dirs) {
+    await mkdir(join(targetDir, dir), { recursive: true });
+  }
+}
+async function replaceDirectory(src, dest) {
+  if (await pathExists(dest)) {
+    await rm(dest, { recursive: true, force: true });
+  }
+  await cp(src, dest, { recursive: true });
+}
+async function copyFile(src, dest) {
+  await fsCopyFile(src, dest);
+}
+async function copyFileIfNotExists(src, dest) {
+  if (await pathExists(dest)) {
+    return "preserved";
+  }
+  await fsCopyFile(src, dest);
+  return "created";
+}
+async function copyDirectoryContents(src, dest) {
+  if (await pathExists(dest)) {
+    await rm(dest, { recursive: true, force: true });
+  }
+  await mkdir(dest, { recursive: true });
+  await cp(src, dest, { recursive: true });
+}
+var init_fs_ops = __esm({
+  "src/lib/fs-ops.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/template.ts
+import { readFile } from "fs/promises";
+import { dirname, join as join2, resolve } from "path";
+import { fileURLToPath } from "url";
+async function resolveTemplatePath(localSource) {
+  if (localSource) {
+    const localPath = resolve(process.cwd(), "template");
+    if (await pathExists(localPath)) {
+      return localPath;
+    }
+    const parentPath = resolve(process.cwd(), "..", "template");
+    if (await pathExists(parentPath)) {
+      return parentPath;
+    }
+    const thisFile2 = fileURLToPath(import.meta.url);
+    const packageRoot2 = dirname(dirname(thisFile2));
+    const bundledPath = join2(packageRoot2, "template");
+    if (await pathExists(bundledPath)) {
+      return bundledPath;
+    }
+    throw new Error(`Local template directory not found at ${localPath}`);
+  }
+  const thisFile = fileURLToPath(import.meta.url);
+  const distDir = dirname(thisFile);
+  const packageRoot = dirname(distDir);
+  const templatePath = join2(packageRoot, "template");
+  if (await pathExists(templatePath)) {
+    return templatePath;
+  }
+  throw new Error(
+    `Template directory not found at ${templatePath}. Is the package installed correctly?`
+  );
+}
+async function readTemplateVersion(templateDir) {
+  const versionFile = join2(templateDir, ".flydocs", "version");
+  const content = await readFile(versionFile, "utf-8");
+  return content.trim();
+}
+var init_template = __esm({
+  "src/lib/template.ts"() {
+    "use strict";
+    init_fs_ops();
+  }
+});
+
+// src/lib/ui.ts
+import pc2 from "picocolors";
+function printStatus(message) {
+  console.log(`${pc2.green("\u2714")} ${message}`);
+}
+function printWarning(message) {
+  console.log(`${pc2.yellow("\u26A0")} ${message}`);
+}
+function printError(message) {
+  console.error(`${pc2.red("\u2716")} ${message}`);
+}
+function printInfo(message) {
+  console.log(`${pc2.cyan("\u2139")} ${message}`);
+}
+function printStub(command) {
+  printWarning(`${pc2.bold(command)} is not yet implemented in the Node CLI.`);
+  console.log(`  Use ${pc2.cyan("bash install.sh")} for now.`);
+}
+function printBanner(version) {
+  const pink = pc2.magenta;
+  const purple = (t) => pc2.cyan(t);
+  const dim = pc2.dim;
+  const bold = pc2.bold;
+  console.log();
+  console.log(`  ${bold(pink("\u2588\u2588\u2588\u2588\u2588\u2588"))}`);
+  console.log(
+    `  ${bold(pink("\u2588\u2588"))}      ${bold(purple("\u2588\u2588\u2588\u2588\u2588\u2588"))}  ${bold(pink("Fly"))}${bold(purple("Docs"))} ${bold(pink("Core"))}`
+  );
+  console.log(
+    `        ${bold(purple("\u2588\u2588\u2588\u2588\u2588\u2588"))}  ${dim("Context-as-a-Service Platform Built for Engineering at Altitude")}`
+  );
+  console.log(`        ${bold(purple("\u2588\u2588"))}`);
+  console.log(`        ${bold(purple("\u2588\u2588"))}      ${dim(`v${version}`)}`);
+  console.log();
+}
+function printCompletionBox(title, lines) {
+  const width = 59;
+  const topBot = "\u2550".repeat(width);
+  console.log();
+  console.log(`\u2554${topBot}\u2557`);
+  const padding = Math.max(0, Math.floor((width - title.length) / 2));
+  console.log(
+    `\u2551${" ".repeat(padding)}${title}${" ".repeat(width - padding - title.length)}\u2551`
+  );
+  console.log(`\u255A${topBot}\u255D`);
+  console.log();
+  for (const line of lines) {
+    console.log(`  ${line}`);
+  }
+  console.log();
+}
+function printBetaCta() {
+  const dim = pc2.dim;
+  console.log(
+    dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")
+  );
+  console.log();
+  console.log(`  ${pc2.bold("Join the FlyDocs Closed Beta")}`);
+  console.log(
+    `  ${dim("Early access to cloud features, priority support, and more.")}`
+  );
+  console.log(
+    `  ${pc2.cyan("https://www.flydocs.ai?utm_source=cli&utm_medium=install&utm_campaign=beta")}`
+  );
+  console.log();
+}
+var init_ui = __esm({
+  "src/lib/ui.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/lib/config.ts
+import { readFile as readFile2, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+async function readConfig(dir) {
+  const content = await readFile2(join3(dir, ".flydocs", "config.json"), "utf-8");
+  return JSON.parse(content);
+}
+async function writeConfig(dir, config) {
+  const content = JSON.stringify(config, null, 2) + "\n";
+  await writeFile(join3(dir, ".flydocs", "config.json"), content, "utf-8");
+}
+async function createFreshConfig(templateDir, version, tier) {
+  const content = await readFile2(
+    join3(templateDir, ".flydocs", "config.json"),
+    "utf-8"
+  );
+  const config = JSON.parse(content);
+  config.version = version;
+  config.tier = tier;
+  return config;
+}
+function extractPreservedValues(config) {
+  return {
+    tier: config.tier,
+    setupComplete: config.setupComplete ?? false,
+    providerTeamId: config.provider?.teamId ?? null,
+    workspace: config.workspace ?? {},
+    issueLabels: config.issueLabels ?? {},
+    statusMapping: config.statusMapping ?? {},
+    detectedStack: config.detectedStack ?? {},
+    mcp: config.mcp ?? {},
+    skills: config.skills ?? {},
+    designSystem: config.designSystem ?? null,
+    aiLabor: config.aiLabor ?? {}
+  };
+}
+async function mergeConfig(templateDir, version, tierFlag, preserved) {
+  const content = await readFile2(
+    join3(templateDir, ".flydocs", "config.json"),
+    "utf-8"
+  );
+  const config = JSON.parse(content);
+  config.version = version;
+  config.tier = tierFlag ?? preserved.tier;
+  config.setupComplete = preserved.setupComplete;
+  if (preserved.providerTeamId !== null) {
+    if (!config.provider) {
+      config.provider = { type: "linear", teamId: null };
+    }
+    config.provider.teamId = preserved.providerTeamId;
+  }
+  if (Object.keys(preserved.workspace).length > 0) {
+    config.workspace = preserved.workspace;
+  }
+  if (Object.keys(preserved.issueLabels).length > 0) {
+    config.issueLabels = preserved.issueLabels;
+  }
+  if (Object.keys(preserved.statusMapping).length > 0) {
+    config.statusMapping = preserved.statusMapping;
+  }
+  if (Object.keys(preserved.detectedStack).length > 0) {
+    config.detectedStack = preserved.detectedStack;
+  }
+  if (Object.keys(preserved.mcp).length > 0) {
+    config.mcp = preserved.mcp;
+  }
+  if (Object.keys(preserved.skills).length > 0) {
+    config.skills = preserved.skills;
+  }
+  if (preserved.designSystem !== null) {
+    config.designSystem = preserved.designSystem;
+  }
+  if (Object.keys(preserved.aiLabor).length > 0) {
+    config.aiLabor = preserved.aiLabor;
+  }
+  return config;
+}
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/skills.ts
+import { join as join4 } from "path";
+async function installOwnedSkills(templateDir, targetDir, tier) {
+  const skillsDir = join4(targetDir, ".claude", "skills");
+  const templateSkillsDir = join4(templateDir, ".claude", "skills");
+  await replaceDirectory(
+    join4(templateSkillsDir, "flydocs-workflow"),
+    join4(skillsDir, "flydocs-workflow")
+  );
+  const activeMech = MECHANISM_SKILLS[tier];
+  const inactiveMech = tier === "local" ? MECHANISM_SKILLS.cloud : MECHANISM_SKILLS.local;
+  await replaceDirectory(
+    join4(templateSkillsDir, activeMech),
+    join4(skillsDir, activeMech)
+  );
+  const { rm: rm5 } = await import("fs/promises");
+  const inactivePath = join4(skillsDir, inactiveMech);
+  if (await pathExists(inactivePath)) {
+    await rm5(inactivePath, { recursive: true, force: true });
+  }
+  for (const skill of OWNED_SKILLS) {
+    if (skill === "flydocs-workflow") continue;
+    const src = join4(templateSkillsDir, skill);
+    if (await pathExists(src)) {
+      await replaceDirectory(src, join4(skillsDir, skill));
+    }
+  }
+  for (const skill of SUPPORTING_SKILLS) {
+    const src = join4(templateSkillsDir, skill);
+    if (await pathExists(src)) {
+      await replaceDirectory(src, join4(skillsDir, skill));
+    }
+  }
+  const readmeSrc = join4(templateSkillsDir, "README.md");
+  if (await pathExists(readmeSrc)) {
+    await copyFile(readmeSrc, join4(skillsDir, "README.md"));
+  }
+}
+async function replaceOwnedSkills(templateDir, targetDir, tier) {
+  const skillsDir = join4(targetDir, ".claude", "skills");
+  const templateSkillsDir = join4(templateDir, ".claude", "skills");
+  for (const skill of [...OWNED_SKILLS, ...SUPPORTING_SKILLS]) {
+    const src = join4(templateSkillsDir, skill);
+    if (await pathExists(src)) {
+      await replaceDirectory(src, join4(skillsDir, skill));
+    }
+  }
+  const { rm: rm5 } = await import("fs/promises");
+  const activeMech = MECHANISM_SKILLS[tier];
+  const inactiveMech = tier === "local" ? MECHANISM_SKILLS.cloud : MECHANISM_SKILLS.local;
+  const inactivePath = join4(skillsDir, inactiveMech);
+  if (await pathExists(inactivePath)) {
+    await rm5(inactivePath, { recursive: true, force: true });
+  }
+  await replaceDirectory(
+    join4(templateSkillsDir, activeMech),
+    join4(skillsDir, activeMech)
+  );
+  const readmeSrc = join4(templateSkillsDir, "README.md");
+  if (await pathExists(readmeSrc)) {
+    await copyFile(readmeSrc, join4(skillsDir, "README.md"));
+  }
+}
+async function copyCursorRules(targetDir) {
+  const { mkdir: mkdir6 } = await import("fs/promises");
+  const rulesDir = join4(targetDir, ".cursor", "rules");
+  await mkdir6(rulesDir, { recursive: true });
+  const workflowRule = join4(
+    targetDir,
+    ".claude",
+    "skills",
+    "flydocs-workflow",
+    "cursor-rule.mdc"
+  );
+  if (await pathExists(workflowRule)) {
+    await copyFile(workflowRule, join4(rulesDir, "flydocs-workflow.mdc"));
+  }
+  for (const mech of ["flydocs-local", "flydocs-cloud"]) {
+    const mechRule = join4(
+      targetDir,
+      ".claude",
+      "skills",
+      mech,
+      "cursor-rule.mdc"
+    );
+    if (await pathExists(mechRule)) {
+      await copyFile(mechRule, join4(rulesDir, "flydocs-mechanism.mdc"));
+    }
+  }
+  for (const skill of PREMIUM_CURSOR_RULES) {
+    const skillRule = join4(
+      targetDir,
+      ".claude",
+      "skills",
+      skill,
+      "cursor-rule.mdc"
+    );
+    if (await pathExists(skillRule)) {
+      await copyFile(skillRule, join4(rulesDir, `${skill}.mdc`));
+    }
+  }
+}
+var OWNED_SKILLS, SUPPORTING_SKILLS, MECHANISM_SKILLS, PREMIUM_CURSOR_RULES;
+var init_skills = __esm({
+  "src/lib/skills.ts"() {
+    "use strict";
+    init_fs_ops();
+    OWNED_SKILLS = [
+      "flydocs-workflow",
+      "flydocs-figma",
+      "flydocs-estimates",
+      "flydocs-context-graph"
+    ];
+    SUPPORTING_SKILLS = [
+      "implementation-flow",
+      "review-workflow",
+      "spec-templates"
+    ];
+    MECHANISM_SKILLS = {
+      local: "flydocs-local",
+      cloud: "flydocs-cloud"
+    };
+    PREMIUM_CURSOR_RULES = ["flydocs-figma", "flydocs-estimates"];
+  }
+});
+
+// src/lib/stack.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join5 } from "path";
+async function detectStack(targetDir) {
+  const detected = /* @__PURE__ */ new Set();
+  const pkgPath = join5(targetDir, "package.json");
+  let pkg;
+  try {
+    const content = await readFile3(pkgPath, "utf-8");
+    pkg = JSON.parse(content);
+  } catch {
+  }
+  if (pkg) {
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if ("next" in allDeps) detected.add("nextjs");
+    if ("expo" in allDeps) detected.add("expo");
+    if ("react" in allDeps) detected.add("react");
+    if ("convex" in allDeps) detected.add("convex");
+    if ("prisma" in allDeps) detected.add("prisma");
+    if (Object.keys(allDeps).some((k) => k.startsWith("@clerk")))
+      detected.add("clerk");
+    if (Object.keys(allDeps).some((k) => k.startsWith("@workos")))
+      detected.add("workos");
+    if ("tailwindcss" in allDeps) detected.add("tailwind");
+    if ("vitest" in allDeps) detected.add("vitest");
+    if ("jest" in allDeps) detected.add("jest");
+    if (Object.keys(allDeps).some((k) => k.startsWith("@testing-library")))
+      detected.add("testing-library");
+  }
+  for (const f of ["convex/schema.ts", "convex/schema.js"]) {
+    if (await pathExists(join5(targetDir, f))) detected.add("convex");
+  }
+  for (const f of ["next.config.ts", "next.config.js", "next.config.mjs"]) {
+    if (await pathExists(join5(targetDir, f))) detected.add("nextjs");
+  }
+  const appJsonPath = join5(targetDir, "app.json");
+  if (await pathExists(appJsonPath)) {
+    try {
+      const appContent = await readFile3(appJsonPath, "utf-8");
+      if (appContent.includes('"expo"')) detected.add("expo");
+    } catch {
+    }
+  }
+  if (await pathExists(join5(targetDir, "tsconfig.json"))) {
+    detected.add("typescript");
+  }
+  const raw = Array.from(detected);
+  return {
+    raw,
+    frameworks: raw.filter((s) => ["nextjs", "react", "expo"].includes(s)),
+    database: raw.filter((s) => ["convex", "prisma"].includes(s)),
+    auth: raw.filter((s) => ["clerk", "workos"].includes(s)),
+    styling: raw.filter((s) => ["tailwind"].includes(s)),
+    language: raw.filter((s) => ["typescript"].includes(s)),
+    testing: raw.filter(
+      (s) => ["vitest", "jest", "testing-library"].includes(s)
+    )
+  };
+}
+function stackToDetectedConfig(stack) {
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    frameworks: stack.frameworks,
+    database: stack.database,
+    auth: stack.auth,
+    styling: stack.styling,
+    language: stack.language,
+    testing: stack.testing
+  };
+}
+var init_stack = __esm({
+  "src/lib/stack.ts"() {
+    "use strict";
+    init_fs_ops();
+  }
+});
+
+// src/lib/post-install.ts
+import { execSync } from "child_process";
+import { join as join6 } from "path";
+async function runManifestGeneration(targetDir) {
+  const scriptPath = join6(
+    targetDir,
+    ".flydocs",
+    "scripts",
+    "generate_manifest.py"
+  );
+  if (!await pathExists(scriptPath)) return;
+  try {
+    execSync(`python3 "${scriptPath}"`, {
+      cwd: targetDir,
+      stdio: "pipe"
+    });
+    printStatus("Skill manifest");
+  } catch {
+    printWarning("Skill manifest generation failed (non-fatal)");
+  }
+}
+async function runContextGraphBuild(targetDir) {
+  const scriptPath = join6(
+    targetDir,
+    ".claude",
+    "skills",
+    "flydocs-context-graph",
+    "scripts",
+    "graph_build.py"
+  );
+  if (!await pathExists(scriptPath)) return;
+  try {
+    execSync(`python3 "${scriptPath}"`, {
+      cwd: targetDir,
+      stdio: "pipe"
+    });
+    printStatus("Context graph");
+  } catch {
+    printWarning("Context graph build failed (non-fatal)");
+  }
+}
+var init_post_install = __esm({
+  "src/lib/post-install.ts"() {
+    "use strict";
+    init_fs_ops();
+    init_ui();
+  }
+});
+
+// src/lib/skill-manager.ts
+import { readFile as readFile4, readdir, rm as rm2, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { join as join7 } from "path";
+import pc3 from "picocolors";
+function flushFrontmatterValue(mode, lines) {
+  switch (mode) {
+    case "scalar":
+      return lines[0] ?? "";
+    case "list":
+      return lines;
+    case "block":
+      return lines.join("\n").trim();
+  }
+}
+function parseFrontmatter(text3) {
+  const match = text3.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const block = match[1];
+  const result = {};
+  let currentKey = null;
+  let currentMode = "scalar";
+  let currentLines = [];
+  for (const line of block.split("\n")) {
+    const keyMatch = line.match(/^(\w[\w-]*):\s*(.*)/);
+    if (keyMatch && !line.startsWith("  ")) {
+      if (currentKey !== null) {
+        result[currentKey] = flushFrontmatterValue(currentMode, currentLines);
+      }
+      currentKey = keyMatch[1];
+      const value = keyMatch[2].trim();
+      if (value === "|" || value === ">") {
+        currentMode = "block";
+        currentLines = [];
+      } else if (value === "") {
+        currentMode = "list";
+        currentLines = [];
+      } else {
+        currentMode = "scalar";
+        currentLines = [value.replace(/^["']|["']$/g, "")];
+      }
+      continue;
+    }
+    const stripped = line.trim();
+    if (currentKey !== null) {
+      if (currentMode === "list" && stripped.startsWith("- ")) {
+        currentLines.push(
+          stripped.slice(2).trim().replace(/^["']|["']$/g, "")
+        );
+      } else if (currentMode === "block") {
+        currentLines.push(line.replace(/^\s+/, ""));
+      }
+    }
+  }
+  if (currentKey !== null) {
+    result[currentKey] = flushFrontmatterValue(currentMode, currentLines);
+  }
+  return result;
+}
+function isPlatformSkill(name) {
+  return name.startsWith("flydocs-");
+}
+function parseSource(source) {
+  const urlMatch = source.match(
+    /^https?:\/\/github\.com\/([^/]+\/[^/]+)\/tree\/[^/]+\/skills\/([^/]+)\/?$/
+  );
+  if (urlMatch) {
+    return { repo: urlMatch[1], name: urlMatch[2] };
+  }
+  if (source.includes(":")) {
+    const colonIdx = source.lastIndexOf(":");
+    const repo = source.slice(0, colonIdx);
+    const name = source.slice(colonIdx + 1);
+    if (repo.includes("/")) {
+      return { repo, name };
+    }
+  }
+  const catalogEntry = COMMUNITY_CATALOG.find((s) => s.name === source);
+  if (catalogEntry) {
+    return { repo: catalogEntry.repo, name: catalogEntry.name };
+  }
+  throw new Error(
+    `Unknown skill: ${source}
+  Try: flydocs skills search <keyword>
+  Or use full reference: owner/repo:skill-name`
+  );
+}
+async function fetchGitHubJson(url) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 15e3);
+  try {
+    const response = await fetch(url, {
+      headers: { "User-Agent": "flydocs-cli" },
+      signal: controller.signal
+    });
+    if (response.status === 404) return null;
+    if (!response.ok) {
+      throw new Error(
+        `GitHub API returned ${response.status}: ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    if (Array.isArray(data)) {
+      return data;
+    }
+    return [data];
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function downloadFileContent(downloadUrl) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 15e3);
+  try {
+    const response = await fetch(downloadUrl, {
+      headers: { "User-Agent": "flydocs-cli" },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`Download failed: ${response.status}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function downloadRecursive(url, destDir) {
+  const items = await fetchGitHubJson(url);
+  if (items === null) return false;
+  await mkdir2(destDir, { recursive: true });
+  for (const item of items) {
+    const destPath = join7(destDir, item.name);
+    if (item.type === "file") {
+      if (item.download_url) {
+        const content = await downloadFileContent(item.download_url);
+        await writeFile2(destPath, content);
+      }
+    } else if (item.type === "dir") {
+      await downloadRecursive(item.url, destPath);
+    }
+  }
+  return true;
+}
+async function downloadSkillTree(repo, skillName, targetDir) {
+  const apiUrl = `https://api.github.com/repos/${repo}/contents/skills/${skillName}`;
+  return downloadRecursive(apiUrl, targetDir);
+}
+async function listSkills(targetDir) {
+  const skillsDir = join7(targetDir, ".claude", "skills");
+  const platform = [];
+  const community = [];
+  if (!await pathExists(skillsDir)) {
+    return { platform, community };
+  }
+  let entries;
+  try {
+    entries = await readdir(skillsDir);
+  } catch {
+    return { platform, community };
+  }
+  for (const entry of entries.sort()) {
+    const skillFile = join7(skillsDir, entry, "SKILL.md");
+    if (!await pathExists(skillFile)) continue;
+    let content;
+    try {
+      content = await readFile4(skillFile, "utf-8");
+    } catch {
+      continue;
+    }
+    const fm = parseFrontmatter(content);
+    const name = fm !== null && typeof fm["name"] === "string" ? fm["name"] : entry;
+    let triggerCount = 0;
+    if (fm !== null) {
+      const triggers = fm["triggers"];
+      if (Array.isArray(triggers)) {
+        triggerCount = triggers.length;
+      } else if (typeof triggers === "string") {
+        triggerCount = triggers.split(",").filter((t) => t.trim().length > 0).length;
+      }
+    }
+    const info = {
+      name,
+      dir: entry,
+      type: isPlatformSkill(entry) ? "platform" : "community",
+      triggers: triggerCount
+    };
+    if (info.type === "platform") {
+      platform.push(info);
+    } else {
+      community.push(info);
+    }
+  }
+  return { platform, community };
+}
+function searchCatalog(keyword) {
+  const lower = keyword.toLowerCase();
+  return COMMUNITY_CATALOG.filter((skill) => {
+    const searchable = `${skill.name} ${skill.description} ${skill.tags.join(" ")}`.toLowerCase();
+    return searchable.includes(lower);
+  });
+}
+async function addSkill(targetDir, source) {
+  if (isPlatformSkill(source)) {
+    printError(`Cannot install platform skill '${source}'.`);
+    console.log("  Platform skills (flydocs-*) are managed by the installer.");
+    return;
+  }
+  const { repo, name: skillName } = parseSource(source);
+  if (isPlatformSkill(skillName)) {
+    printError(`Cannot install platform skill '${skillName}'.`);
+    console.log("  Platform skills (flydocs-*) are managed by the installer.");
+    return;
+  }
+  const skillsDir = join7(targetDir, ".claude", "skills", skillName);
+  if (await pathExists(skillsDir)) {
+    printWarning(`Skill '${skillName}' is already installed.`);
+    console.log(`  Remove first: flydocs skills remove ${skillName}`);
+    return;
+  }
+  console.log();
+  console.log(
+    `${pc3.blue("->")} Installing ${pc3.cyan(skillName)} from ${repo}...`
+  );
+  console.log();
+  let success;
+  try {
+    success = await downloadSkillTree(repo, skillName, skillsDir);
+  } catch (err) {
+    if (await pathExists(skillsDir)) {
+      await rm2(skillsDir, { recursive: true, force: true });
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    printError(`Download failed: ${message}`);
+    return;
+  }
+  if (!success) {
+    if (await pathExists(skillsDir)) {
+      await rm2(skillsDir, { recursive: true, force: true });
+    }
+    printError(`Skill not found at ${repo}/skills/${skillName}`);
+    return;
+  }
+  const skillMdPath = join7(skillsDir, "SKILL.md");
+  if (!await pathExists(skillMdPath)) {
+    await rm2(skillsDir, { recursive: true, force: true });
+    printError("Invalid skill: SKILL.md not found.");
+    return;
+  }
+  const skillMdContent = await readFile4(skillMdPath, "utf-8");
+  const fm = parseFrontmatter(skillMdContent);
+  if (fm === null || !fm["name"] || !fm["description"]) {
+    await rm2(skillsDir, { recursive: true, force: true });
+    printError(
+      "Invalid skill: SKILL.md missing required frontmatter (name, description)."
+    );
+    return;
+  }
+  if (!fm["triggers"]) {
+    printWarning(
+      "SKILL.md has no triggers -- skill won't appear in manifest index."
+    );
+  }
+  printStatus("Downloaded skill files");
+  const cursorRuleSrc = join7(skillsDir, "cursor-rule.mdc");
+  if (await pathExists(cursorRuleSrc)) {
+    const cursorRulesDir = join7(targetDir, ".cursor", "rules");
+    await mkdir2(cursorRulesDir, { recursive: true });
+    const cursorRuleDest = join7(cursorRulesDir, `${skillName}.mdc`);
+    await copyFile(cursorRuleSrc, cursorRuleDest);
+    printStatus("Installed cursor rule");
+  }
+  const config = await readConfig(targetDir);
+  const installed = config.skills?.installed ?? [];
+  const entry = `${repo}/${skillName}`;
+  if (!installed.includes(entry)) {
+    installed.push(entry);
+    if (!config.skills) {
+      config.skills = { installed: [], custom: [] };
+    }
+    config.skills.installed = installed;
+    await writeConfig(targetDir, config);
+    printStatus("Updated config.json");
+  }
+  await runManifestGeneration(targetDir);
+  console.log();
+  printStatus(`Installed ${pc3.cyan(skillName)}`);
+  console.log();
+}
+async function removeSkill(targetDir, name) {
+  if (isPlatformSkill(name)) {
+    printError(`Cannot remove platform skill '${name}'.`);
+    console.log("  Platform skills (flydocs-*) are managed by the installer.");
+    return;
+  }
+  const skillDir = join7(targetDir, ".claude", "skills", name);
+  if (!await pathExists(skillDir)) {
+    printError(`Skill '${name}' is not installed.`);
+    return;
+  }
+  await rm2(skillDir, { recursive: true, force: true });
+  printStatus("Removed skill directory");
+  const cursorRule = join7(targetDir, ".cursor", "rules", `${name}.mdc`);
+  if (await pathExists(cursorRule)) {
+    await rm2(cursorRule, { force: true });
+    printStatus("Removed cursor rule");
+  }
+  const config = await readConfig(targetDir);
+  const installed = config.skills?.installed ?? [];
+  config.skills.installed = installed.filter((s) => !s.endsWith(`/${name}`));
+  await writeConfig(targetDir, config);
+  printStatus("Updated config.json");
+  await runManifestGeneration(targetDir);
+  console.log();
+  printStatus(`Removed ${pc3.cyan(name)}`);
+  console.log();
+}
+var COMMUNITY_CATALOG;
+var init_skill_manager = __esm({
+  "src/lib/skill-manager.ts"() {
+    "use strict";
+    init_config();
+    init_fs_ops();
+    init_ui();
+    init_post_install();
+    COMMUNITY_CATALOG = [
+      {
+        name: "react-best-practices",
+        repo: "vercel-labs/agent-skills",
+        description: "React/Next.js performance optimization (40+ rules from Vercel)",
+        tags: ["react", "nextjs", "performance", "components"]
+      },
+      {
+        name: "web-design-guidelines",
+        repo: "vercel-labs/agent-skills",
+        description: "UI/UX accessibility and design patterns (100+ rules)",
+        tags: ["design", "accessibility", "ux", "ui", "nextjs", "web"]
+      },
+      {
+        name: "convex-best-practices",
+        repo: "waynesutton/convexskills",
+        description: "Convex database patterns and best practices",
+        tags: ["convex", "database", "backend"]
+      },
+      {
+        name: "convex-functions",
+        repo: "waynesutton/convexskills",
+        description: "Convex query/mutation/action patterns",
+        tags: ["convex", "functions", "query", "mutation"]
+      },
+      {
+        name: "tailwind-v4",
+        repo: "blencorp/claude-code-kit",
+        description: "Tailwind CSS v4 patterns and configuration",
+        tags: ["tailwind", "css", "styling"]
+      },
+      {
+        name: "clerk-auth",
+        repo: "blencorp/claude-code-kit",
+        description: "Clerk authentication patterns",
+        tags: ["clerk", "auth", "authentication"]
+      }
+    ];
+  }
+});
+
+// src/lib/community-skills.ts
+import { multiselect, isCancel, cancel } from "@clack/prompts";
+import pc4 from "picocolors";
+function suggestSkills(stack) {
+  const seen = /* @__PURE__ */ new Set();
+  const suggested = [];
+  for (const skill of COMMUNITY_SKILLS_MAP) {
+    if (stack.raw.includes(skill.stackTrigger)) {
+      const key = `${skill.repo}:${skill.name}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        suggested.push(skill);
+      }
+    }
+  }
+  return suggested;
+}
+async function promptCommunitySkills(targetDir, stack, autoYes) {
+  const suggestions = suggestSkills(stack);
+  if (suggestions.length === 0) {
+    printInfo("No community skills suggested for detected stack.");
+    console.log(`  Browse more at: ${pc4.cyan("https://skills.sh/")}`);
+    return;
+  }
+  console.log();
+  console.log(`  ${pc4.bold(pc4.yellow("Community Skills (Recommended)"))}`);
+  console.log();
+  console.log(`  Based on your stack: ${pc4.cyan(stack.raw.join(", "))}`);
+  console.log();
+  console.log("  FlyDocs bundles workflow skills. Community skills add");
+  console.log("  stack-specific patterns from the Agent Skills ecosystem.");
+  console.log();
+  let selected;
+  if (autoYes) {
+    selected = suggestions;
+    console.log("  Auto-accepting all (--yes)");
+  } else {
+    const options = suggestions.map((s) => ({
+      value: s,
+      label: s.name,
+      hint: s.description
+    }));
+    const result = await multiselect({
+      message: "Select community skills to install",
+      options,
+      required: false
+    });
+    if (isCancel(result)) {
+      cancel("Skipped community skills");
+      selected = [];
+    } else {
+      selected = result;
+    }
+  }
+  if (selected.length === 0) {
+    printInfo(
+      "Skipped community skills. Install later: flydocs skills add <name>"
+    );
+    return;
+  }
+  console.log();
+  console.log(`  Installing ${selected.length} community skill(s)...`);
+  console.log();
+  let successCount = 0;
+  for (const skill of selected) {
+    try {
+      await addSkill(targetDir, `${skill.repo}:${skill.name}`);
+      successCount++;
+    } catch {
+      printError(`${skill.name} (failed)`);
+    }
+  }
+  console.log();
+  printStatus(`${successCount} community skill(s) installed`);
+  console.log(`  Manage skills: flydocs skills list`);
+  console.log(`  Browse more at: ${pc4.cyan("https://skills.sh/")}`);
+}
+var COMMUNITY_SKILLS_MAP;
+var init_community_skills = __esm({
+  "src/lib/community-skills.ts"() {
+    "use strict";
+    init_ui();
+    init_skill_manager();
+    COMMUNITY_SKILLS_MAP = [
+      {
+        stackTrigger: "nextjs",
+        repo: "vercel-labs/agent-skills",
+        name: "react-best-practices",
+        description: "React/Next.js performance optimization (40+ rules from Vercel)"
+      },
+      {
+        stackTrigger: "nextjs",
+        repo: "vercel-labs/agent-skills",
+        name: "web-design-guidelines",
+        description: "UI/UX accessibility and design patterns (100+ rules)"
+      },
+      {
+        stackTrigger: "react",
+        repo: "vercel-labs/agent-skills",
+        name: "react-best-practices",
+        description: "React performance optimization (40+ rules from Vercel)"
+      },
+      {
+        stackTrigger: "convex",
+        repo: "waynesutton/convexskills",
+        name: "convex-best-practices",
+        description: "Convex database patterns and best practices"
+      },
+      {
+        stackTrigger: "convex",
+        repo: "waynesutton/convexskills",
+        name: "convex-functions",
+        description: "Convex query/mutation/action patterns"
+      },
+      {
+        stackTrigger: "tailwind",
+        repo: "blencorp/claude-code-kit",
+        name: "tailwind-v4",
+        description: "Tailwind CSS v4 patterns and configuration"
+      },
+      {
+        stackTrigger: "clerk",
+        repo: "blencorp/claude-code-kit",
+        name: "clerk-auth",
+        description: "Clerk authentication patterns"
+      }
+    ];
+  }
+});
+
+// src/lib/deprecated.ts
+import { readdir as readdir2, mkdir as mkdir3, rename, rm as rm3 } from "fs/promises";
+import { join as join8 } from "path";
+import { confirm, isCancel as isCancel2 } from "@clack/prompts";
+async function scanDeprecated(targetDir) {
+  const found = [];
+  for (const item of [...DEPRECATED_DIRS, ...DEPRECATED_FILES]) {
+    if (await pathExists(join8(targetDir, item))) {
+      found.push(item);
+    }
+  }
+  for (const skill of DEPRECATED_SKILLS) {
+    const p = join8(targetDir, ".claude", "skills", skill);
+    if (await pathExists(p)) {
+      found.push(`.claude/skills/${skill}`);
+    }
+  }
+  for (const dir of DEPRECATED_RULES_DIR) {
+    if (await pathExists(join8(targetDir, dir))) {
+      found.push(dir);
+    }
+  }
+  for (const hook of DEPRECATED_HOOKS) {
+    const p = join8(targetDir, ".flydocs", "hooks", hook);
+    if (await pathExists(p)) {
+      found.push(`.flydocs/hooks/${hook}`);
+    }
+  }
+  for (const rule of DEPRECATED_CURSOR_RULES) {
+    const p = join8(targetDir, ".cursor", "rules", rule);
+    if (await pathExists(p)) {
+      found.push(`.cursor/rules/${rule}`);
+    }
+  }
+  for (const dir of DEPRECATED_CURSOR_RULE_DIRS) {
+    const p = join8(targetDir, ".cursor", "rules", dir);
+    if (await pathExists(p)) {
+      found.push(`.cursor/rules/${dir}`);
+    }
+  }
+  for (const cmd of DEPRECATED_COMMANDS) {
+    for (const prefix of [".cursor/commands", ".claude/commands"]) {
+      const p = join8(targetDir, prefix, cmd);
+      if (await pathExists(p)) {
+        found.push(`${prefix}/${cmd}`);
+      }
+    }
+  }
+  return found;
+}
+async function handleLegacyContext(targetDir) {
+  const contextDir = join8(targetDir, "flydocs", "context");
+  const legacyDir = join8(contextDir, "legacy");
+  const oldFiles = ["overview.md", "stack.md", "standards.md"];
+  let hasOld = false;
+  for (const f of oldFiles) {
+    if (await pathExists(join8(contextDir, f))) {
+      hasOld = true;
+      break;
+    }
+  }
+  if (hasOld) {
+    await mkdir3(legacyDir, { recursive: true });
+    for (const f of oldFiles) {
+      const src = join8(contextDir, f);
+      if (await pathExists(src)) {
+        await rename(src, join8(legacyDir, f));
+        printStatus(`Moved flydocs/context/${f} \u2192 legacy/`);
+      }
+    }
+    printInfo(
+      "Run /flydocs-setup to consolidate legacy context into project.md"
+    );
+  }
+}
+async function checkLegacyFolder(targetDir) {
+  const legacyDir = join8(targetDir, "flydocs", "context", "legacy");
+  if (!await pathExists(legacyDir)) return null;
+  try {
+    const entries = await readdir2(legacyDir);
+    if (entries.length > 0) {
+      return "flydocs/context/legacy";
+    }
+  } catch {
+  }
+  return null;
+}
+async function promptCleanup(targetDir, paths) {
+  if (paths.length === 0) {
+    printStatus("No deprecated files found");
+    return;
+  }
+  console.log();
+  printWarning("Found deprecated files/directories:");
+  for (const p of paths) {
+    console.log(`   - ${p}`);
+  }
+  console.log();
+  const shouldDelete = await confirm({
+    message: "Delete deprecated files?"
+  });
+  if (isCancel2(shouldDelete) || !shouldDelete) {
+    printInfo("Keeping deprecated files");
+    return;
+  }
+  for (const p of paths) {
+    await rm3(join8(targetDir, p), { recursive: true, force: true });
+    printStatus(`Deleted: ${p}`);
+  }
+}
+var DEPRECATED_DIRS, DEPRECATED_FILES, DEPRECATED_SKILLS, DEPRECATED_RULES_DIR, DEPRECATED_HOOKS, DEPRECATED_CURSOR_RULES, DEPRECATED_CURSOR_RULE_DIRS, DEPRECATED_COMMANDS;
+var init_deprecated = __esm({
+  "src/lib/deprecated.ts"() {
+    "use strict";
+    init_fs_ops();
+    init_ui();
+    DEPRECATED_DIRS = [".docflow", "docflow"];
+    DEPRECATED_FILES = ["AGENTS.md.bak"];
+    DEPRECATED_SKILLS = [
+      "linear-workflow",
+      "session-workflow",
+      "ai-labor-estimate",
+      "component-workflow",
+      "figma-mcp",
+      "implementation-flow",
+      "review-workflow",
+      "spec-templates"
+    ];
+    DEPRECATED_RULES_DIR = [".flydocs/rules"];
+    DEPRECATED_HOOKS = ["linear-auto-approve.py", "session-end.py"];
+    DEPRECATED_CURSOR_RULES = [
+      "designer-agent.mdc",
+      "docflow-core.mdc",
+      "figma-integration.mdc",
+      "flydocs-core.mdc",
+      "impl-workflow.mdc",
+      "implementation-agent.mdc",
+      "linear-integration.mdc",
+      "pm-agent.mdc",
+      "pm-workflow.mdc",
+      "qe-agent.mdc",
+      "qe-workflow.mdc",
+      "session-awareness.mdc",
+      "templates.mdc"
+    ];
+    DEPRECATED_CURSOR_RULE_DIRS = ["designer-agent", "docflow-core"];
+    DEPRECATED_COMMANDS = [
+      "docflow-setup.md",
+      "docflow-update.md",
+      "sync-project.md",
+      "design-setup.md"
+    ];
+  }
+});
+
+// src/lib/gitignore.ts
+import { readFile as readFile5, writeFile as writeFile3, appendFile } from "fs/promises";
+import { join as join9 } from "path";
+async function ensureGitignore(targetDir) {
+  const gitignorePath = join9(targetDir, ".gitignore");
+  if (await pathExists(gitignorePath)) {
+    const content = await readFile5(gitignorePath, "utf-8");
+    if (!content.includes("# FlyDocs")) {
+      const section = "\n# FlyDocs\n" + FLYDOCS_GITIGNORE_ENTRIES.join("\n") + "\n";
+      await appendFile(gitignorePath, section, "utf-8");
+      printStatus("Added FlyDocs entries to .gitignore");
+    }
+  } else {
+    await writeFile3(gitignorePath, FULL_GITIGNORE_TEMPLATE, "utf-8");
+    printStatus(".gitignore (new)");
+  }
+}
+async function migrateGitignore(targetDir) {
+  const gitignorePath = join9(targetDir, ".gitignore");
+  if (!await pathExists(gitignorePath)) return;
+  const content = await readFile5(gitignorePath, "utf-8");
+  if (!content.includes("flydocs/context/graph.json")) {
+    if (content.includes("# FlyDocs")) {
+      const lines = content.split("\n");
+      const flyDocsIdx = lines.findIndex((l) => l.trim() === "# FlyDocs");
+      if (flyDocsIdx !== -1) {
+        let insertIdx = flyDocsIdx + 1;
+        while (insertIdx < lines.length && lines[insertIdx].trim() !== "" && !lines[insertIdx].startsWith("#")) {
+          insertIdx++;
+        }
+        lines.splice(insertIdx, 0, "flydocs/context/graph.json");
+        await writeFile3(gitignorePath, lines.join("\n"), "utf-8");
+      } else {
+        await appendFile(
+          gitignorePath,
+          "\nflydocs/context/graph.json\n",
+          "utf-8"
+        );
+      }
+    } else {
+      await appendFile(
+        gitignorePath,
+        "\nflydocs/context/graph.json\n",
+        "utf-8"
+      );
+    }
+    printStatus("Added flydocs/context/graph.json to .gitignore");
+  }
+}
+var FLYDOCS_GITIGNORE_ENTRIES, FULL_GITIGNORE_TEMPLATE;
+var init_gitignore = __esm({
+  "src/lib/gitignore.ts"() {
+    "use strict";
+    init_fs_ops();
+    init_ui();
+    FLYDOCS_GITIGNORE_ENTRIES = [
+      ".env",
+      ".env.local",
+      ".flydocs/session.json",
+      ".flydocs/logs/",
+      ".flydocs/backup-*/",
+      "flydocs/context/graph.json"
+    ];
+    FULL_GITIGNORE_TEMPLATE = `# Environment
+.env
+.env.local
+.env.*.local
+
+# FlyDocs
+.flydocs/session.json
+.flydocs/logs/
+.flydocs/backup-*/
+flydocs/context/graph.json
+
+# Dependencies
+node_modules/
+
+# Build
+dist/
+build/
+.next/
+out/
+
+# IDE
+.idea/
+*.swp
+*.swo
+.DS_Store
+
+# Logs
+*.log
+
+# Python
+__pycache__/
+*.pyc
+`;
+  }
+});
+
+// src/lib/version.ts
+import { readFile as readFile6 } from "fs/promises";
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  const len = Math.max(parts1.length, parts2.length);
+  for (let i = 0; i < len; i++) {
+    const a = parts1[i] ?? 0;
+    const b = parts2[i] ?? 0;
+    if (a < b) return "older";
+    if (a > b) return "newer";
+  }
+  return "equal";
+}
+async function getWhatsNew(changelogPath, fromVersion, toVersion) {
+  let content;
+  try {
+    content = await readFile6(changelogPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const sections = content.split(/^## \[/m);
+  const relevant = [];
+  for (const section of sections.slice(1)) {
+    const match = section.match(/^([\d.]+)\]/);
+    if (!match) continue;
+    const ver = match[1];
+    if (compareVersions(ver, fromVersion) !== "older" && compareVersions(ver, fromVersion) !== "equal" && (compareVersions(ver, toVersion) === "older" || compareVersions(ver, toVersion) === "equal")) {
+      const lines = section.split("\n");
+      for (const line of lines) {
+        const stripped = line.trim();
+        if (stripped.startsWith("- ")) {
+          relevant.push(stripped);
+        }
+      }
+    }
+  }
+  return relevant;
+}
+var init_version = __esm({
+  "src/lib/version.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/update-check.ts
+import { readFile as readFile7, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+import { join as join10 } from "path";
+import { homedir } from "os";
+import pc5 from "picocolors";
+async function readCache() {
+  try {
+    const raw = await readFile7(CACHE_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && "checkedAt" in parsed && "latestVersion" in parsed && typeof parsed.checkedAt === "number" && typeof parsed.latestVersion === "string") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function writeCache(cache) {
+  try {
+    await mkdir4(join10(homedir(), ".flydocs"), { recursive: true });
+    await writeFile4(CACHE_FILE, JSON.stringify(cache), "utf-8");
+  } catch {
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const response = await fetch(
+      `https://registry.npmjs.org/${PACKAGE_NAME}/latest`,
+      { signal: controller.signal }
+    );
+    clearTimeout(timeout);
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    if (typeof data === "object" && data !== null && "version" in data && typeof data.version === "string") {
+      return data.version;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdate() {
+  try {
+    const cache = await readCache();
+    if (cache && Date.now() - cache.checkedAt < CACHE_TTL_MS) {
+      return {
+        currentVersion: CLI_VERSION,
+        latestVersion: cache.latestVersion,
+        updateAvailable: compareVersions(CLI_VERSION, cache.latestVersion) === "older"
+      };
+    }
+    const latestVersion = await fetchLatestVersion();
+    if (!latestVersion) {
+      return null;
+    }
+    await writeCache({ checkedAt: Date.now(), latestVersion });
+    return {
+      currentVersion: CLI_VERSION,
+      latestVersion,
+      updateAvailable: compareVersions(CLI_VERSION, latestVersion) === "older"
+    };
+  } catch {
+    return null;
+  }
+}
+function printUpdateNotice(result) {
+  if (!result.updateAvailable) {
+    return;
+  }
+  console.log();
+  console.log(
+    `  ${pc5.dim("Update available:")} ${pc5.cyan(result.currentVersion)} ${pc5.dim("->")} ${pc5.cyan(result.latestVersion)}`
+  );
+  console.log(
+    `  ${pc5.dim("Run:")} ${pc5.yellow(`npm update -g ${PACKAGE_NAME}`)}`
+  );
+  console.log();
+}
+var CACHE_FILE, CACHE_TTL_MS, FETCH_TIMEOUT_MS;
+var init_update_check = __esm({
+  "src/lib/update-check.ts"() {
+    "use strict";
+    init_constants();
+    init_version();
+    CACHE_FILE = join10(homedir(), ".flydocs", "update-check.json");
+    CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+    FETCH_TIMEOUT_MS = 5e3;
+  }
+});
+
+// src/commands/install.ts
+var install_exports = {};
+__export(install_exports, {
+  default: () => install_default
+});
+import { defineCommand } from "citty";
+import { resolve as resolve2 } from "path";
+import { join as join11 } from "path";
+import { select, isCancel as isCancel3, cancel as cancel2 } from "@clack/prompts";
+var install_default;
+var init_install = __esm({
+  "src/commands/install.ts"() {
+    "use strict";
+    init_template();
+    init_fs_ops();
+    init_ui();
+    init_config();
+    init_skills();
+    init_stack();
+    init_community_skills();
+    init_deprecated();
+    init_gitignore();
+    init_post_install();
+    init_update_check();
+    install_default = defineCommand({
+      meta: {
+        name: "install",
+        description: "Install FlyDocs in a project directory"
+      },
+      args: {
+        tier: {
+          type: "string",
+          description: "Set tier: 'local' (free) or 'cloud' (Linear)"
+        },
+        path: {
+          type: "string",
+          description: "Install in the specified directory"
+        },
+        here: {
+          type: "boolean",
+          description: "Install in the current directory",
+          default: false
+        },
+        "local-source": {
+          type: "boolean",
+          description: "Force use of local template/ directory",
+          default: false
+        },
+        yes: {
+          type: "boolean",
+          alias: ["y"],
+          description: "Accept all community skill recommendations",
+          default: false
+        }
+      },
+      async run({ args }) {
+        const templateDir = await resolveTemplatePath(args["local-source"]);
+        const version = await readTemplateVersion(templateDir);
+        printBanner(version);
+        let targetDir;
+        if (args.path) {
+          targetDir = resolve2(args.path.replace(/^~/, process.env.HOME ?? "~"));
+        } else if (args.here) {
+          targetDir = process.cwd();
+        } else {
+          targetDir = process.cwd();
+        }
+        if (!await pathExists(targetDir)) {
+          printError(`Directory does not exist: ${targetDir}`);
+          process.exit(1);
+        }
+        targetDir = resolve2(targetDir);
+        if (targetDir !== process.cwd()) {
+          printInfo(`Installing to: ${targetDir}`);
+          console.log();
+        }
+        process.chdir(targetDir);
+        let tier;
+        if (args.tier) {
+          if (args.tier !== "local" && args.tier !== "cloud") {
+            printError(`Invalid tier: ${args.tier} (must be 'local' or 'cloud')`);
+            process.exit(1);
+          }
+          tier = args.tier;
+          printInfo(`Tier set via flag: ${tier}`);
+        } else if (await pathExists(join11(targetDir, ".flydocs", "config.json"))) {
+          try {
+            const existing = await readConfig(targetDir);
+            if (existing.tier) {
+              tier = existing.tier;
+              printInfo(`Tier from config: ${tier}`);
+            }
+          } catch {
+          }
+        }
+        if (!tier) {
+          const tierChoice = await select({
+            message: "Select your tier",
+            options: [
+              {
+                value: "local",
+                label: "local",
+                hint: "File-based issues. No accounts, no API keys, works offline."
+              },
+              {
+                value: "cloud",
+                label: "cloud",
+                hint: "Linear integration. Real-time sync with your team."
+              }
+            ]
+          });
+          if (isCancel3(tierChoice)) {
+            cancel2("Installation cancelled.");
+            process.exit(0);
+          }
+          tier = tierChoice;
+          console.log();
+        }
+        if (!await pathExists(join11(targetDir, ".git"))) {
+          printError(
+            "Not in a git repository. Please run from the root of your project."
+          );
+          process.exit(1);
+        }
+        await ensureDirectories(targetDir, tier);
+        console.log("Installing framework files...");
+        await replaceDirectory(
+          join11(templateDir, ".flydocs", "templates"),
+          join11(targetDir, ".flydocs", "templates")
+        );
+        await replaceDirectory(
+          join11(templateDir, ".flydocs", "hooks"),
+          join11(targetDir, ".flydocs", "hooks")
+        );
+        await replaceDirectory(
+          join11(templateDir, ".flydocs", "scripts"),
+          join11(targetDir, ".flydocs", "scripts")
+        );
+        await copyFile(
+          join11(templateDir, ".flydocs", "version"),
+          join11(targetDir, ".flydocs", "version")
+        );
+        const manifestSrc = join11(templateDir, "manifest.json");
+        if (await pathExists(manifestSrc)) {
+          await copyFile(manifestSrc, join11(targetDir, ".flydocs", "manifest.json"));
+        }
+        const changelogSrc = join11(templateDir, "CHANGELOG.md");
+        if (await pathExists(changelogSrc)) {
+          await copyFile(changelogSrc, join11(targetDir, ".flydocs", "CHANGELOG.md"));
+        }
+        printStatus(".flydocs/templates, hooks, version, manifest, changelog");
+        const configPath = join11(targetDir, ".flydocs", "config.json");
+        if (!await pathExists(configPath)) {
+          const config = await createFreshConfig(templateDir, version, tier);
+          await writeConfig(targetDir, config);
+          printStatus(`.flydocs/config.json (new, tier: ${tier})`);
+        } else if (args.tier) {
+          try {
+            const existing = await readConfig(targetDir);
+            existing.version = version;
+            existing.tier = tier;
+            await writeConfig(targetDir, existing);
+            printStatus(`.flydocs/config.json (tier updated: ${tier})`);
+          } catch {
+            const config = await createFreshConfig(templateDir, version, tier);
+            await writeConfig(targetDir, config);
+            printStatus(`.flydocs/config.json (recreated, tier: ${tier})`);
+          }
+        } else {
+          printWarning(".flydocs/config.json exists, preserving");
+        }
+        console.log();
+        console.log(`Installing skills (tier: ${tier})...`);
+        await installOwnedSkills(templateDir, targetDir, tier);
+        printStatus(`Skills installed (tier: ${tier})`);
+        console.log();
+        console.log("Installing agents and commands...");
+        const claudeAgentsSrc = join11(templateDir, ".claude", "agents");
+        if (await pathExists(claudeAgentsSrc)) {
+          await copyDirectoryContents(
+            claudeAgentsSrc,
+            join11(targetDir, ".claude", "agents")
+          );
+        }
+        await copyDirectoryContents(
+          join11(templateDir, ".claude", "commands"),
+          join11(targetDir, ".claude", "commands")
+        );
+        await copyFile(
+          join11(templateDir, ".claude", "CLAUDE.md"),
+          join11(targetDir, ".claude", "CLAUDE.md")
+        );
+        await copyFile(
+          join11(templateDir, ".claude", "settings.json"),
+          join11(targetDir, ".claude", "settings.json")
+        );
+        printStatus(".claude/ (agents, commands, CLAUDE.md, settings)");
+        const cursorAgentsSrc = join11(templateDir, ".cursor", "agents");
+        if (await pathExists(cursorAgentsSrc)) {
+          await copyDirectoryContents(
+            cursorAgentsSrc,
+            join11(targetDir, ".cursor", "agents")
+          );
+        }
+        await copyDirectoryContents(
+          join11(templateDir, ".claude", "commands"),
+          join11(targetDir, ".cursor", "commands")
+        );
+        await copyFile(
+          join11(templateDir, ".cursor", "hooks.json"),
+          join11(targetDir, ".cursor", "hooks.json")
+        );
+        printStatus(".cursor/ (agents, commands, hooks)");
+        await copyCursorRules(targetDir);
+        printStatus(".cursor/rules/");
+        const mcpResult = await copyFileIfNotExists(
+          join11(templateDir, ".cursor", "mcp.json"),
+          join11(targetDir, ".cursor", "mcp.json")
+        );
+        if (mcpResult === "created") {
+          printStatus(".cursor/mcp.json (new)");
+        } else {
+          printWarning(".cursor/mcp.json exists, preserving");
+        }
+        await copyFile(
+          join11(templateDir, "AGENTS.md"),
+          join11(targetDir, "AGENTS.md")
+        );
+        printStatus("AGENTS.md");
+        await runManifestGeneration(targetDir);
+        await runContextGraphBuild(targetDir);
+        console.log();
+        console.log("Installing project templates...");
+        const userFiles = [
+          {
+            src: join11(templateDir, "flydocs", "context", "project.md"),
+            dest: join11(targetDir, "flydocs", "context", "project.md"),
+            label: "flydocs/context/project.md"
+          },
+          {
+            src: join11(templateDir, "flydocs", "knowledge", "INDEX.md"),
+            dest: join11(targetDir, "flydocs", "knowledge", "INDEX.md"),
+            label: "flydocs/knowledge/INDEX.md"
+          },
+          {
+            src: join11(templateDir, "flydocs", "knowledge", "README.md"),
+            dest: join11(targetDir, "flydocs", "knowledge", "README.md"),
+            label: "flydocs/knowledge/README.md"
+          },
+          {
+            src: join11(
+              templateDir,
+              "flydocs",
+              "knowledge",
+              "product",
+              "personas.md"
+            ),
+            dest: join11(targetDir, "flydocs", "knowledge", "product", "personas.md"),
+            label: "flydocs/knowledge/product/personas.md"
+          },
+          {
+            src: join11(
+              templateDir,
+              "flydocs",
+              "knowledge",
+              "product",
+              "user-flows.md"
+            ),
+            dest: join11(
+              targetDir,
+              "flydocs",
+              "knowledge",
+              "product",
+              "user-flows.md"
+            ),
+            label: "flydocs/knowledge/product/user-flows.md"
+          },
+          {
+            src: join11(templateDir, "flydocs", "design-system", "README.md"),
+            dest: join11(targetDir, "flydocs", "design-system", "README.md"),
+            label: "flydocs/design-system/README.md"
+          },
+          {
+            src: join11(
+              templateDir,
+              "flydocs",
+              "design-system",
+              "component-patterns.md"
+            ),
+            dest: join11(
+              targetDir,
+              "flydocs",
+              "design-system",
+              "component-patterns.md"
+            ),
+            label: "flydocs/design-system/component-patterns.md"
+          },
+          {
+            src: join11(templateDir, "flydocs", "design-system", "token-mapping.md"),
+            dest: join11(targetDir, "flydocs", "design-system", "token-mapping.md"),
+            label: "flydocs/design-system/token-mapping.md"
+          },
+          {
+            src: join11(templateDir, "flydocs", "README.md"),
+            dest: join11(targetDir, "flydocs", "README.md"),
+            label: "flydocs/README.md"
+          }
+        ];
+        for (const file of userFiles) {
+          if (await pathExists(file.src)) {
+            const result = await copyFileIfNotExists(file.src, file.dest);
+            if (result === "created") {
+              printStatus(`${file.label} (new)`);
+            } else {
+              printWarning(`${file.label} exists, preserving`);
+            }
+          }
+        }
+        const envExampleSrc = join11(templateDir, ".env.example");
+        if (await pathExists(envExampleSrc)) {
+          const hasEnv = await pathExists(join11(targetDir, ".env"));
+          const hasEnvExample = await pathExists(join11(targetDir, ".env.example"));
+          if (!hasEnv && !hasEnvExample) {
+            await copyFile(envExampleSrc, join11(targetDir, ".env.example"));
+            printStatus(".env.example (new)");
+          }
+        }
+        await ensureGitignore(targetDir);
+        console.log();
+        console.log("Detecting project stack...");
+        const stack = await detectStack(targetDir);
+        if (stack.raw.length > 0) {
+          printStatus(`Detected: ${stack.raw.join(", ")}`);
+          try {
+            const config = await readConfig(targetDir);
+            config.detectedStack = stackToDetectedConfig(stack);
+            await writeConfig(targetDir, config);
+          } catch {
+          }
+          await promptCommunitySkills(targetDir, stack, args.yes);
+        } else {
+          printInfo("No framework detected in package.json");
+        }
+        console.log();
+        console.log("Checking for deprecated files...");
+        const deprecated = await scanDeprecated(targetDir);
+        await promptCleanup(targetDir, deprecated);
+        const nextSteps = tier === "local" ? [
+          `Tier: ${tier}`,
+          `Version: ${version}`,
+          "",
+          "Next steps:",
+          "  1. Run /flydocs-setup to configure your project",
+          "  2. Start working with /start-session",
+          "",
+          "Documentation: flydocs/README.md"
+        ] : [
+          `Tier: ${tier}`,
+          `Version: ${version}`,
+          "",
+          "Next steps:",
+          "  1. Copy your LINEAR_API_KEY to .env",
+          "  2. Run /flydocs-setup to configure your Linear workspace",
+          "  3. Start working with /start-session",
+          "",
+          "Documentation: flydocs/README.md"
+        ];
+        printCompletionBox("Installation Complete!", nextSteps);
+        printBetaCta();
+        try {
+          const updateResult = await checkForUpdate();
+          if (updateResult) {
+            printUpdateNotice(updateResult);
+          }
+        } catch {
+        }
+      }
+    });
+  }
+});
+
+// src/commands/update.ts
+var update_exports = {};
+__export(update_exports, {
+  default: () => update_default
+});
+import { defineCommand as defineCommand2 } from "citty";
+import { resolve as resolve3, join as join12 } from "path";
+import { mkdir as mkdir5, cp as cp2, readFile as readFile8, readdir as readdir3, rm as rm4 } from "fs/promises";
+import { select as select2, text, confirm as confirm2, isCancel as isCancel4, cancel as cancel3 } from "@clack/prompts";
+import pc6 from "picocolors";
+var update_default;
+var init_update = __esm({
+  "src/commands/update.ts"() {
+    "use strict";
+    init_template();
+    init_version();
+    init_fs_ops();
+    init_ui();
+    init_config();
+    init_skills();
+    init_stack();
+    init_community_skills();
+    init_deprecated();
+    init_gitignore();
+    init_post_install();
+    init_update_check();
+    update_default = defineCommand2({
+      meta: {
+        name: "update",
+        description: "Update an existing FlyDocs installation"
+      },
+      args: {
+        path: {
+          type: "string",
+          description: "Update the specified project directory"
+        },
+        here: {
+          type: "boolean",
+          description: "Update in the current directory",
+          default: false
+        },
+        tier: {
+          type: "string",
+          description: "Change tier: 'local' (free) or 'cloud' (Linear)"
+        },
+        force: {
+          type: "boolean",
+          description: "Force update even if versions match",
+          default: false
+        },
+        "local-source": {
+          type: "boolean",
+          description: "Force use of local template/ directory",
+          default: false
+        },
+        yes: {
+          type: "boolean",
+          alias: ["y"],
+          description: "Accept all community skill recommendations",
+          default: false
+        }
+      },
+      async run({ args }) {
+        const templateDir = await resolveTemplatePath(args["local-source"]);
+        const version = await readTemplateVersion(templateDir);
+        printBanner(version);
+        printInfo("Running in update mode \u2014 framework files will be refreshed");
+        console.log();
+        let targetDir;
+        if (args.path) {
+          targetDir = resolve3(args.path.replace(/^~/, process.env.HOME ?? "~"));
+        } else if (args.here) {
+          targetDir = process.cwd();
+        } else {
+          const choice = await select2({
+            message: "Which project would you like to update?",
+            options: [
+              {
+                value: "cwd",
+                label: `Current directory (${process.cwd()})`
+              },
+              {
+                value: "enter",
+                label: "Enter a path"
+              }
+            ]
+          });
+          if (isCancel4(choice)) {
+            cancel3("Update cancelled.");
+            process.exit(0);
+          }
+          if (choice === "cwd") {
+            targetDir = process.cwd();
+          } else {
+            const enteredPath = await text({
+              message: "Enter project path:"
+            });
+            if (isCancel4(enteredPath)) {
+              cancel3("Update cancelled.");
+              process.exit(0);
+            }
+            targetDir = resolve3(
+              enteredPath.replace(/^~/, process.env.HOME ?? "~")
+            );
+          }
+        }
+        if (!await pathExists(targetDir)) {
+          printError(`Directory does not exist: ${targetDir}`);
+          process.exit(1);
+        }
+        targetDir = resolve3(targetDir);
+        process.chdir(targetDir);
+        const hasVersion = await pathExists(join12(targetDir, ".flydocs", "version"));
+        const hasConfig = await pathExists(
+          join12(targetDir, ".flydocs", "config.json")
+        );
+        if (!hasVersion && !hasConfig) {
+          printError(`Not a FlyDocs project: ${targetDir}`);
+          printInfo("Missing .flydocs/version or .flydocs/config.json");
+          process.exit(1);
+        }
+        printInfo(`Updating project at: ${targetDir}`);
+        console.log();
+        let currentVersion = "0.1.0";
+        if (hasVersion) {
+          const vContent = await readFile8(
+            join12(targetDir, ".flydocs", "version"),
+            "utf-8"
+          );
+          currentVersion = vContent.trim();
+        }
+        const versionStatus = compareVersions(currentVersion, version);
+        if (versionStatus === "equal" && !args.force) {
+          printStatus(`Already up to date (v${currentVersion})`);
+          console.log();
+          console.log(
+            "No changes needed. Use --force to re-apply framework files."
+          );
+          process.exit(0);
+        } else if (versionStatus === "equal" && args.force) {
+          printInfo(`Forcing update at v${currentVersion}`);
+        } else if (versionStatus === "newer") {
+          printWarning(
+            `Project version (${currentVersion}) is newer than installer (${version})`
+          );
+          const shouldContinue = await confirm2({
+            message: "Continue anyway?"
+          });
+          if (isCancel4(shouldContinue) || !shouldContinue) {
+            process.exit(0);
+          }
+        }
+        console.log(`Updating: v${currentVersion} \u2192 v${version}`);
+        console.log();
+        const changelogPath = join12(templateDir, "CHANGELOG.md");
+        const whatsNew = await getWhatsNew(changelogPath, currentVersion, version);
+        if (whatsNew.length > 0) {
+          console.log(pc6.cyan("What's new:"));
+          console.log();
+          for (const entry of whatsNew) {
+            console.log(`  ${entry}`);
+          }
+          console.log();
+        }
+        const now = /* @__PURE__ */ new Date();
+        const ts = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, "0")}${String(now.getDate()).padStart(2, "0")}-${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}${String(now.getSeconds()).padStart(2, "0")}`;
+        const backupDir = join12(targetDir, ".flydocs", `backup-${ts}`);
+        await mkdir5(backupDir, { recursive: true });
+        if (hasConfig) {
+          await cp2(
+            join12(targetDir, ".flydocs", "config.json"),
+            join12(backupDir, "config.json")
+          );
+          printStatus(`Config backed up to .flydocs/backup-${ts}/`);
+        }
+        try {
+          const flydocsDir = join12(targetDir, ".flydocs");
+          const entries = await readdir3(flydocsDir);
+          const backups = entries.filter((e) => e.startsWith("backup-")).sort();
+          if (backups.length > 3) {
+            const toRemove = backups.slice(0, backups.length - 3);
+            for (const old of toRemove) {
+              await rm4(join12(flydocsDir, old), { recursive: true, force: true });
+            }
+          }
+        } catch {
+        }
+        let preserved = {
+          tier: "cloud",
+          setupComplete: false,
+          providerTeamId: null,
+          workspace: {},
+          issueLabels: {},
+          statusMapping: {},
+          detectedStack: {},
+          mcp: {},
+          skills: {},
+          designSystem: null,
+          aiLabor: {}
+        };
+        if (hasConfig) {
+          try {
+            const existingConfig = await readConfig(targetDir);
+            preserved = extractPreservedValues(existingConfig);
+          } catch {
+            printWarning("Could not read existing config \u2014 using defaults");
+          }
+        }
+        let effectiveTier;
+        if (args.tier) {
+          if (args.tier !== "local" && args.tier !== "cloud") {
+            printError(`Invalid tier: ${args.tier} (must be 'local' or 'cloud')`);
+            process.exit(1);
+          }
+          effectiveTier = args.tier;
+        } else {
+          effectiveTier = preserved.tier;
+        }
+        console.log("Replacing framework directories...");
+        await replaceDirectory(
+          join12(templateDir, ".flydocs", "templates"),
+          join12(targetDir, ".flydocs", "templates")
+        );
+        await replaceDirectory(
+          join12(templateDir, ".flydocs", "hooks"),
+          join12(targetDir, ".flydocs", "hooks")
+        );
+        await replaceDirectory(
+          join12(templateDir, ".flydocs", "scripts"),
+          join12(targetDir, ".flydocs", "scripts")
+        );
+        printStatus(".flydocs/templates, hooks, scripts");
+        const claudeAgentsSrc = join12(templateDir, ".claude", "agents");
+        if (await pathExists(claudeAgentsSrc)) {
+          await copyDirectoryContents(
+            claudeAgentsSrc,
+            join12(targetDir, ".claude", "agents")
+          );
+        }
+        printStatus(".claude/agents");
+        await replaceOwnedSkills(templateDir, targetDir, effectiveTier);
+        printStatus(`.claude/skills (tier: ${effectiveTier})`);
+        const cursorAgentsSrc = join12(templateDir, ".cursor", "agents");
+        if (await pathExists(cursorAgentsSrc)) {
+          await copyDirectoryContents(
+            cursorAgentsSrc,
+            join12(targetDir, ".cursor", "agents")
+          );
+        }
+        printStatus(".cursor/agents");
+        console.log();
+        console.log("Replacing framework files...");
+        await copyFile(
+          join12(templateDir, ".claude", "CLAUDE.md"),
+          join12(targetDir, ".claude", "CLAUDE.md")
+        );
+        await copyFile(
+          join12(templateDir, ".claude", "settings.json"),
+          join12(targetDir, ".claude", "settings.json")
+        );
+        printStatus(".claude/CLAUDE.md, settings.json");
+        await copyDirectoryContents(
+          join12(templateDir, ".claude", "commands"),
+          join12(targetDir, ".claude", "commands")
+        );
+        await copyDirectoryContents(
+          join12(templateDir, ".claude", "commands"),
+          join12(targetDir, ".cursor", "commands")
+        );
+        printStatus(".claude/commands, .cursor/commands");
+        const skillsReadmeSrc = join12(templateDir, ".claude", "skills", "README.md");
+        if (await pathExists(skillsReadmeSrc)) {
+          await copyFile(
+            skillsReadmeSrc,
+            join12(targetDir, ".claude", "skills", "README.md")
+          );
+        }
+        printStatus(".claude/skills/README.md");
+        await copyFile(
+          join12(templateDir, ".cursor", "hooks.json"),
+          join12(targetDir, ".cursor", "hooks.json")
+        );
+        printStatus(".cursor/hooks.json");
+        await copyFile(
+          join12(templateDir, "AGENTS.md"),
+          join12(targetDir, "AGENTS.md")
+        );
+        printStatus("AGENTS.md");
+        await runManifestGeneration(targetDir);
+        await runContextGraphBuild(targetDir);
+        console.log();
+        console.log("Updating cursor rules...");
+        await copyCursorRules(targetDir);
+        printStatus(".cursor/rules/");
+        console.log();
+        console.log("Merging configuration...");
+        try {
+          const tierFlag = args.tier;
+          const mergedConfig = await mergeConfig(
+            templateDir,
+            version,
+            tierFlag,
+            preserved
+          );
+          await writeConfig(targetDir, mergedConfig);
+          printStatus(".flydocs/config.json (merged)");
+        } catch {
+          printWarning("Config merge failed \u2014 config.json preserved as-is");
+        }
+        await copyFile(
+          join12(templateDir, ".flydocs", "version"),
+          join12(targetDir, ".flydocs", "version")
+        );
+        printStatus(`.flydocs/version \u2192 ${version}`);
+        const clSrc = join12(templateDir, "CHANGELOG.md");
+        if (await pathExists(clSrc)) {
+          await copyFile(clSrc, join12(targetDir, ".flydocs", "CHANGELOG.md"));
+          printStatus(".flydocs/CHANGELOG.md");
+        }
+        const mfSrc = join12(templateDir, "manifest.json");
+        if (await pathExists(mfSrc)) {
+          await copyFile(mfSrc, join12(targetDir, ".flydocs", "manifest.json"));
+          printStatus(".flydocs/manifest.json");
+        }
+        console.log();
+        console.log("Detecting project stack...");
+        const stack = await detectStack(targetDir);
+        if (stack.raw.length > 0) {
+          printStatus(`Detected: ${stack.raw.join(", ")}`);
+          try {
+            const config = await readConfig(targetDir);
+            config.detectedStack = stackToDetectedConfig(stack);
+            await writeConfig(targetDir, config);
+          } catch {
+          }
+          await promptCommunitySkills(targetDir, stack, args.yes);
+        } else {
+          printInfo("No framework detected in package.json");
+        }
+        await migrateGitignore(targetDir);
+        console.log();
+        console.log("Checking for deprecated files...");
+        await handleLegacyContext(targetDir);
+        const legacyPath = await checkLegacyFolder(targetDir);
+        const deprecated = await scanDeprecated(targetDir);
+        if (legacyPath) {
+          deprecated.push(legacyPath);
+        }
+        await promptCleanup(targetDir, deprecated);
+        printCompletionBox("Update Complete!", [
+          `v${currentVersion} \u2192 v${version}`,
+          `Tier: ${effectiveTier}`,
+          "Config: preserved and merged",
+          "",
+          `Backup: .flydocs/backup-${ts}/`
+        ]);
+        printBetaCta();
+        try {
+          const updateResult = await checkForUpdate();
+          if (updateResult) {
+            printUpdateNotice(updateResult);
+          }
+        } catch {
+        }
+      }
+    });
+  }
+});
+
+// src/commands/setup.ts
+var setup_exports = {};
+__export(setup_exports, {
+  default: () => setup_default
+});
+import { defineCommand as defineCommand3 } from "citty";
+var setup_default;
+var init_setup = __esm({
+  "src/commands/setup.ts"() {
+    "use strict";
+    init_ui();
+    setup_default = defineCommand3({
+      meta: {
+        name: "setup",
+        description: "Configure FlyDocs settings for this project"
+      },
+      run() {
+        printStub("flydocs setup");
+      }
+    });
+  }
+});
+
+// src/commands/skills.ts
+var skills_exports = {};
+__export(skills_exports, {
+  default: () => skills_default
+});
+import { defineCommand as defineCommand4 } from "citty";
+import pc7 from "picocolors";
+var list, search, add, remove, skills_default;
+var init_skills2 = __esm({
+  "src/commands/skills.ts"() {
+    "use strict";
+    init_skill_manager();
+    list = defineCommand4({
+      meta: {
+        name: "list",
+        description: "List installed skills"
+      },
+      async run() {
+        const result = await listSkills(process.cwd());
+        const total = result.platform.length + result.community.length;
+        if (total === 0) {
+          console.log("No skills installed.");
+          return;
+        }
+        console.log();
+        console.log(`${total} skill(s) installed:`);
+        if (result.platform.length > 0) {
+          console.log();
+          console.log(pc7.bold("Platform"));
+          for (const skill of result.platform) {
+            console.log(
+              `  ${skill.name} ${pc7.dim(`(${skill.triggers} triggers)`)}`
+            );
+          }
+        }
+        if (result.community.length > 0) {
+          console.log();
+          console.log(pc7.bold("Community"));
+          for (const skill of result.community) {
+            console.log(
+              `  ${skill.name} ${pc7.dim(`(${skill.triggers} triggers)`)}`
+            );
+          }
+        }
+        console.log();
+      }
+    });
+    search = defineCommand4({
+      meta: {
+        name: "search",
+        description: "Search community skills"
+      },
+      args: {
+        keyword: {
+          type: "positional",
+          description: "Keyword to search for",
+          required: true
+        }
+      },
+      async run({ args }) {
+        const results = await searchCatalog(args.keyword);
+        if (results.length === 0) {
+          console.log(`No skills found for "${args.keyword}".`);
+          console.log(`  Browse the catalog at: ${pc7.cyan("https://skills.sh/")}`);
+          return;
+        }
+        console.log();
+        console.log(`${results.length} skill(s) matching "${args.keyword}":`);
+        console.log();
+        for (const skill of results) {
+          console.log(`  ${pc7.bold(skill.name)}`);
+          console.log(`  ${skill.description}`);
+          console.log(`  ${pc7.dim(skill.repo)}`);
+          if (skill.tags.length > 0) {
+            console.log(`  ${pc7.dim(skill.tags.join(", "))}`);
+          }
+          console.log();
+        }
+      }
+    });
+    add = defineCommand4({
+      meta: {
+        name: "add",
+        description: "Install a community skill"
+      },
+      args: {
+        source: {
+          type: "positional",
+          description: "Skill source (name or URL)",
+          required: true
+        }
+      },
+      async run({ args }) {
+        await addSkill(process.cwd(), args.source);
+      }
+    });
+    remove = defineCommand4({
+      meta: {
+        name: "remove",
+        description: "Remove an installed community skill"
+      },
+      args: {
+        name: {
+          type: "positional",
+          description: "Skill name to remove",
+          required: true
+        }
+      },
+      async run({ args }) {
+        await removeSkill(process.cwd(), args.name);
+      }
+    });
+    skills_default = defineCommand4({
+      meta: {
+        name: "skills",
+        description: "Manage FlyDocs skills (list, search, add, remove)"
+      },
+      subCommands: {
+        list,
+        search,
+        add,
+        remove
+      }
+    });
+  }
+});
+
+// src/commands/connect.ts
+var connect_exports = {};
+__export(connect_exports, {
+  default: () => connect_default
+});
+import { defineCommand as defineCommand5 } from "citty";
+import { text as text2, confirm as confirm3, isCancel as isCancel5, cancel as cancel4 } from "@clack/prompts";
+import pc8 from "picocolors";
+import { readFile as readFile9, writeFile as writeFile5, appendFile as appendFile2 } from "fs/promises";
+import { join as join13 } from "path";
+import { execSync as execSync2 } from "child_process";
+var connect_default;
+var init_connect = __esm({
+  "src/commands/connect.ts"() {
+    "use strict";
+    init_config();
+    init_fs_ops();
+    init_template();
+    init_ui();
+    connect_default = defineCommand5({
+      meta: {
+        name: "connect",
+        description: "Connect FlyDocs to a cloud provider (Linear)"
+      },
+      args: {
+        path: {
+          type: "string",
+          description: "Path to FlyDocs project"
+        },
+        here: {
+          type: "boolean",
+          description: "Use current directory"
+        },
+        "local-source": {
+          type: "boolean",
+          description: "Use local template directory"
+        },
+        key: {
+          type: "string",
+          description: "Linear API key (skips prompt)"
+        }
+      },
+      async run({ args }) {
+        const targetDir = args.path ?? process.cwd();
+        const configPath = join13(targetDir, ".flydocs", "config.json");
+        if (!await pathExists(configPath)) {
+          printError("Not a FlyDocs project (.flydocs/config.json not found).");
+          console.log(
+            `  Run ${pc8.cyan("flydocs")} first to install FlyDocs in this project.`
+          );
+          process.exit(1);
+        }
+        const config = await readConfig(targetDir);
+        if (config.tier === "cloud") {
+          printInfo("This project is already connected to the cloud tier.");
+          console.log();
+          const reconnect = await confirm3({
+            message: "Want to update your API key?"
+          });
+          if (isCancel5(reconnect) || !reconnect) {
+            console.log(`  No changes made.`);
+            return;
+          }
+        }
+        console.log();
+        console.log(`  ${pc8.bold("Connect to Linear")}`);
+        console.log();
+        console.log(
+          `  ${pc8.dim("Get your API key from: Linear \u2192 Settings \u2192 API \u2192 Personal API keys")}`
+        );
+        console.log();
+        let apiKey = args.key ?? "";
+        if (!apiKey) {
+          const keyInput = await text2({
+            message: "Enter your Linear API key",
+            placeholder: "lin_api_...",
+            validate(value) {
+              if (!value.trim()) return "API key is required";
+              if (!value.startsWith("lin_api_"))
+                return "Linear API keys start with lin_api_";
+              return void 0;
+            }
+          });
+          if (isCancel5(keyInput)) {
+            cancel4("Connection cancelled.");
+            process.exit(0);
+          }
+          apiKey = keyInput;
+        }
+        printInfo("Validating API key...");
+        try {
+          const result = execSync2(
+            `python3 -c "
+import urllib.request, json
+req = urllib.request.Request('https://api.linear.app/graphql',
+    data=json.dumps({'query': '{ viewer { id name email } }'}).encode(),
+    headers={'Authorization': '${apiKey}', 'Content-Type': 'application/json'})
+res = urllib.request.urlopen(req)
+data = json.loads(res.read())
+print(json.dumps(data['data']['viewer']))
+"`,
+            { encoding: "utf-8", timeout: 15e3 }
+          );
+          const viewer = JSON.parse(result.trim());
+          printStatus(`Authenticated as ${pc8.bold(viewer.name)} (${viewer.email})`);
+        } catch {
+          printError("Invalid API key or network error.");
+          console.log(`  Check your key and try again.`);
+          process.exit(1);
+        }
+        const envPath = join13(targetDir, ".env");
+        const envLocalPath = join13(targetDir, ".env.local");
+        const targetEnvPath = await pathExists(envLocalPath) ? envLocalPath : envPath;
+        if (await pathExists(targetEnvPath)) {
+          const envContent = await readFile9(targetEnvPath, "utf-8");
+          if (envContent.includes("LINEAR_API_KEY=")) {
+            const updated = envContent.replace(
+              /LINEAR_API_KEY=.*/,
+              `LINEAR_API_KEY=${apiKey}`
+            );
+            await writeFile5(targetEnvPath, updated, "utf-8");
+          } else {
+            await appendFile2(targetEnvPath, `
+LINEAR_API_KEY=${apiKey}
+`);
+          }
+        } else {
+          await writeFile5(targetEnvPath, `LINEAR_API_KEY=${apiKey}
+`, "utf-8");
+        }
+        printStatus(
+          `API key stored in ${pc8.dim(targetEnvPath === envLocalPath ? ".env.local" : ".env")}`
+        );
+        const wasLocal = config.tier === "local";
+        config.tier = "cloud";
+        config.provider = config.provider ?? { type: "linear", teamId: null };
+        config.provider.type = "linear";
+        await writeConfig(targetDir, config);
+        printStatus("Config updated to cloud tier");
+        if (wasLocal) {
+          try {
+            const templateDir = await resolveTemplatePath(
+              args["local-source"] || void 0
+            );
+            const templateSkillsDir = join13(templateDir, ".claude", "skills");
+            const skillsDir = join13(targetDir, ".claude", "skills");
+            await replaceDirectory(
+              join13(templateSkillsDir, "flydocs-cloud"),
+              join13(skillsDir, "flydocs-cloud")
+            );
+            const { rm: rm5 } = await import("fs/promises");
+            const localSkillDir = join13(skillsDir, "flydocs-local");
+            if (await pathExists(localSkillDir)) {
+              await rm5(localSkillDir, { recursive: true, force: true });
+            }
+            printStatus("Cloud mechanism skill installed");
+          } catch {
+            printInfo(
+              "Could not swap mechanism skills automatically. Run flydocs update to complete."
+            );
+          }
+        }
+        console.log();
+        console.log(
+          `  ${pc8.bold("Connected!")} Your project now syncs with Linear.`
+        );
+        console.log();
+        console.log(`  Next steps:`);
+        console.log(
+          `    1. Run ${pc8.cyan("/flydocs-setup")} in your IDE to configure your Linear project`
+        );
+        console.log(`    2. Run ${pc8.cyan("/start-session")} to begin working`);
+        console.log();
+      }
+    });
+  }
+});
+
+// src/commands/upgrade.ts
+var upgrade_exports = {};
+__export(upgrade_exports, {
+  default: () => upgrade_default
+});
+import { defineCommand as defineCommand6 } from "citty";
+import pc9 from "picocolors";
+var upgrade_default;
+var init_upgrade = __esm({
+  "src/commands/upgrade.ts"() {
+    "use strict";
+    init_config();
+    init_fs_ops();
+    upgrade_default = defineCommand6({
+      meta: {
+        name: "upgrade",
+        description: "Learn about FlyDocs Cloud tier and upgrade from local"
+      },
+      args: {
+        path: {
+          type: "string",
+          description: "Path to FlyDocs project"
+        },
+        here: {
+          type: "boolean",
+          description: "Use current directory"
+        }
+      },
+      async run({ args }) {
+        const targetDir = args.path ?? (args.here ? process.cwd() : process.cwd());
+        const configExists = await pathExists(`${targetDir}/.flydocs/config.json`);
+        let currentTier = "unknown";
+        if (configExists) {
+          try {
+            const config = await readConfig(targetDir);
+            currentTier = config.tier;
+          } catch {
+          }
+        }
+        console.log();
+        if (currentTier === "cloud") {
+          console.log(
+            `  ${pc9.green("\u2713")} You're already on the ${pc9.bold("cloud")} tier.`
+          );
+          console.log();
+          console.log(
+            `  Your issues sync with Linear via the cloud mechanism skill.`
+          );
+          console.log(
+            `  Run ${pc9.cyan("flydocs connect")} to update your connection settings.`
+          );
+          console.log();
+          return;
+        }
+        console.log(`  ${pc9.bold("FlyDocs Cloud Tier")}`);
+        console.log();
+        console.log(`  You're currently on the ${pc9.yellow("local")} tier.`);
+        console.log(`  Upgrade to cloud for:`);
+        console.log();
+        console.log(
+          `    ${pc9.cyan("\u2192")} Issue sync with Linear (Jira coming soon)`
+        );
+        console.log(`    ${pc9.cyan("\u2192")} Project milestones and cycle management`);
+        console.log(`    ${pc9.cyan("\u2192")} Team assignment and priority tracking`);
+        console.log(`    ${pc9.cyan("\u2192")} Project health updates and dashboards`);
+        console.log(`    ${pc9.cyan("\u2192")} Cross-project issue linking`);
+        console.log();
+        console.log(`  ${pc9.bold("How to upgrade:")}`);
+        console.log();
+        console.log(`    1. Sign up at ${pc9.cyan("https://www.flydocs.ai")}`);
+        console.log(`    2. Get your Linear API key from Linear \u2192 Settings \u2192 API`);
+        console.log(
+          `    3. Run ${pc9.cyan("flydocs connect")} to connect your project`
+        );
+        console.log();
+      }
+    });
+  }
+});
+
+// src/commands/self-update.ts
+var self_update_exports = {};
+__export(self_update_exports, {
+  default: () => self_update_default
+});
+import { defineCommand as defineCommand7 } from "citty";
+import { execSync as execSync3 } from "child_process";
+import pc10 from "picocolors";
+var self_update_default;
+var init_self_update = __esm({
+  "src/commands/self-update.ts"() {
+    "use strict";
+    init_constants();
+    init_ui();
+    self_update_default = defineCommand7({
+      meta: {
+        name: "self-update",
+        description: "Update FlyDocs CLI to the latest version"
+      },
+      async run() {
+        console.log();
+        console.log(`  Updating ${pc10.cyan(PACKAGE_NAME)}...`);
+        console.log();
+        try {
+          execSync3(`npm update -g ${PACKAGE_NAME}`, {
+            stdio: "inherit",
+            timeout: 6e4
+          });
+          console.log();
+          printStatus("FlyDocs CLI updated successfully");
+        } catch {
+          printError(`Update failed. Try manually: npm update -g ${PACKAGE_NAME}`);
+          process.exit(1);
+        }
+      }
+    });
+  }
+});
+
+// src/cli.ts
+init_constants();
+import { defineCommand as defineCommand8, runCommand, runMain } from "citty";
+var main = defineCommand8({
+  meta: {
+    name: CLI_NAME,
+    version: CLI_VERSION,
+    description: "FlyDocs AI CLI \u2014 install, setup, and manage FlyDocs projects"
+  },
+  subCommands: {
+    install: () => Promise.resolve().then(() => (init_install(), install_exports)).then((m) => m.default),
+    update: () => Promise.resolve().then(() => (init_update(), update_exports)).then((m) => m.default),
+    setup: () => Promise.resolve().then(() => (init_setup(), setup_exports)).then((m) => m.default),
+    skills: () => Promise.resolve().then(() => (init_skills2(), skills_exports)).then((m) => m.default),
+    connect: () => Promise.resolve().then(() => (init_connect(), connect_exports)).then((m) => m.default),
+    upgrade: () => Promise.resolve().then(() => (init_upgrade(), upgrade_exports)).then((m) => m.default),
+    "self-update": () => Promise.resolve().then(() => (init_self_update(), self_update_exports)).then((m) => m.default)
+  },
+  async run({ rawArgs }) {
+    const subCommandNames = /* @__PURE__ */ new Set([
+      "install",
+      "update",
+      "setup",
+      "skills",
+      "connect",
+      "upgrade",
+      "self-update"
+    ]);
+    const firstArg = rawArgs.find((a) => !a.startsWith("-"));
+    if (firstArg && subCommandNames.has(firstArg)) return;
+    const installCmd = await Promise.resolve().then(() => (init_install(), install_exports)).then(
+      (m) => m.default
+    );
+    await runCommand(installCmd, { rawArgs });
+  }
+});
+runMain(main);