lynxprompt 0.1.0 → 0.2.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk9 from "chalk";
+import chalk16 from "chalk";
 
 // src/commands/login.ts
 import chalk from "chalk";
@@ -135,6 +135,19 @@ var ApiClient = class {
     });
     return this.request(`/api/blueprints?${params}`);
   }
+  async createBlueprint(data) {
+    return this.request("/api/v1/blueprints", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateBlueprint(id, data) {
+    const apiId = id.startsWith("bp_") ? id : `bp_${id}`;
+    return this.request(`/api/v1/blueprints/${apiId}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
 };
 var ApiRequestError = class extends Error {
   constructor(message, statusCode, response) {
@@ -408,67 +421,319 @@ function handleApiError(error) {
 import chalk5 from "chalk";
 import ora4 from "ora";
 import prompts from "prompts";
-import { writeFile, access, mkdir } from "fs/promises";
+import { writeFile as writeFile2, mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
+import { join as join2, dirname as dirname2 } from "path";
+import { existsSync } from "fs";
+
+// src/utils/blueprint-tracker.ts
+import { readFile, writeFile, mkdir, access } from "fs/promises";
 import { join, dirname } from "path";
+import { createHash } from "crypto";
+import * as yaml from "yaml";
+var BLUEPRINTS_FILE = ".lynxprompt/blueprints.yml";
+function calculateChecksum(content) {
+  return createHash("sha256").update(content).digest("hex").substring(0, 16);
+}
+async function loadBlueprints(cwd) {
+  const filePath = join(cwd, BLUEPRINTS_FILE);
+  try {
+    await access(filePath);
+    const content = await readFile(filePath, "utf-8");
+    const config2 = yaml.parse(content);
+    return config2 || { version: "1", blueprints: [] };
+  } catch {
+    return { version: "1", blueprints: [] };
+  }
+}
+async function saveBlueprints(cwd, config2) {
+  const filePath = join(cwd, BLUEPRINTS_FILE);
+  const dir = dirname(filePath);
+  await mkdir(dir, { recursive: true });
+  const content = yaml.stringify(config2, {
+    lineWidth: 0,
+    singleQuote: false
+  });
+  await writeFile(filePath, content, "utf-8");
+}
+async function trackBlueprint(cwd, blueprint) {
+  const config2 = await loadBlueprints(cwd);
+  config2.blueprints = config2.blueprints.filter((b) => b.file !== blueprint.file);
+  const editable = blueprint.source !== "marketplace";
+  const canPull = true;
+  config2.blueprints.push({
+    id: blueprint.id,
+    source: blueprint.source,
+    file: blueprint.file,
+    name: blueprint.name,
+    pulledAt: (/* @__PURE__ */ new Date()).toISOString(),
+    checksum: calculateChecksum(blueprint.content),
+    version: blueprint.version,
+    editable,
+    canPull
+  });
+  await saveBlueprints(cwd, config2);
+}
+async function findBlueprintByFile(cwd, file) {
+  const config2 = await loadBlueprints(cwd);
+  return config2.blueprints.find((b) => b.file === file) || null;
+}
+async function hasLocalChanges(cwd, tracked) {
+  try {
+    const filePath = join(cwd, tracked.file);
+    const content = await readFile(filePath, "utf-8");
+    const currentChecksum = calculateChecksum(content);
+    return currentChecksum !== tracked.checksum;
+  } catch {
+    return false;
+  }
+}
+async function updateChecksum(cwd, file, content) {
+  const config2 = await loadBlueprints(cwd);
+  const blueprint = config2.blueprints.find((b) => b.file === file);
+  if (blueprint) {
+    blueprint.checksum = calculateChecksum(content);
+    blueprint.pulledAt = (/* @__PURE__ */ new Date()).toISOString();
+    await saveBlueprints(cwd, config2);
+  }
+}
+async function untrackBlueprint(cwd, file) {
+  const config2 = await loadBlueprints(cwd);
+  const initialCount = config2.blueprints.length;
+  config2.blueprints = config2.blueprints.filter((b) => b.file !== file);
+  if (config2.blueprints.length < initialCount) {
+    await saveBlueprints(cwd, config2);
+    return true;
+  }
+  return false;
+}
+async function linkBlueprint(cwd, file, blueprintId, blueprintName, source) {
+  try {
+    const filePath = join(cwd, file);
+    const content = await readFile(filePath, "utf-8");
+    await trackBlueprint(cwd, {
+      id: blueprintId,
+      name: blueprintName,
+      file,
+      content,
+      source
+    });
+  } catch (error) {
+    throw new Error(`Could not read file ${file} to link`);
+  }
+}
+async function checkSyncStatus(cwd) {
+  const config2 = await loadBlueprints(cwd);
+  const results = [];
+  for (const blueprint of config2.blueprints) {
+    const filePath = join(cwd, blueprint.file);
+    let fileExists2 = false;
+    let localModified = false;
+    try {
+      await access(filePath);
+      fileExists2 = true;
+      localModified = await hasLocalChanges(cwd, blueprint);
+    } catch {
+      fileExists2 = false;
+    }
+    results.push({ blueprint, localModified, fileExists: fileExists2 });
+  }
+  return results;
+}
+
+// src/commands/pull.ts
 var TYPE_TO_FILENAME = {
   AGENTS_MD: "AGENTS.md",
-  CURSOR_RULES: ".cursorrules",
+  CURSOR_RULES: ".cursor/rules/project.mdc",
   COPILOT_INSTRUCTIONS: ".github/copilot-instructions.md",
   WINDSURF_RULES: ".windsurfrules",
   ZED_INSTRUCTIONS: ".zed/instructions.md",
   CLAUDE_MD: "CLAUDE.md",
   GENERIC: "ai-config.md"
 };
+function getSourceFromVisibility(visibility) {
+  switch (visibility) {
+    case "PUBLIC":
+      return "marketplace";
+    case "TEAM":
+      return "team";
+    case "PRIVATE":
+      return "private";
+    default:
+      return "marketplace";
+  }
+}
 async function pullCommand(id, options) {
   if (!isAuthenticated()) {
     console.log(
-      chalk5.yellow("Not logged in. Run 'lynxprompt login' to authenticate.")
+      chalk5.yellow("Not logged in. Run 'lynxp login' to authenticate.")
     );
     process.exit(1);
   }
+  const cwd = process.cwd();
   const spinner = ora4(`Fetching blueprint ${chalk5.cyan(id)}...`).start();
   try {
     const { blueprint } = await api.getBlueprint(id);
     spinner.stop();
     if (!blueprint.content) {
-      console.error(chalk5.red("Blueprint has no content."));
+      console.error(chalk5.red("\u2717 Blueprint has no content."));
       process.exit(1);
     }
+    const source = getSourceFromVisibility(blueprint.visibility);
+    const isMarketplace = source === "marketplace";
+    console.log();
+    console.log(chalk5.cyan(`\u{1F431} Blueprint: ${chalk5.bold(blueprint.name)}`));
+    if (blueprint.description) {
+      console.log(chalk5.gray(`   ${blueprint.description}`));
+    }
+    console.log(chalk5.gray(`   Type: ${blueprint.type} \u2022 Tier: ${blueprint.tier} \u2022 Visibility: ${blueprint.visibility}`));
+    if (isMarketplace) {
+      console.log(chalk5.yellow(`   \u{1F4E6} Marketplace blueprint (read-only - changes won't sync back)`));
+    } else if (source === "team") {
+      console.log(chalk5.blue(`   \u{1F465} Team blueprint (can sync changes)`));
+    } else if (source === "private") {
+      console.log(chalk5.green(`   \u{1F512} Private blueprint (can sync changes)`));
+    }
+    console.log();
+    if (options.preview) {
+      console.log(chalk5.gray("\u2500".repeat(60)));
+      console.log();
+      const lines = blueprint.content.split("\n");
+      const previewLines = lines.slice(0, 50);
+      for (const line of previewLines) {
+        if (line.startsWith("#")) {
+          console.log(chalk5.cyan(line));
+        } else if (line.startsWith(">")) {
+          console.log(chalk5.gray(line));
+        } else if (line.startsWith("- ") || line.startsWith("* ")) {
+          console.log(chalk5.white(line));
+        } else if (line.startsWith("```")) {
+          console.log(chalk5.yellow(line));
+        } else {
+          console.log(line);
+        }
+      }
+      if (lines.length > 50) {
+        console.log();
+        console.log(chalk5.gray(`... ${lines.length - 50} more lines`));
+      }
+      console.log();
+      console.log(chalk5.gray("\u2500".repeat(60)));
+      console.log();
+      console.log(chalk5.gray("Run without --preview to download this blueprint."));
+      return;
+    }
     const filename = TYPE_TO_FILENAME[blueprint.type] || "ai-config.md";
-    const outputPath = join(options.output, filename);
-    let fileExists2 = false;
-    try {
-      await access(outputPath);
-      fileExists2 = true;
-    } catch {
+    const outputPath = join2(options.output, filename);
+    let localContent = null;
+    if (existsSync(outputPath)) {
+      try {
+        localContent = await readFile2(outputPath, "utf-8");
+      } catch {
+      }
     }
-    if (fileExists2 && !options.yes) {
+    const existingTracked = await findBlueprintByFile(cwd, filename);
+    if (existingTracked && existingTracked.id !== id) {
+      console.log(chalk5.yellow(`\u26A0 This file is already linked to a different blueprint: ${existingTracked.id}`));
+      if (!options.yes) {
+        const { proceed } = await prompts({
+          type: "confirm",
+          name: "proceed",
+          message: "Replace the link with the new blueprint?",
+          initial: false
+        });
+        if (!proceed) {
+          console.log(chalk5.gray("Cancelled."));
+          return;
+        }
+      }
+    }
+    if (localContent && !options.yes) {
+      const localLines = localContent.split("\n").length;
+      const remoteLines = blueprint.content.split("\n").length;
+      console.log(chalk5.yellow(`\u26A0 File exists: ${outputPath}`));
+      console.log(chalk5.gray(`   Local:  ${localLines} lines`));
+      console.log(chalk5.gray(`   Remote: ${remoteLines} lines`));
+      console.log();
       const response = await prompts({
-        type: "confirm",
-        name: "overwrite",
-        message: `File ${chalk5.cyan(outputPath)} already exists. Overwrite?`,
-        initial: false
+        type: "select",
+        name: "action",
+        message: "What would you like to do?",
+        choices: [
+          { title: "Overwrite with remote version", value: "overwrite" },
+          { title: "Preview remote content first", value: "preview" },
+          { title: "Cancel", value: "cancel" }
+        ]
       });
-      if (!response.overwrite) {
-        console.log(chalk5.yellow("Aborted."));
+      if (response.action === "cancel" || !response.action) {
+        console.log(chalk5.gray("Cancelled."));
         return;
       }
+      if (response.action === "preview") {
+        console.log();
+        console.log(chalk5.gray("\u2500".repeat(60)));
+        console.log();
+        const lines = blueprint.content.split("\n").slice(0, 30);
+        for (const line of lines) {
+          if (line.startsWith("#")) {
+            console.log(chalk5.cyan(line));
+          } else {
+            console.log(line);
+          }
+        }
+        if (blueprint.content.split("\n").length > 30) {
+          console.log(chalk5.gray(`... ${blueprint.content.split("\n").length - 30} more lines`));
+        }
+        console.log();
+        console.log(chalk5.gray("\u2500".repeat(60)));
+        console.log();
+        const confirmResponse = await prompts({
+          type: "confirm",
+          name: "confirm",
+          message: "Download and overwrite local file?",
+          initial: false
+        });
+        if (!confirmResponse.confirm) {
+          console.log(chalk5.gray("Cancelled."));
+          return;
+        }
+      }
     }
-    const dir = dirname(outputPath);
+    const dir = dirname2(outputPath);
     if (dir !== ".") {
-      await mkdir(dir, { recursive: true });
+      await mkdir2(dir, { recursive: true });
+    }
+    await writeFile2(outputPath, blueprint.content, "utf-8");
+    if (options.track !== false) {
+      await trackBlueprint(cwd, {
+        id: blueprint.id,
+        name: blueprint.name,
+        file: filename,
+        content: blueprint.content,
+        source
+      });
+    }
+    console.log(chalk5.green(`\u2705 Downloaded: ${chalk5.bold(outputPath)}`));
+    if (options.track !== false) {
+      console.log(chalk5.gray(`   Linked to: ${blueprint.id}`));
+      if (isMarketplace) {
+        console.log(chalk5.gray(`   Updates: Run 'lynxp pull ${id}' to sync updates`));
+      } else {
+        console.log(chalk5.gray(`   Sync: Run 'lynxp push ${filename}' to push changes`));
+      }
     }
-    await writeFile(outputPath, blueprint.content, "utf-8");
-    console.log();
-    console.log(chalk5.green(`\u2705 Downloaded ${chalk5.bold(blueprint.name)}`));
-    console.log(`   ${chalk5.gray("File:")} ${chalk5.cyan(outputPath)}`);
-    console.log(`   ${chalk5.gray("Type:")} ${blueprint.type}`);
-    console.log(`   ${chalk5.gray("Tier:")} ${blueprint.tier}`);
     console.log();
     const editorHint = getEditorHint(blueprint.type);
     if (editorHint) {
       console.log(chalk5.gray(`\u{1F4A1} ${editorHint}`));
+      console.log();
     }
+    console.log(chalk5.gray("Tips:"));
+    console.log(chalk5.gray(`  \u2022 Run 'lynxp status' to see tracked blueprints`));
+    console.log(chalk5.gray(`  \u2022 Run 'lynxp diff ${id}' to see changes between local and remote`));
+    if (isMarketplace) {
+      console.log(chalk5.gray(`  \u2022 Run 'lynxp unlink ${filename}' to disconnect and make editable`));
+    }
+    console.log();
   } catch (error) {
     spinner.fail("Failed to pull blueprint");
     handleApiError2(error);
@@ -496,175 +761,1208 @@ function handleApiError2(error) {
   if (error instanceof ApiRequestError) {
     if (error.statusCode === 401) {
       console.error(
-        chalk5.red("Your session has expired. Please run 'lynxprompt login' again.")
+        chalk5.red("\u2717 Your session has expired. Please run 'lynxp login' again.")
       );
     } else if (error.statusCode === 403) {
       console.error(
-        chalk5.red("You don't have access to this blueprint.")
+        chalk5.red("\u2717 You don't have access to this blueprint.")
       );
       console.error(
         chalk5.gray(
-          "This might be a private blueprint or require a higher subscription tier."
+          "  This might be a private blueprint or require a higher subscription tier."
         )
       );
     } else if (error.statusCode === 404) {
-      console.error(chalk5.red("Blueprint not found."));
+      console.error(chalk5.red("\u2717 Blueprint not found."));
       console.error(
         chalk5.gray(
-          "Make sure you have the correct blueprint ID. Use 'lynxprompt list' to see your blueprints."
+          "  Make sure you have the correct blueprint ID. Use 'lynxp list' to see your blueprints."
         )
       );
     } else {
-      console.error(chalk5.red(`Error: ${error.message}`));
+      console.error(chalk5.red(`\u2717 Error: ${error.message}`));
     }
   } else {
-    console.error(chalk5.red("An unexpected error occurred."));
+    console.error(chalk5.red("\u2717 An unexpected error occurred."));
   }
   process.exit(1);
 }
 
-// src/commands/init.ts
+// src/commands/push.ts
 import chalk6 from "chalk";
-import prompts2 from "prompts";
 import ora5 from "ora";
-import { writeFile as writeFile2, mkdir as mkdir2, access as access3 } from "fs/promises";
-import { join as join3, dirname as dirname2 } from "path";
+import fs from "fs";
+import path from "path";
+import prompts2 from "prompts";
+async function pushCommand(fileArg, options) {
+  const cwd = process.cwd();
+  if (!isAuthenticated()) {
+    console.log(chalk6.yellow("You need to be logged in to push blueprints."));
+    console.log(chalk6.gray("Run 'lynxp login' to authenticate."));
+    process.exit(1);
+  }
+  const file = fileArg || findDefaultFile();
+  if (!file) {
+    console.log(chalk6.red("No AI configuration file found."));
+    console.log(
+      chalk6.gray("Specify a file or run in a directory with AGENTS.md, CLAUDE.md, etc.")
+    );
+    process.exit(1);
+  }
+  if (!fs.existsSync(file)) {
+    console.log(chalk6.red(`File not found: ${file}`));
+    process.exit(1);
+  }
+  const content = fs.readFileSync(file, "utf-8");
+  const filename = path.basename(file);
+  const linked = await findBlueprintByFile(cwd, file);
+  if (linked) {
+    await updateBlueprint(cwd, file, linked.id, content, options);
+  } else {
+    await createOrLinkBlueprint(cwd, file, filename, content, options);
+  }
+}
+async function updateBlueprint(cwd, file, blueprintId, content, options) {
+  console.log(chalk6.cyan(`
+\u{1F4E4} Updating blueprint ${chalk6.bold(blueprintId)}...`));
+  console.log(chalk6.gray(`   File: ${file}`));
+  if (!options.yes) {
+    const confirm = await prompts2({
+      type: "confirm",
+      name: "value",
+      message: `Push changes to ${blueprintId}?`,
+      initial: true
+    });
+    if (!confirm.value) {
+      console.log(chalk6.yellow("Push cancelled."));
+      return;
+    }
+  }
+  const spinner = ora5("Pushing changes...").start();
+  try {
+    const result = await api.updateBlueprint(blueprintId, { content });
+    spinner.succeed("Blueprint updated!");
+    await updateChecksum(cwd, file, content);
+    console.log();
+    console.log(chalk6.green(`\u2705 Successfully updated ${chalk6.bold(result.blueprint.name)}`));
+    console.log(chalk6.gray(`   ID: ${blueprintId}`));
+    console.log(chalk6.gray(`   View: https://lynxprompt.com/templates/${blueprintId.replace("bp_", "")}`));
+  } catch (error) {
+    spinner.fail("Failed to update blueprint");
+    handleError(error);
+  }
+}
+async function createOrLinkBlueprint(cwd, file, filename, content, options) {
+  console.log(chalk6.cyan("\n\u{1F4E4} Push new blueprint"));
+  console.log(chalk6.gray(`   File: ${file}`));
+  let name = options.name;
+  let description = options.description;
+  let visibility = options.visibility || "PRIVATE";
+  let tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : [];
+  if (!options.yes) {
+    const responses = await prompts2([
+      {
+        type: name ? null : "text",
+        name: "name",
+        message: "Blueprint name:",
+        initial: filename.replace(/\.(md|mdc|json|yml|yaml)$/, ""),
+        validate: (v) => v.length > 0 || "Name is required"
+      },
+      {
+        type: description ? null : "text",
+        name: "description",
+        message: "Description:",
+        initial: ""
+      },
+      {
+        type: "select",
+        name: "visibility",
+        message: "Visibility:",
+        choices: [
+          { title: "Private (only you)", value: "PRIVATE" },
+          { title: "Team (your team members)", value: "TEAM" },
+          { title: "Public (visible to everyone)", value: "PUBLIC" }
+        ],
+        initial: 0
+      },
+      {
+        type: "text",
+        name: "tags",
+        message: "Tags (comma-separated):",
+        initial: ""
+      }
+    ]);
+    if (!responses.name && !name) {
+      console.log(chalk6.yellow("Push cancelled."));
+      return;
+    }
+    name = name || responses.name;
+    description = description || responses.description || "";
+    visibility = responses.visibility || visibility;
+    tags = responses.tags ? responses.tags.split(",").map((t) => t.trim()).filter(Boolean) : tags;
+  }
+  if (!name) {
+    name = filename.replace(/\.(md|mdc|json|yml|yaml)$/, "");
+  }
+  const spinner = ora5("Creating blueprint...").start();
+  try {
+    const result = await api.createBlueprint({
+      name,
+      description: description || "",
+      content,
+      visibility,
+      tags
+    });
+    spinner.succeed("Blueprint created!");
+    await trackBlueprint(cwd, {
+      id: result.blueprint.id,
+      name: result.blueprint.name,
+      file,
+      content,
+      source: "private"
+    });
+    console.log();
+    console.log(chalk6.green(`\u2705 Created blueprint ${chalk6.bold(result.blueprint.name)}`));
+    console.log(chalk6.gray(`   ID: ${result.blueprint.id}`));
+    console.log(chalk6.gray(`   Visibility: ${visibility}`));
+    if (visibility === "PUBLIC") {
+      console.log(chalk6.gray(`   View: https://lynxprompt.com/templates/${result.blueprint.id.replace("bp_", "")}`));
+    }
+    console.log();
+    console.log(chalk6.cyan("The file is now linked. Future 'lynxp push' will update this blueprint."));
+  } catch (error) {
+    spinner.fail("Failed to create blueprint");
+    handleError(error);
+  }
+}
+function findDefaultFile() {
+  const candidates = [
+    "AGENTS.md",
+    "CLAUDE.md",
+    ".cursor/rules/project.mdc",
+    ".github/copilot-instructions.md",
+    ".windsurfrules",
+    "AIDER.md",
+    "GEMINI.md",
+    ".clinerules"
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function handleError(error) {
+  if (error instanceof ApiRequestError) {
+    console.error(chalk6.red(`Error: ${error.message}`));
+    if (error.statusCode === 401) {
+      console.error(chalk6.gray("Your session may have expired. Run 'lynxp login' to re-authenticate."));
+    } else if (error.statusCode === 403) {
+      console.error(chalk6.gray("You don't have permission to modify this blueprint."));
+    } else if (error.statusCode === 404) {
+      console.error(chalk6.gray("Blueprint not found. It may have been deleted."));
+    }
+  } else {
+    console.error(chalk6.red("An unexpected error occurred."));
+  }
+  process.exit(1);
+}
+
+// src/commands/init.ts
+import chalk7 from "chalk";
+import prompts3 from "prompts";
+import ora6 from "ora";
+import { writeFile as writeFile3, mkdir as mkdir3, readFile as readFile4 } from "fs/promises";
+import { join as join5, dirname as dirname3, basename } from "path";
+import { existsSync as existsSync3 } from "fs";
+import * as yaml2 from "yaml";
+
+// src/utils/agent-detector.ts
+import { existsSync as existsSync2, readdirSync, readFileSync, statSync } from "fs";
+import { join as join3 } from "path";
+
+// src/utils/agents.ts
+var AGENTS = [
+  // === POPULAR AGENTS ===
+  {
+    id: "cursor",
+    name: "Cursor",
+    description: "AI-powered code editor with .cursor/rules/ support",
+    patterns: [".cursor/rules/"],
+    output: ".cursor/rules/",
+    format: "mdc",
+    category: "popular",
+    popular: true
+  },
+  {
+    id: "agents",
+    name: "AGENTS.md",
+    description: "Universal format for Claude Code, GitHub Copilot, Aider, and others",
+    patterns: ["AGENTS.md"],
+    output: "AGENTS.md",
+    format: "markdown",
+    category: "popular",
+    popular: true
+  },
+  {
+    id: "claude",
+    name: "Claude Code",
+    description: "Anthropic's Claude with CLAUDE.md support",
+    patterns: ["CLAUDE.md"],
+    output: "CLAUDE.md",
+    format: "markdown",
+    category: "popular",
+    popular: true
+  },
+  {
+    id: "copilot",
+    name: "GitHub Copilot",
+    description: "GitHub's AI pair programmer",
+    patterns: [".github/copilot-instructions.md"],
+    output: ".github/copilot-instructions.md",
+    format: "markdown",
+    category: "popular",
+    popular: true
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    description: "Codeium's AI IDE with .windsurfrules support",
+    patterns: [".windsurfrules", ".windsurf/rules/"],
+    output: ".windsurfrules",
+    format: "text",
+    category: "popular",
+    popular: true
+  },
+  // === MARKDOWN FORMAT AGENTS ===
+  {
+    id: "gemini",
+    name: "Gemini",
+    description: "Google's Gemini AI assistant",
+    patterns: ["GEMINI.md"],
+    output: "GEMINI.md",
+    format: "markdown",
+    category: "markdown"
+  },
+  {
+    id: "warp",
+    name: "Warp AI",
+    description: "Warp terminal's AI assistant",
+    patterns: ["WARP.md"],
+    output: "WARP.md",
+    format: "markdown",
+    category: "markdown"
+  },
+  {
+    id: "zed",
+    name: "Zed",
+    description: "High-performance code editor with AI features",
+    patterns: [".zed/instructions.md", "ZED.md"],
+    output: ".zed/instructions.md",
+    format: "markdown",
+    category: "markdown"
+  },
+  {
+    id: "crush",
+    name: "Crush",
+    description: "AI coding assistant",
+    patterns: ["CRUSH.md"],
+    output: "CRUSH.md",
+    format: "markdown",
+    category: "markdown"
+  },
+  {
+    id: "junie",
+    name: "Junie",
+    description: "JetBrains' AI coding assistant",
+    patterns: [".junie/guidelines.md"],
+    output: ".junie/guidelines.md",
+    format: "markdown",
+    category: "markdown"
+  },
+  {
+    id: "openhands",
+    name: "OpenHands",
+    description: "Open-source AI coding agent",
+    patterns: [".openhands/microagents/repo.md"],
+    output: ".openhands/microagents/repo.md",
+    format: "markdown",
+    category: "markdown"
+  },
+  // === PLAIN TEXT FORMAT ===
+  {
+    id: "cline",
+    name: "Cline",
+    description: "VS Code AI assistant extension",
+    patterns: [".clinerules"],
+    output: ".clinerules",
+    format: "text",
+    category: "config"
+  },
+  {
+    id: "goose",
+    name: "Goose",
+    description: "Block's AI coding assistant",
+    patterns: [".goosehints"],
+    output: ".goosehints",
+    format: "text",
+    category: "config"
+  },
+  {
+    id: "aider",
+    name: "Aider",
+    description: "AI pair programming in your terminal",
+    patterns: [".aider.conf.yml", "AIDER.md"],
+    output: "AIDER.md",
+    format: "markdown",
+    category: "config"
+  },
+  // === DIRECTORY-BASED AGENTS ===
+  {
+    id: "amazonq",
+    name: "Amazon Q",
+    description: "AWS's AI coding assistant",
+    patterns: [".amazonq/rules/"],
+    output: ".amazonq/rules/",
+    format: "mdc",
+    category: "directory"
+  },
+  {
+    id: "augmentcode",
+    name: "Augment Code",
+    description: "AI code augmentation tool",
+    patterns: [".augment/rules/"],
+    output: ".augment/rules/",
+    format: "mdc",
+    category: "directory"
+  },
+  {
+    id: "kilocode",
+    name: "Kilocode",
+    description: "AI-powered code generation",
+    patterns: [".kilocode/rules/"],
+    output: ".kilocode/rules/",
+    format: "mdc",
+    category: "directory"
+  },
+  {
+    id: "kiro",
+    name: "Kiro",
+    description: "AWS's spec-driven AI coding agent",
+    patterns: [".kiro/steering/"],
+    output: ".kiro/steering/",
+    format: "mdc",
+    category: "directory"
+  },
+  {
+    id: "trae-ai",
+    name: "Trae AI",
+    description: "ByteDance's AI coding assistant",
+    patterns: [".trae/rules/"],
+    output: ".trae/rules/",
+    format: "mdc",
+    category: "directory"
+  },
+  {
+    id: "firebase-studio",
+    name: "Firebase Studio",
+    description: "Google's Firebase development environment",
+    patterns: [".idx/"],
+    output: ".idx/",
+    format: "mdc",
+    category: "directory"
+  },
+  {
+    id: "roocode",
+    name: "Roo Code",
+    description: "AI coding assistant for VS Code",
+    patterns: [".roo/rules/"],
+    output: ".roo/rules/",
+    format: "mdc",
+    category: "directory"
+  },
+  // === JSON/CONFIG FORMAT ===
+  {
+    id: "firebender",
+    name: "Firebender",
+    description: "AI code transformation tool",
+    patterns: ["firebender.json"],
+    output: "firebender.json",
+    format: "json",
+    category: "config"
+  },
+  {
+    id: "opencode",
+    name: "Open Code",
+    description: "Open-source AI coding tool",
+    patterns: ["opencode.json"],
+    output: "opencode.json",
+    format: "json",
+    category: "config"
+  },
+  // === MCP (Model Context Protocol) AGENTS ===
+  {
+    id: "vscode-mcp",
+    name: "VS Code MCP",
+    description: "VS Code with Model Context Protocol",
+    patterns: [".vscode/mcp.json"],
+    output: ".vscode/mcp.json",
+    format: "json",
+    category: "mcp"
+  },
+  {
+    id: "cursor-mcp",
+    name: "Cursor MCP",
+    description: "Cursor with Model Context Protocol",
+    patterns: [".cursor/mcp.json"],
+    output: ".cursor/mcp.json",
+    format: "json",
+    category: "mcp"
+  },
+  {
+    id: "root-mcp",
+    name: "Root MCP",
+    description: "Root-level MCP config for Claude Code, Aider",
+    patterns: [".mcp.json"],
+    output: ".mcp.json",
+    format: "json",
+    category: "mcp"
+  },
+  {
+    id: "windsurf-mcp",
+    name: "Windsurf MCP",
+    description: "Windsurf with Model Context Protocol",
+    patterns: [".windsurf/mcp_config.json"],
+    output: ".windsurf/mcp_config.json",
+    format: "json",
+    category: "mcp"
+  }
+];
+function getAgent(id) {
+  return AGENTS.find((a) => a.id === id);
+}
+function getPopularAgents() {
+  return AGENTS.filter((a) => a.popular);
+}
+function getAgentDisplayName(id) {
+  const agent = getAgent(id);
+  return agent?.name ?? id;
+}
+
+// src/utils/agent-detector.ts
+function detectAgents(cwd = process.cwd()) {
+  const detected = [];
+  for (const agent of AGENTS) {
+    const result = detectAgent(cwd, agent);
+    if (result) {
+      detected.push(result);
+    }
+  }
+  const popularDetected = detected.filter((d) => d.agent.popular);
+  const importable = detected.filter((d) => d.hasContent);
+  let summary;
+  if (detected.length === 0) {
+    summary = "No AI agent configuration files detected";
+  } else if (detected.length === 1) {
+    summary = `Found ${getAgentDisplayName(detected[0].agent.id)} configuration`;
+  } else {
+    const names = detected.slice(0, 3).map((d) => d.agent.name);
+    const more = detected.length > 3 ? ` +${detected.length - 3} more` : "";
+    summary = `Found ${detected.length} agents: ${names.join(", ")}${more}`;
+  }
+  return { detected, popularDetected, importable, summary };
+}
+function detectAgent(cwd, agent) {
+  const files = [];
+  let hasContent = false;
+  let ruleCount = 0;
+  for (const pattern of agent.patterns) {
+    const fullPath = join3(cwd, pattern);
+    if (!existsSync2(fullPath)) {
+      continue;
+    }
+    const stats = statSync(fullPath);
+    if (stats.isDirectory()) {
+      const dirFiles = scanDirectory(fullPath, agent.format);
+      if (dirFiles.length > 0) {
+        files.push(pattern);
+        hasContent = true;
+        ruleCount += dirFiles.reduce((sum, f) => sum + f.sections, 0);
+      }
+    } else if (stats.isFile()) {
+      files.push(pattern);
+      const content = safeReadFile(fullPath);
+      if (content && content.trim().length > 0) {
+        hasContent = true;
+        ruleCount += countSections(content);
+      }
+    }
+  }
+  if (files.length === 0) {
+    return null;
+  }
+  return { agent, files, hasContent, ruleCount };
+}
+function scanDirectory(dirPath, format) {
+  const results = [];
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const name = entry.name.toLowerCase();
+      const isRuleFile = format === "mdc" && name.endsWith(".mdc") || format === "markdown" && name.endsWith(".md") || format === "json" && name.endsWith(".json") || format === "yaml" && (name.endsWith(".yml") || name.endsWith(".yaml"));
+      if (!isRuleFile) continue;
+      const filePath = join3(dirPath, entry.name);
+      const content = safeReadFile(filePath);
+      if (content && content.trim().length > 0) {
+        results.push({
+          path: filePath,
+          sections: countSections(content)
+        });
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function countSections(content) {
+  const headings = content.match(/^#{1,6}\s+.+$/gm);
+  return headings ? headings.length : content.trim().length > 0 ? 1 : 0;
+}
+function safeReadFile(path2) {
+  try {
+    return readFileSync(path2, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function formatDetectionResults(result) {
+  if (result.detected.length === 0) {
+    return "No AI agent configuration files found.\n\nRun 'lynxp wizard' to create your first configuration.";
+  }
+  const lines = [
+    `Found ${result.detected.length} AI agent${result.detected.length === 1 ? "" : "s"}:`,
+    ""
+  ];
+  for (const detected of result.detected) {
+    const icon = detected.hasContent ? "\u2713" : "\u25CB";
+    const rules = detected.ruleCount > 0 ? ` (${detected.ruleCount} sections)` : "";
+    lines.push(`  ${icon} ${detected.agent.name}${rules}`);
+    for (const file of detected.files) {
+      lines.push(`    \u2514\u2500 ${file}`);
+    }
+  }
+  if (result.importable.length > 0) {
+    lines.push("");
+    lines.push(`${result.importable.length} can be imported into LynxPrompt.`);
+  }
+  return lines.join("\n");
+}
 
 // src/utils/detect.ts
-import { readFile, access as access2 } from "fs/promises";
-import { join as join2 } from "path";
+import { readFile as readFile3, access as access3 } from "fs/promises";
+import { join as join4 } from "path";
+var JS_FRAMEWORK_PATTERNS = {
+  nextjs: ["next"],
+  react: ["react", "react-dom"],
+  vue: ["vue"],
+  angular: ["@angular/core"],
+  svelte: ["svelte", "@sveltejs/kit"],
+  solid: ["solid-js"],
+  remix: ["@remix-run/react"],
+  astro: ["astro"],
+  nuxt: ["nuxt"],
+  gatsby: ["gatsby"]
+};
+var JS_TOOL_PATTERNS = {
+  typescript: ["typescript"],
+  tailwind: ["tailwindcss"],
+  prisma: ["prisma", "@prisma/client"],
+  drizzle: ["drizzle-orm"],
+  express: ["express"],
+  fastify: ["fastify"],
+  hono: ["hono"],
+  elysia: ["elysia"],
+  trpc: ["@trpc/server"],
+  graphql: ["graphql", "@apollo/server"],
+  jest: ["jest"],
+  vitest: ["vitest"],
+  playwright: ["@playwright/test"],
+  cypress: ["cypress"],
+  eslint: ["eslint"],
+  biome: ["@biomejs/biome"],
+  prettier: ["prettier"],
+  vite: ["vite"],
+  webpack: ["webpack"],
+  turbo: ["turbo"]
+};
 async function detectProject(cwd) {
   const detected = {
     name: null,
     stack: [],
     commands: {},
-    packageManager: null
+    packageManager: null,
+    type: "unknown"
   };
-  const packageJsonPath = join2(cwd, "package.json");
+  const packageJsonPath = join4(cwd, "package.json");
   if (await fileExists(packageJsonPath)) {
     try {
-      const content = await readFile(packageJsonPath, "utf-8");
+      const content = await readFile3(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       detected.name = pkg.name || null;
+      detected.description = pkg.description;
+      if (pkg.workspaces || await fileExists(join4(cwd, "pnpm-workspace.yaml"))) {
+        detected.type = "monorepo";
+      } else if (pkg.main || pkg.exports) {
+        detected.type = "library";
+      } else {
+        detected.type = "application";
+      }
       const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-      if (allDeps["typescript"]) detected.stack.push("typescript");
-      if (allDeps["react"]) detected.stack.push("react");
-      if (allDeps["next"]) detected.stack.push("nextjs");
-      if (allDeps["vue"]) detected.stack.push("vue");
-      if (allDeps["@angular/core"]) detected.stack.push("angular");
-      if (allDeps["svelte"]) detected.stack.push("svelte");
-      if (allDeps["express"]) detected.stack.push("express");
-      if (allDeps["fastify"]) detected.stack.push("fastify");
-      if (allDeps["prisma"]) detected.stack.push("prisma");
-      if (allDeps["tailwindcss"]) detected.stack.push("tailwind");
+      for (const [framework, deps] of Object.entries(JS_FRAMEWORK_PATTERNS)) {
+        if (deps.some((dep) => allDeps[dep])) {
+          detected.stack.push(framework);
+        }
+      }
+      for (const [tool, deps] of Object.entries(JS_TOOL_PATTERNS)) {
+        if (deps.some((dep) => allDeps[dep])) {
+          detected.stack.push(tool);
+        }
+      }
+      if (detected.stack.length === 0 || detected.stack.length === 1 && detected.stack[0] === "typescript") {
+        detected.stack.unshift("javascript");
+      }
       if (pkg.scripts) {
         detected.commands.build = pkg.scripts.build;
         detected.commands.test = pkg.scripts.test;
-        detected.commands.lint = pkg.scripts.lint;
-        detected.commands.dev = pkg.scripts.dev || pkg.scripts.start;
+        detected.commands.lint = pkg.scripts.lint || pkg.scripts["lint:check"];
+        detected.commands.dev = pkg.scripts.dev || pkg.scripts.start || pkg.scripts.serve;
+        detected.commands.format = pkg.scripts.format || pkg.scripts.prettier;
       }
-      if (await fileExists(join2(cwd, "pnpm-lock.yaml"))) {
+      if (await fileExists(join4(cwd, "pnpm-lock.yaml"))) {
         detected.packageManager = "pnpm";
-      } else if (await fileExists(join2(cwd, "yarn.lock"))) {
+      } else if (await fileExists(join4(cwd, "yarn.lock"))) {
         detected.packageManager = "yarn";
-      } else if (await fileExists(join2(cwd, "bun.lockb"))) {
+      } else if (await fileExists(join4(cwd, "bun.lockb"))) {
         detected.packageManager = "bun";
-      } else if (await fileExists(join2(cwd, "package-lock.json"))) {
+      } else if (await fileExists(join4(cwd, "package-lock.json"))) {
         detected.packageManager = "npm";
       }
+      if (detected.packageManager && detected.packageManager !== "npm") {
+        const pm = detected.packageManager;
+        for (const [key, value] of Object.entries(detected.commands)) {
+          if (value && !value.startsWith(pm) && !value.startsWith("npx")) {
+            detected.commands[key] = `${pm} run ${value}`;
+          }
+        }
+      } else if (detected.commands) {
+        for (const [key, value] of Object.entries(detected.commands)) {
+          if (value && !value.startsWith("npm") && !value.startsWith("npx")) {
+            detected.commands[key] = `npm run ${value}`;
+          }
+        }
+      }
+      if (pkg.scripts) {
+        detected.commands.build = pkg.scripts.build ? "build" : void 0;
+        detected.commands.test = pkg.scripts.test ? "test" : void 0;
+        detected.commands.lint = pkg.scripts.lint ? "lint" : pkg.scripts["lint:check"] ? "lint:check" : void 0;
+        detected.commands.dev = pkg.scripts.dev ? "dev" : pkg.scripts.start ? "start" : pkg.scripts.serve ? "serve" : void 0;
+      }
       return detected;
     } catch {
     }
   }
-  const pyprojectPath = join2(cwd, "pyproject.toml");
+  const pyprojectPath = join4(cwd, "pyproject.toml");
   if (await fileExists(pyprojectPath)) {
     try {
-      const content = await readFile(pyprojectPath, "utf-8");
+      const content = await readFile3(pyprojectPath, "utf-8");
       detected.stack.push("python");
+      detected.type = "application";
       const nameMatch = content.match(/name\s*=\s*"([^"]+)"/);
       if (nameMatch) detected.name = nameMatch[1];
       if (content.includes("fastapi")) detected.stack.push("fastapi");
       if (content.includes("django")) detected.stack.push("django");
       if (content.includes("flask")) detected.stack.push("flask");
+      if (content.includes("pydantic")) detected.stack.push("pydantic");
+      if (content.includes("sqlalchemy")) detected.stack.push("sqlalchemy");
+      if (content.includes("pytest")) detected.stack.push("pytest");
+      if (content.includes("ruff")) detected.stack.push("ruff");
+      if (content.includes("mypy")) detected.stack.push("mypy");
       detected.commands.test = "pytest";
-      detected.commands.lint = "ruff check";
+      detected.commands.lint = "ruff check .";
+      if (content.includes("[tool.poetry]")) {
+        detected.packageManager = "yarn";
+        detected.commands.dev = "poetry run python -m uvicorn main:app --reload";
+      } else if (await fileExists(join4(cwd, "uv.lock"))) {
+        detected.commands.dev = "uv run python main.py";
+      }
       return detected;
     } catch {
     }
   }
-  const requirementsPath = join2(cwd, "requirements.txt");
+  const requirementsPath = join4(cwd, "requirements.txt");
   if (await fileExists(requirementsPath)) {
     try {
-      const content = await readFile(requirementsPath, "utf-8");
+      const content = await readFile3(requirementsPath, "utf-8");
       detected.stack.push("python");
-      if (content.includes("fastapi")) detected.stack.push("fastapi");
-      if (content.includes("django")) detected.stack.push("django");
-      if (content.includes("flask")) detected.stack.push("flask");
+      detected.type = "application";
+      if (content.toLowerCase().includes("fastapi")) detected.stack.push("fastapi");
+      if (content.toLowerCase().includes("django")) detected.stack.push("django");
+      if (content.toLowerCase().includes("flask")) detected.stack.push("flask");
       detected.commands.test = "pytest";
-      detected.commands.lint = "ruff check";
+      detected.commands.lint = "ruff check .";
       return detected;
     } catch {
     }
   }
-  const cargoPath = join2(cwd, "Cargo.toml");
+  const cargoPath = join4(cwd, "Cargo.toml");
   if (await fileExists(cargoPath)) {
     try {
-      const content = await readFile(cargoPath, "utf-8");
+      const content = await readFile3(cargoPath, "utf-8");
       detected.stack.push("rust");
+      detected.type = "application";
       const nameMatch = content.match(/name\s*=\s*"([^"]+)"/);
       if (nameMatch) detected.name = nameMatch[1];
+      if (content.includes("actix-web")) detected.stack.push("actix");
+      if (content.includes("axum")) detected.stack.push("axum");
+      if (content.includes("tokio")) detected.stack.push("tokio");
+      if (content.includes("serde")) detected.stack.push("serde");
+      if (content.includes("sqlx")) detected.stack.push("sqlx");
       detected.commands.build = "cargo build";
       detected.commands.test = "cargo test";
       detected.commands.lint = "cargo clippy";
+      detected.commands.dev = "cargo run";
       return detected;
     } catch {
     }
   }
-  const goModPath = join2(cwd, "go.mod");
+  const goModPath = join4(cwd, "go.mod");
   if (await fileExists(goModPath)) {
     try {
-      const content = await readFile(goModPath, "utf-8");
+      const content = await readFile3(goModPath, "utf-8");
       detected.stack.push("go");
+      detected.type = "application";
       const moduleMatch = content.match(/module\s+(\S+)/);
       if (moduleMatch) {
         const parts = moduleMatch[1].split("/");
         detected.name = parts[parts.length - 1];
       }
+      if (content.includes("gin-gonic/gin")) detected.stack.push("gin");
+      if (content.includes("gofiber/fiber")) detected.stack.push("fiber");
+      if (content.includes("labstack/echo")) detected.stack.push("echo");
+      if (content.includes("gorm.io/gorm")) detected.stack.push("gorm");
       detected.commands.build = "go build";
       detected.commands.test = "go test ./...";
       detected.commands.lint = "golangci-lint run";
+      detected.commands.dev = "go run .";
       return detected;
     } catch {
     }
   }
-  const makefilePath = join2(cwd, "Makefile");
+  const makefilePath = join4(cwd, "Makefile");
   if (await fileExists(makefilePath)) {
     try {
-      const content = await readFile(makefilePath, "utf-8");
+      const content = await readFile3(makefilePath, "utf-8");
       if (content.includes("build:")) detected.commands.build = "make build";
       if (content.includes("test:")) detected.commands.test = "make test";
       if (content.includes("lint:")) detected.commands.lint = "make lint";
+      if (content.includes("dev:")) detected.commands.dev = "make dev";
+      if (content.includes("run:")) detected.commands.dev = detected.commands.dev || "make run";
       if (Object.keys(detected.commands).length > 0) {
+        detected.type = "application";
         return detected;
       }
     } catch {
     }
   }
+  if (await fileExists(join4(cwd, "Dockerfile")) || await fileExists(join4(cwd, "docker-compose.yml"))) {
+    detected.stack.push("docker");
+    detected.type = "application";
+  }
   return detected.stack.length > 0 || detected.name ? detected : null;
 }
-async function fileExists(path) {
+async function fileExists(path2) {
   try {
-    await access2(path);
+    await access3(path2);
     return true;
   } catch {
     return false;
   }
 }
 
+// src/commands/init.ts
+var LYNXPROMPT_DIR = ".lynxprompt";
+var LYNXPROMPT_CONFIG = ".lynxprompt/conf.yml";
+var LYNXPROMPT_RULES = ".lynxprompt/rules";
+var AGENT_FILES = [
+  { name: "AGENTS.md", agent: "Universal (AGENTS.md)" },
+  { name: "CLAUDE.md", agent: "Claude Code" },
+  { name: ".windsurfrules", agent: "Windsurf" },
+  { name: ".clinerules", agent: "Cline" },
+  { name: ".goosehints", agent: "Goose" },
+  { name: "AIDER.md", agent: "Aider" },
+  { name: ".github/copilot-instructions.md", agent: "GitHub Copilot" },
+  { name: ".zed/instructions.md", agent: "Zed" }
+];
+var AGENT_DIRS = [
+  { path: ".cursor/rules", agent: "Cursor" },
+  { path: ".amazonq/rules", agent: "Amazon Q" },
+  { path: ".augment/rules", agent: "Augment Code" }
+];
+async function scanForExistingFiles(cwd) {
+  const detected = [];
+  for (const file of AGENT_FILES) {
+    const filePath = join5(cwd, file.name);
+    if (existsSync3(filePath)) {
+      try {
+        const content = await readFile4(filePath, "utf-8");
+        detected.push({ path: file.name, agent: file.agent, content });
+      } catch {
+        detected.push({ path: file.name, agent: file.agent });
+      }
+    }
+  }
+  for (const dir of AGENT_DIRS) {
+    const dirPath = join5(cwd, dir.path);
+    if (existsSync3(dirPath)) {
+      detected.push({ path: dir.path, agent: dir.agent });
+    }
+  }
+  return detected;
+}
+function createStarterAgentsMd(projectName) {
+  return `# ${projectName} - AI Agent Instructions
+
+> Edit this file to customize how AI agents work with your codebase.
+> This is the source of truth for all AI assistants in this project.
+
+## Project Overview
+
+Describe your project here. What does it do? What are its main features?
+
+## Tech Stack
+
+List the technologies used in this project:
+
+- Language: (e.g., TypeScript, Python, Go)
+- Framework: (e.g., Next.js, FastAPI, Rails)
+- Database: (e.g., PostgreSQL, MongoDB)
+- Other tools: (e.g., Docker, Kubernetes)
+
+## Code Style
+
+Follow these conventions:
+
+- Write clean, readable code
+- Use descriptive variable and function names
+- Keep functions focused and testable
+- Add comments for complex logic only
+
+## Commands
+
+\`\`\`bash
+# Build
+npm run build
+
+# Test
+npm test
+
+# Lint
+npm run lint
+
+# Dev server
+npm run dev
+\`\`\`
+
+## Boundaries
+
+### \u2705 Always (do without asking)
+
+- Read any file in the project
+- Modify files in src/ or lib/
+- Run build, test, and lint commands
+- Create test files
+
+### \u26A0\uFE0F Ask First
+
+- Add new dependencies
+- Modify configuration files
+- Create new modules or directories
+
+### \u{1F6AB} Never
+
+- Modify .env files or secrets
+- Delete critical files without backup
+- Force push to git
+- Expose sensitive information
+
+---
+
+*Managed by [LynxPrompt](https://lynxprompt.com)*
+`;
+}
+function createDefaultConfig(exporters = ["agents"]) {
+  const config2 = {
+    version: "1",
+    exporters,
+    sources: [
+      {
+        type: "local",
+        path: ".lynxprompt/rules"
+      }
+    ]
+  };
+  return yaml2.stringify(config2);
+}
+function createLynxpromptReadme() {
+  return `# .lynxprompt
+
+This directory contains your LynxPrompt configuration and rules.
+
+> **Note**: This is an advanced setup for managing rules across multiple AI editors.
+> Most users should use \`lynxp wizard\` instead for simple, direct file generation.
+
+## Directory structure
+
+- **\`rules/\`** - Your AI rules. Edit files here, then sync to agents.
+- **\`conf.yml\`** - Configuration file (exporters, sources, options)
+
+## Editing rules
+
+Add markdown files to \`rules/\`:
+
+\`\`\`markdown
+# My Rule
+
+Description of what this rule does...
+\`\`\`
+
+## Syncing
+
+After editing rules, run:
+
+\`\`\`bash
+lynxp sync
+\`\`\`
+
+This exports your rules to the configured agent formats (AGENTS.md, .cursor/rules/, etc.)
+
+## More information
+
+- Docs: https://lynxprompt.com/docs/cli
+- Support: https://lynxprompt.com/support
+`;
+}
+async function initCommand(options) {
+  console.log();
+  console.log(chalk7.cyan("\u{1F431} LynxPrompt Init"));
+  console.log(chalk7.gray("Advanced mode: Multi-editor rule management"));
+  console.log();
+  if (!options.yes && !options.force) {
+    console.log(chalk7.yellow("\u{1F4A1} Tip: Most users should use 'lynxp wizard' instead."));
+    console.log(chalk7.gray("   The wizard generates files directly without the .lynxprompt/ folder."));
+    console.log();
+    const { proceed } = await prompts3({
+      type: "confirm",
+      name: "proceed",
+      message: "Continue with advanced setup?",
+      initial: false
+    });
+    if (!proceed) {
+      console.log();
+      console.log(chalk7.gray("Run 'lynxp wizard' for simple file generation."));
+      return;
+    }
+    console.log();
+  }
+  const cwd = process.cwd();
+  const projectName = basename(cwd);
+  const lynxpromptDir = join5(cwd, LYNXPROMPT_DIR);
+  const configPath = join5(cwd, LYNXPROMPT_CONFIG);
+  const rulesDir = join5(cwd, LYNXPROMPT_RULES);
+  if (existsSync3(configPath) && !options.force) {
+    console.log(chalk7.yellow("LynxPrompt is already initialized in this project."));
+    console.log(chalk7.gray(`Config: ${LYNXPROMPT_CONFIG}`));
+    console.log(chalk7.gray(`Rules:  ${LYNXPROMPT_RULES}/`));
+    console.log();
+    console.log(chalk7.gray("Run 'lynxp sync' to export rules to your agents."));
+    console.log(chalk7.gray("Run 'lynxp wizard' to generate new configurations."));
+    return;
+  }
+  const spinner = ora6("Scanning project...").start();
+  const [projectInfo, agentDetection] = await Promise.all([
+    detectProject(cwd),
+    Promise.resolve(detectAgents(cwd))
+  ]);
+  const existingFiles = await scanForExistingFiles(cwd);
+  spinner.stop();
+  if (projectInfo) {
+    console.log(chalk7.green("\u2713 Detected project:"));
+    if (projectInfo.name) console.log(chalk7.gray(`  Name: ${projectInfo.name}`));
+    if (projectInfo.stack.length > 0) console.log(chalk7.gray(`  Stack: ${projectInfo.stack.join(", ")}`));
+    if (projectInfo.packageManager) console.log(chalk7.gray(`  Package manager: ${projectInfo.packageManager}`));
+    console.log();
+  }
+  if (agentDetection.detected.length > 0) {
+    console.log(chalk7.green(`\u2713 Detected ${agentDetection.detected.length} AI agent${agentDetection.detected.length === 1 ? "" : "s"}:`));
+    for (const detected of agentDetection.detected) {
+      const rules = detected.ruleCount > 0 ? chalk7.gray(` (${detected.ruleCount} sections)`) : "";
+      console.log(`  ${chalk7.cyan("\u2022")} ${detected.agent.name}${rules}`);
+    }
+    console.log();
+  }
+  if (existingFiles.length > 0) {
+    console.log(chalk7.green("\u2713 Found existing AI configuration files:"));
+    for (const file of existingFiles) {
+      console.log(`  ${chalk7.cyan(file.path)} ${chalk7.gray(`(${file.agent})`)}`);
+    }
+    console.log();
+    if (!options.yes) {
+      const { action } = await prompts3({
+        type: "select",
+        name: "action",
+        message: "What would you like to do?",
+        choices: [
+          { title: "Import existing files to .lynxprompt/rules/", value: "import" },
+          { title: "Start fresh (keep existing files, create new rules)", value: "fresh" },
+          { title: "Cancel", value: "cancel" }
+        ]
+      });
+      if (action === "cancel" || !action) {
+        console.log(chalk7.gray("Cancelled."));
+        return;
+      }
+      if (action === "import") {
+        await mkdir3(rulesDir, { recursive: true });
+        let importedCount = 0;
+        for (const file of existingFiles) {
+          if (file.content) {
+            const ruleName = file.path.replace(/^\./, "").replace(/\//g, "-").replace(/\.md$/, "") + ".md";
+            const rulePath = join5(rulesDir, ruleName);
+            await writeFile3(rulePath, file.content, "utf-8");
+            console.log(chalk7.gray(`  Imported: ${file.path} \u2192 .lynxprompt/rules/${ruleName}`));
+            importedCount++;
+          }
+        }
+        if (importedCount === 0) {
+          const starterPath = join5(rulesDir, "agents.md");
+          await writeFile3(starterPath, createStarterAgentsMd(projectName), "utf-8");
+          console.log(chalk7.gray("  Created starter: .lynxprompt/rules/agents.md"));
+        }
+      } else {
+        await mkdir3(rulesDir, { recursive: true });
+        const starterPath = join5(rulesDir, "agents.md");
+        await writeFile3(starterPath, createStarterAgentsMd(projectName), "utf-8");
+        console.log(chalk7.gray("Created starter: .lynxprompt/rules/agents.md"));
+      }
+    } else {
+      await mkdir3(rulesDir, { recursive: true });
+      for (const file of existingFiles) {
+        if (file.content) {
+          const ruleName = file.path.replace(/^\./, "").replace(/\//g, "-").replace(/\.md$/, "") + ".md";
+          const rulePath = join5(rulesDir, ruleName);
+          await writeFile3(rulePath, file.content, "utf-8");
+        }
+      }
+    }
+  } else {
+    console.log(chalk7.gray("No existing AI configuration files found."));
+    console.log();
+    if (!options.yes) {
+      const { create } = await prompts3({
+        type: "confirm",
+        name: "create",
+        message: "Create a starter template?",
+        initial: true
+      });
+      if (!create) {
+        console.log(chalk7.gray("Cancelled."));
+        return;
+      }
+    }
+    await mkdir3(rulesDir, { recursive: true });
+    const starterPath = join5(rulesDir, "agents.md");
+    await writeFile3(starterPath, createStarterAgentsMd(projectName), "utf-8");
+    console.log(chalk7.gray("Created: .lynxprompt/rules/agents.md"));
+  }
+  let exporters = [];
+  if (agentDetection.detected.length > 0) {
+    exporters = agentDetection.detected.map((d) => d.agent.id);
+    if (agentDetection.detected.length > 3 && !options.yes) {
+      const { selected } = await prompts3({
+        type: "multiselect",
+        name: "selected",
+        message: "Select agents to enable:",
+        choices: agentDetection.detected.map((d) => ({
+          title: d.agent.name,
+          value: d.agent.id,
+          selected: true
+        })),
+        hint: "- Space to toggle, Enter to confirm"
+      });
+      if (selected && selected.length > 0) {
+        exporters = selected;
+      }
+    }
+  } else {
+    exporters = ["agents"];
+    if (!options.yes) {
+      const popular = getPopularAgents();
+      const { selected } = await prompts3({
+        type: "multiselect",
+        name: "selected",
+        message: "Select AI agents to sync to:",
+        choices: popular.map((a) => ({
+          title: `${a.name} - ${a.description}`,
+          value: a.id,
+          selected: a.id === "agents"
+          // Default select AGENTS.md
+        })),
+        hint: "- Space to toggle, Enter to confirm"
+      });
+      if (selected && selected.length > 0) {
+        exporters = selected;
+      }
+    }
+  }
+  console.log(chalk7.gray(`Enabling ${exporters.length} exporter${exporters.length === 1 ? "" : "s"}: ${exporters.join(", ")}`));
+  await mkdir3(dirname3(configPath), { recursive: true });
+  await writeFile3(configPath, createDefaultConfig(exporters), "utf-8");
+  const readmePath = join5(lynxpromptDir, "README.md");
+  await writeFile3(readmePath, createLynxpromptReadme(), "utf-8");
+  const gitignorePath = join5(lynxpromptDir, ".gitignore");
+  const gitignoreContent = `# Local state files
+.cache/
+.backups/
+`;
+  await writeFile3(gitignorePath, gitignoreContent, "utf-8");
+  console.log();
+  console.log(chalk7.green("\u2705 LynxPrompt initialized!"));
+  console.log();
+  console.log(chalk7.gray("Created:"));
+  console.log(chalk7.gray(`  ${LYNXPROMPT_CONFIG} - Configuration`));
+  console.log(chalk7.gray(`  ${LYNXPROMPT_RULES}/ - Your rules (edit here)`));
+  console.log();
+  console.log(chalk7.cyan("Next steps:"));
+  console.log(chalk7.gray("  1. Edit your rules in .lynxprompt/rules/"));
+  console.log(chalk7.gray("  2. Run 'lynxp sync' to export to your AI agents"));
+  console.log(chalk7.gray("  3. Or run 'lynxp agents' to manage which agents to sync to"));
+  console.log();
+}
+
+// src/commands/wizard.ts
+import chalk8 from "chalk";
+import prompts4 from "prompts";
+import ora7 from "ora";
+import { writeFile as writeFile4, mkdir as mkdir4, access as access5 } from "fs/promises";
+import { join as join6, dirname as dirname4 } from "path";
+
 // src/utils/generator.ts
 var PLATFORM_FILES = {
-  cursor: ".cursorrules",
-  claude: "AGENTS.md",
+  agents: "AGENTS.md",
+  cursor: ".cursor/rules/project.mdc",
+  claude: "CLAUDE.md",
   copilot: ".github/copilot-instructions.md",
   windsurf: ".windsurfrules",
   zed: ".zed/instructions.md"
@@ -774,13 +2072,25 @@ function generateConfig(options) {
 }
 function generateFileContent(options, platform) {
   const sections = [];
-  const isMarkdown = platform !== "cursor" && platform !== "windsurf";
+  const isMdc = platform === "cursor";
+  const isPlainText = platform === "windsurf";
+  const isMarkdown = !isMdc && !isPlainText;
+  if (isMdc) {
+    sections.push("---");
+    sections.push(`description: "${options.name} - AI coding rules"`);
+    sections.push('globs: ["**/*"]');
+    sections.push("alwaysApply: true");
+    sections.push("---");
+    sections.push("");
+    sections.push(`# ${options.name} - AI Assistant Configuration`);
+    sections.push("");
+  }
   if (isMarkdown) {
     sections.push(`# ${options.name} - AI Assistant Configuration`);
     sections.push("");
   }
   const personaDesc = PERSONA_DESCRIPTIONS[options.persona] || options.persona;
-  if (isMarkdown) {
+  if (isMarkdown || isMdc) {
     sections.push("## Persona");
     sections.push("");
     sections.push(`You are ${personaDesc}. You assist developers working on ${options.name}.`);
@@ -793,14 +2103,14 @@ function generateFileContent(options, platform) {
   }
   sections.push("");
   if (options.stack.length > 0) {
-    if (isMarkdown) {
+    if (isMarkdown || isMdc) {
       sections.push("## Tech Stack");
       sections.push("");
     } else {
       sections.push("Tech Stack:");
     }
     const stackList = options.stack.map((s) => STACK_NAMES[s] || s);
-    if (isMarkdown) {
+    if (isMarkdown || isMdc) {
       for (const tech of stackList) {
         sections.push(`- ${tech}`);
       }
@@ -811,7 +2121,7 @@ function generateFileContent(options, platform) {
   }
   const hasCommands = Object.values(options.commands).some(Boolean);
   if (hasCommands) {
-    if (isMarkdown) {
+    if (isMarkdown || isMdc) {
       sections.push("## Commands");
       sections.push("");
       sections.push("Use these commands for common tasks:");
@@ -821,25 +2131,25 @@ function generateFileContent(options, platform) {
       sections.push("Commands:");
     }
     if (options.commands.build) {
-      sections.push(isMarkdown ? `# Build: ${options.commands.build}` : `- Build: ${options.commands.build}`);
+      sections.push(isMarkdown || isMdc ? `# Build: ${options.commands.build}` : `- Build: ${options.commands.build}`);
     }
     if (options.commands.test) {
-      sections.push(isMarkdown ? `# Test: ${options.commands.test}` : `- Test: ${options.commands.test}`);
+      sections.push(isMarkdown || isMdc ? `# Test: ${options.commands.test}` : `- Test: ${options.commands.test}`);
     }
     if (options.commands.lint) {
-      sections.push(isMarkdown ? `# Lint: ${options.commands.lint}` : `- Lint: ${options.commands.lint}`);
+      sections.push(isMarkdown || isMdc ? `# Lint: ${options.commands.lint}` : `- Lint: ${options.commands.lint}`);
     }
     if (options.commands.dev) {
-      sections.push(isMarkdown ? `# Dev: ${options.commands.dev}` : `- Dev: ${options.commands.dev}`);
+      sections.push(isMarkdown || isMdc ? `# Dev: ${options.commands.dev}` : `- Dev: ${options.commands.dev}`);
     }
-    if (isMarkdown) {
+    if (isMarkdown || isMdc) {
       sections.push("```");
     }
     sections.push("");
   }
   const boundaries = BOUNDARIES[options.boundaries];
   if (boundaries) {
-    if (isMarkdown) {
+    if (isMarkdown || isMdc) {
       sections.push("## Boundaries");
       sections.push("");
       sections.push("### \u2705 Always (do without asking)");
@@ -879,7 +2189,7 @@ function generateFileContent(options, platform) {
     }
     sections.push("");
   }
-  if (isMarkdown) {
+  if (isMarkdown || isMdc) {
     sections.push("## Code Style");
     sections.push("");
     sections.push("Follow these conventions:");
@@ -915,7 +2225,7 @@ function generateFileContent(options, platform) {
     sections.push("- Keep functions focused and testable");
     sections.push("");
   }
-  if (isMarkdown) {
+  if (isMarkdown || isMdc) {
     sections.push("---");
     sections.push("");
     sections.push(`*Generated by [LynxPrompt](https://lynxprompt.com) CLI*`);
@@ -923,7 +2233,25 @@ function generateFileContent(options, platform) {
   return sections.join("\n");
 }
 
-// src/commands/init.ts
+// src/commands/wizard.ts
+var OUTPUT_FORMATS = [
+  {
+    title: "AGENTS.md (Universal)",
+    value: "agents",
+    description: "Works with Claude Code, GitHub Copilot, Aider, and most AI editors",
+    recommended: true
+  },
+  {
+    title: "Cursor (.cursor/rules/)",
+    value: "cursor",
+    description: "Cursor IDE with MDC format"
+  },
+  {
+    title: "Multiple formats",
+    value: "multiple",
+    description: "Select multiple AI editors to generate for"
+  }
+];
 var TECH_STACKS = [
   { title: "TypeScript", value: "typescript" },
   { title: "JavaScript", value: "javascript" },
@@ -951,22 +2279,30 @@ var FRAMEWORKS = [
   { title: "Laravel", value: "laravel" }
 ];
 var PLATFORMS = [
-  { title: "Cursor (.cursorrules)", value: "cursor", filename: ".cursorrules" },
-  { title: "Claude Code (AGENTS.md)", value: "claude", filename: "AGENTS.md" },
+  { title: "AGENTS.md (Universal)", value: "agents", filename: "AGENTS.md" },
+  { title: "Cursor (.cursor/rules/)", value: "cursor", filename: ".cursor/rules/project.mdc" },
+  { title: "Claude Code (CLAUDE.md)", value: "claude", filename: "CLAUDE.md" },
   { title: "GitHub Copilot", value: "copilot", filename: ".github/copilot-instructions.md" },
   { title: "Windsurf (.windsurfrules)", value: "windsurf", filename: ".windsurfrules" },
   { title: "Zed", value: "zed", filename: ".zed/instructions.md" }
 ];
 var PERSONAS = [
+  { title: "Full-Stack Developer - Complete application setups", value: "fullstack" },
   { title: "Backend Developer - APIs, databases, microservices", value: "backend" },
   { title: "Frontend Developer - UI, components, styling", value: "frontend" },
-  { title: "Full-Stack Developer - Complete application setups", value: "fullstack" },
   { title: "DevOps Engineer - Infrastructure, CI/CD, containers", value: "devops" },
   { title: "Data Engineer - Pipelines, ETL, databases", value: "data" },
   { title: "Security Engineer - Secure code, vulnerabilities", value: "security" },
   { title: "Custom...", value: "custom" }
 ];
 var BOUNDARY_PRESETS = [
+  {
+    title: "Standard - Balance of freedom and safety (recommended)",
+    value: "standard",
+    always: ["Read any file", "Modify files in src/", "Run build/test/lint", "Create test files"],
+    askFirst: ["Add new dependencies", "Modify config files", "Create new modules"],
+    never: ["Delete production data", "Modify .env secrets", "Force push"]
+  },
   {
     title: "Conservative - Ask before most changes",
     value: "conservative",
@@ -974,13 +2310,6 @@ var BOUNDARY_PRESETS = [
     askFirst: ["Modify any file", "Add dependencies", "Create files", "Run tests"],
     never: ["Delete files", "Modify .env", "Push to git"]
   },
-  {
-    title: "Standard - Balance of freedom and safety",
-    value: "standard",
-    always: ["Read any file", "Modify files in src/", "Run build/test/lint", "Create test files"],
-    askFirst: ["Add new dependencies", "Modify config files", "Create new modules"],
-    never: ["Delete production data", "Modify .env secrets", "Force push"]
-  },
   {
     title: "Permissive - AI can modify freely within src/",
     value: "permissive",
@@ -989,26 +2318,36 @@ var BOUNDARY_PRESETS = [
     never: ["Modify .env", "Access external APIs without confirmation"]
   }
 ];
-async function initCommand(options) {
+async function wizardCommand(options) {
   console.log();
-  console.log(chalk6.cyan("\u{1F431} Welcome to LynxPrompt!"));
+  console.log(chalk8.cyan("\u{1F431} LynxPrompt Wizard"));
+  console.log(chalk8.gray("Generate AI IDE configuration in seconds"));
   console.log();
   const detected = await detectProject(process.cwd());
   if (detected) {
-    console.log(chalk6.gray("Detected project configuration:"));
-    if (detected.name) console.log(chalk6.gray(`  Name: ${detected.name}`));
-    if (detected.stack.length > 0) console.log(chalk6.gray(`  Stack: ${detected.stack.join(", ")}`));
-    if (detected.commands.build) console.log(chalk6.gray(`  Build: ${detected.commands.build}`));
-    if (detected.commands.test) console.log(chalk6.gray(`  Test: ${detected.commands.test}`));
+    console.log(chalk8.green("\u2713 Detected project:"));
+    if (detected.name) console.log(chalk8.gray(`  Name: ${detected.name}`));
+    if (detected.stack.length > 0) console.log(chalk8.gray(`  Stack: ${detected.stack.join(", ")}`));
+    if (detected.packageManager) console.log(chalk8.gray(`  Package manager: ${detected.packageManager}`));
+    if (detected.commands.build) console.log(chalk8.gray(`  Build: ${detected.commands.build}`));
+    if (detected.commands.test) console.log(chalk8.gray(`  Test: ${detected.commands.test}`));
     console.log();
   }
   let config2;
   if (options.yes) {
+    let platforms;
+    if (options.format) {
+      platforms = options.format.split(",").map((f) => f.trim());
+    } else if (options.platforms) {
+      platforms = options.platforms.split(",").map((p) => p.trim());
+    } else {
+      platforms = ["agents"];
+    }
     config2 = {
       name: options.name || detected?.name || "my-project",
       description: options.description || "",
       stack: options.stack?.split(",").map((s) => s.trim()) || detected?.stack || [],
-      platforms: options.platforms?.split(",").map((s) => s.trim()) || ["cursor", "claude"],
+      platforms,
       persona: options.persona || "fullstack",
       boundaries: options.boundaries || "standard",
       commands: detected?.commands || {}
@@ -1016,123 +2355,164 @@ async function initCommand(options) {
   } else {
     config2 = await runInteractiveWizard(options, detected);
   }
-  const spinner = ora5("Generating configuration files...").start();
+  const spinner = ora7("Generating configuration...").start();
   try {
     const files = generateConfig(config2);
     spinner.stop();
     console.log();
-    console.log(chalk6.green("\u2705 Generated files:"));
+    console.log(chalk8.green("\u2705 Generated:"));
     for (const [filename, content] of Object.entries(files)) {
-      const outputPath = join3(process.cwd(), filename);
+      const outputPath = join6(process.cwd(), filename);
       let exists = false;
       try {
-        await access3(outputPath);
+        await access5(outputPath);
         exists = true;
       } catch {
       }
       if (exists && !options.yes) {
-        const response = await prompts2({
+        const response = await prompts4({
           type: "confirm",
           name: "overwrite",
           message: `${filename} already exists. Overwrite?`,
           initial: false
         });
         if (!response.overwrite) {
-          console.log(chalk6.yellow(`   Skipped: ${filename}`));
+          console.log(chalk8.yellow(`   Skipped: ${filename}`));
           continue;
         }
       }
-      const dir = dirname2(outputPath);
+      const dir = dirname4(outputPath);
       if (dir !== ".") {
-        await mkdir2(dir, { recursive: true });
+        await mkdir4(dir, { recursive: true });
       }
-      await writeFile2(outputPath, content, "utf-8");
-      console.log(`   ${chalk6.cyan(filename)}`);
+      await writeFile4(outputPath, content, "utf-8");
+      console.log(`   ${chalk8.cyan(filename)}`);
     }
     console.log();
-    console.log(chalk6.gray("Your AI IDE configuration is ready!"));
-    console.log(chalk6.gray("The AI assistant in your IDE will now follow these instructions."));
+    console.log(chalk8.gray("Your AI assistant will now follow these instructions."));
+    console.log();
+    console.log(chalk8.gray("Tips:"));
+    console.log(chalk8.gray("  \u2022 Edit the generated file anytime to customize rules"));
+    console.log(chalk8.gray("  \u2022 Run 'lynxp wizard' again to regenerate"));
+    console.log(chalk8.gray("  \u2022 Run 'lynxp check' to validate your configuration"));
     console.log();
   } catch (error) {
     spinner.fail("Failed to generate files");
-    console.error(chalk6.red("An error occurred while generating configuration files."));
+    console.error(chalk8.red("\n\u2717 An error occurred while generating configuration files."));
     if (error instanceof Error) {
-      console.error(chalk6.gray(error.message));
+      console.error(chalk8.gray(`  ${error.message}`));
     }
+    console.error(chalk8.gray("\nTry running with --yes flag for default settings."));
     process.exit(1);
   }
 }
 async function runInteractiveWizard(options, detected) {
   const answers = {};
-  const nameResponse = await prompts2({
+  let platforms;
+  if (options.format) {
+    platforms = options.format.split(",").map((f) => f.trim());
+  } else {
+    const formatResponse = await prompts4({
+      type: "select",
+      name: "format",
+      message: "Select output format:",
+      choices: OUTPUT_FORMATS.map((f) => ({
+        title: f.recommended ? `${f.title} ${chalk8.green("(recommended)")}` : f.title,
+        value: f.value,
+        description: f.description
+      })),
+      initial: 0
+      // AGENTS.md is default
+    });
+    if (formatResponse.format === "multiple") {
+      const platformResponse = await prompts4({
+        type: "multiselect",
+        name: "platforms",
+        message: "Select AI editors:",
+        choices: PLATFORMS.map((p) => ({ title: p.title, value: p.value })),
+        hint: "- Space to select, Enter to confirm",
+        min: 1
+      });
+      platforms = platformResponse.platforms || ["agents"];
+    } else {
+      platforms = [formatResponse.format || "agents"];
+    }
+  }
+  answers.platforms = platforms;
+  const nameResponse = await prompts4({
     type: "text",
     name: "name",
-    message: "What's your project name?",
+    message: "Project name:",
     initial: options.name || detected?.name || "my-project"
   });
-  answers.name = nameResponse.name;
-  const descResponse = await prompts2({
+  answers.name = nameResponse.name || "my-project";
+  const descResponse = await prompts4({
     type: "text",
     name: "description",
-    message: "Describe your project in one sentence:",
+    message: "Brief description (optional):",
     initial: options.description || ""
   });
-  answers.description = descResponse.description;
+  answers.description = descResponse.description || "";
   const allStackOptions = [...TECH_STACKS, ...FRAMEWORKS];
-  const stackResponse = await prompts2({
+  const detectedStackSet = new Set(detected?.stack || []);
+  const stackResponse = await prompts4({
     type: "multiselect",
     name: "stack",
-    message: "Select your tech stack:",
-    choices: allStackOptions,
+    message: "Tech stack:",
+    choices: allStackOptions.map((s) => ({
+      title: s.title,
+      value: s.value,
+      selected: detectedStackSet.has(s.value)
+    })),
     hint: "- Space to select, Enter to confirm"
   });
   answers.stack = stackResponse.stack || [];
-  const platformResponse = await prompts2({
-    type: "multiselect",
-    name: "platforms",
-    message: "Which AI IDEs do you use?",
-    choices: PLATFORMS,
-    hint: "- Space to select, Enter to confirm",
-    min: 1
-  });
-  answers.platforms = platformResponse.platforms || ["cursor"];
-  const personaResponse = await prompts2({
+  const personaResponse = await prompts4({
     type: "select",
     name: "persona",
-    message: "What's the AI's persona/role?",
+    message: "AI persona:",
     choices: PERSONAS,
-    initial: 2
+    initial: 0
     // Full-stack by default
   });
   if (personaResponse.persona === "custom") {
-    const customPersona = await prompts2({
+    const customPersona = await prompts4({
       type: "text",
       name: "value",
       message: "Describe the custom persona:"
     });
     answers.persona = customPersona.value || "fullstack";
   } else {
-    answers.persona = personaResponse.persona;
+    answers.persona = personaResponse.persona || "fullstack";
   }
+  const boundaryResponse = await prompts4({
+    type: "select",
+    name: "boundaries",
+    message: "AI boundaries:",
+    choices: BOUNDARY_PRESETS.map((b) => ({ title: b.title, value: b.value })),
+    initial: 0
+    // Standard by default
+  });
+  answers.boundaries = boundaryResponse.boundaries || "standard";
   if (detected?.commands && Object.keys(detected.commands).length > 0) {
     console.log();
-    console.log(chalk6.gray("Auto-detected commands:"));
-    if (detected.commands.build) console.log(chalk6.gray(`  Build: ${detected.commands.build}`));
-    if (detected.commands.test) console.log(chalk6.gray(`  Test: ${detected.commands.test}`));
-    if (detected.commands.lint) console.log(chalk6.gray(`  Lint: ${detected.commands.lint}`));
-    if (detected.commands.dev) console.log(chalk6.gray(`  Dev: ${detected.commands.dev}`));
-    const editCommands = await prompts2({
+    console.log(chalk8.gray("Auto-detected commands:"));
+    if (detected.commands.build) console.log(chalk8.gray(`  Build: ${detected.commands.build}`));
+    if (detected.commands.test) console.log(chalk8.gray(`  Test: ${detected.commands.test}`));
+    if (detected.commands.lint) console.log(chalk8.gray(`  Lint: ${detected.commands.lint}`));
+    if (detected.commands.dev) console.log(chalk8.gray(`  Dev: ${detected.commands.dev}`));
+    const editCommands = await prompts4({
       type: "confirm",
       name: "edit",
-      message: "Edit these commands?",
+      message: "Edit commands?",
       initial: false
     });
     if (editCommands.edit) {
-      const commandsResponse = await prompts2([
-        { type: "text", name: "build", message: "Build command:", initial: detected.commands.build },
-        { type: "text", name: "test", message: "Test command:", initial: detected.commands.test },
-        { type: "text", name: "lint", message: "Lint command:", initial: detected.commands.lint },
-        { type: "text", name: "dev", message: "Dev command:", initial: detected.commands.dev }
+      const commandsResponse = await prompts4([
+        { type: "text", name: "build", message: "Build:", initial: detected.commands.build },
+        { type: "text", name: "test", message: "Test:", initial: detected.commands.test },
+        { type: "text", name: "lint", message: "Lint:", initial: detected.commands.lint },
+        { type: "text", name: "dev", message: "Dev:", initial: detected.commands.dev }
       ]);
       answers.commands = commandsResponse;
     } else {
@@ -1141,15 +2521,6 @@ async function runInteractiveWizard(options, detected) {
   } else {
     answers.commands = {};
   }
-  const boundaryResponse = await prompts2({
-    type: "select",
-    name: "boundaries",
-    message: "Select boundary preset:",
-    choices: BOUNDARY_PRESETS.map((b) => ({ title: b.title, value: b.value })),
-    initial: 1
-    // Standard by default
-  });
-  answers.boundaries = boundaryResponse.boundaries || "standard";
   return {
     name: answers.name,
     description: answers.description,
@@ -1162,52 +2533,52 @@ async function runInteractiveWizard(options, detected) {
 }
 
 // src/commands/search.ts
-import chalk7 from "chalk";
-import ora6 from "ora";
+import chalk9 from "chalk";
+import ora8 from "ora";
 async function searchCommand(query, options) {
-  const spinner = ora6(`Searching for "${query}"...`).start();
+  const spinner = ora8(`Searching for "${query}"...`).start();
   try {
     const limit = parseInt(options.limit, 10) || 20;
     const { templates, total, hasMore } = await api.searchBlueprints(query, limit);
     spinner.stop();
     if (templates.length === 0) {
       console.log();
-      console.log(chalk7.yellow(`No blueprints found for "${query}".`));
-      console.log(chalk7.gray("Try different keywords or browse at https://lynxprompt.com/blueprints"));
+      console.log(chalk9.yellow(`No blueprints found for "${query}".`));
+      console.log(chalk9.gray("Try different keywords or browse at https://lynxprompt.com/blueprints"));
       return;
     }
     console.log();
-    console.log(chalk7.cyan(`\u{1F50D} Search Results for "${query}" (${total} found)`));
+    console.log(chalk9.cyan(`\u{1F50D} Search Results for "${query}" (${total} found)`));
     console.log();
     for (const result of templates) {
       printSearchResult(result);
     }
     if (hasMore) {
-      console.log(chalk7.gray(`Showing ${templates.length} of ${total}. Use --limit to see more.`));
+      console.log(chalk9.gray(`Showing ${templates.length} of ${total}. Use --limit to see more.`));
     }
     console.log();
-    console.log(chalk7.gray("Use 'lynxprompt pull <id>' to download a blueprint."));
+    console.log(chalk9.gray("Use 'lynxprompt pull <id>' to download a blueprint."));
   } catch (error) {
     spinner.fail("Search failed");
     handleApiError3(error);
   }
 }
 function printSearchResult(result) {
-  const priceInfo = result.price ? chalk7.yellow(`\u20AC${(result.price / 100).toFixed(2)}`) : chalk7.green("Free");
-  const officialBadge = result.isOfficial ? chalk7.magenta(" \u2605 Official") : "";
-  console.log(`  ${chalk7.bold(result.name)}${officialBadge}`);
-  console.log(`     ${chalk7.cyan(result.id)} \u2022 ${priceInfo}`);
+  const priceInfo = result.price ? chalk9.yellow(`\u20AC${(result.price / 100).toFixed(2)}`) : chalk9.green("Free");
+  const officialBadge = result.isOfficial ? chalk9.magenta(" \u2605 Official") : "";
+  console.log(`  ${chalk9.bold(result.name)}${officialBadge}`);
+  console.log(`     ${chalk9.cyan(result.id)} \u2022 ${priceInfo}`);
   if (result.description) {
-    console.log(`     ${chalk7.gray(truncate2(result.description, 60))}`);
+    console.log(`     ${chalk9.gray(truncate2(result.description, 60))}`);
   }
-  console.log(`     ${chalk7.gray(`by ${result.author}`)} \u2022 ${chalk7.gray(`\u2193${result.downloads}`)} ${chalk7.gray(`\u2665${result.likes}`)}`);
+  console.log(`     ${chalk9.gray(`by ${result.author}`)} \u2022 ${chalk9.gray(`\u2193${result.downloads}`)} ${chalk9.gray(`\u2665${result.likes}`)}`);
   if (result.tags && result.tags.length > 0) {
     console.log(`     ${formatTags2(result.tags)}`);
   }
   console.log();
 }
 function formatTags2(tags) {
-  return tags.slice(0, 4).map((t) => chalk7.gray(`#${t}`)).join(" ");
+  return tags.slice(0, 4).map((t) => chalk9.gray(`#${t}`)).join(" ");
 }
 function truncate2(str, maxLength) {
   if (str.length <= maxLength) return str;
@@ -1215,58 +2586,141 @@ function truncate2(str, maxLength) {
 }
 function handleApiError3(error) {
   if (error instanceof ApiRequestError) {
-    console.error(chalk7.red(`Error: ${error.message}`));
+    console.error(chalk9.red(`Error: ${error.message}`));
   } else {
-    console.error(chalk7.red("An unexpected error occurred."));
+    console.error(chalk9.red("An unexpected error occurred."));
   }
   process.exit(1);
 }
 
 // src/commands/status.ts
-import chalk8 from "chalk";
-import { access as access4, readFile as readFile3 } from "fs/promises";
-import { join as join4 } from "path";
+import chalk10 from "chalk";
+import { access as access6, readFile as readFile6, readdir as readdir3 } from "fs/promises";
+import { join as join7 } from "path";
+import { existsSync as existsSync4 } from "fs";
 var CONFIG_FILES = [
   { path: "AGENTS.md", name: "AGENTS.md", platform: "Claude Code, Cursor, AI Agents" },
   { path: "CLAUDE.md", name: "CLAUDE.md", platform: "Claude Code" },
-  { path: ".cursorrules", name: ".cursorrules", platform: "Cursor" },
   { path: ".github/copilot-instructions.md", name: "Copilot Instructions", platform: "GitHub Copilot" },
   { path: ".windsurfrules", name: ".windsurfrules", platform: "Windsurf" },
-  { path: ".zed/instructions.md", name: "Zed Instructions", platform: "Zed" }
+  { path: ".zed/instructions.md", name: "Zed Instructions", platform: "Zed" },
+  { path: ".clinerules", name: ".clinerules", platform: "Cline" },
+  { path: ".goosehints", name: ".goosehints", platform: "Goose" },
+  { path: "AIDER.md", name: "AIDER.md", platform: "Aider" }
+];
+var CONFIG_DIRS = [
+  { path: ".cursor/rules", name: ".cursor/rules/", platform: "Cursor" },
+  { path: ".amazonq/rules", name: ".amazonq/rules/", platform: "Amazon Q" },
+  { path: ".augment/rules", name: ".augment/rules/", platform: "Augment Code" }
 ];
 async function statusCommand() {
   const cwd = process.cwd();
   console.log();
-  console.log(chalk8.cyan("\u{1F431} AI Config Status"));
-  console.log(chalk8.gray(`   Directory: ${cwd}`));
+  console.log(chalk10.cyan("\u{1F431} LynxPrompt Status"));
+  console.log(chalk10.gray(`   Directory: ${cwd}`));
+  console.log();
+  const lynxpromptExists = existsSync4(join7(cwd, ".lynxprompt"));
+  if (lynxpromptExists) {
+    console.log(chalk10.green("\u2713 LynxPrompt initialized"));
+    const configPath = join7(cwd, ".lynxprompt/conf.yml");
+    if (existsSync4(configPath)) {
+      try {
+        const content = await readFile6(configPath, "utf-8");
+        const { parse: parse5 } = await import("yaml");
+        const config2 = parse5(content);
+        if (config2?.exporters?.length > 0) {
+          console.log(chalk10.gray(`   Exporters: ${config2.exporters.join(", ")}`));
+        }
+      } catch {
+      }
+    }
+    console.log();
+  }
+  const trackedStatus = await checkSyncStatus(cwd);
+  if (trackedStatus.length > 0) {
+    console.log(chalk10.cyan("\u{1F4E6} Tracked Blueprints"));
+    console.log();
+    for (const { blueprint, localModified, fileExists: fileExists2 } of trackedStatus) {
+      const statusIcon = !fileExists2 ? chalk10.red("\u2717") : localModified ? chalk10.yellow("\u25CF") : chalk10.green("\u2713");
+      const sourceLabel = {
+        marketplace: chalk10.gray("[marketplace]"),
+        team: chalk10.blue("[team]"),
+        private: chalk10.green("[private]"),
+        local: chalk10.gray("[local]")
+      }[blueprint.source];
+      console.log(`  ${statusIcon} ${chalk10.bold(blueprint.file)} ${sourceLabel}`);
+      console.log(`     ${chalk10.gray(`ID: ${blueprint.id} \u2022 ${blueprint.name}`)}`);
+      if (!fileExists2) {
+        console.log(chalk10.red(`     \u26A0 File missing - run 'lynxp pull ${blueprint.id}' to restore`));
+      } else if (localModified) {
+        if (blueprint.source === "marketplace") {
+          console.log(chalk10.yellow(`     \u26A0 Local changes (marketplace = read-only, won't sync back)`));
+        } else {
+          console.log(chalk10.yellow(`     \u26A0 Local changes - run 'lynxp push ${blueprint.file}' to sync`));
+        }
+      }
+      console.log();
+    }
+  }
+  console.log(chalk10.cyan("\u{1F4C4} AI Config Files"));
   console.log();
   let foundAny = false;
   for (const config2 of CONFIG_FILES) {
-    const filePath = join4(cwd, config2.path);
+    const filePath = join7(cwd, config2.path);
     try {
-      await access4(filePath);
-      const content = await readFile3(filePath, "utf-8");
+      await access6(filePath);
+      const content = await readFile6(filePath, "utf-8");
       const lines = content.split("\n").length;
       const size = formatBytes(content.length);
       foundAny = true;
-      console.log(`  ${chalk8.green("\u2713")} ${chalk8.bold(config2.name)}`);
-      console.log(`     ${chalk8.gray(`Platform: ${config2.platform}`)}`);
-      console.log(`     ${chalk8.gray(`Size: ${size} (${lines} lines)`)}`);
+      const tracked = trackedStatus.find((t) => t.blueprint.file === config2.path);
+      const trackedLabel = tracked ? chalk10.cyan(" (tracked)") : "";
+      console.log(`  ${chalk10.green("\u2713")} ${chalk10.bold(config2.name)}${trackedLabel}`);
+      console.log(`     ${chalk10.gray(`Platform: ${config2.platform}`)}`);
+      console.log(`     ${chalk10.gray(`Size: ${size} (${lines} lines)`)}`);
       const preview = getPreview(content);
       if (preview) {
-        console.log(`     ${chalk8.gray(`Preview: ${preview}`)}`);
+        console.log(`     ${chalk10.gray(`Preview: ${preview}`)}`);
       }
       console.log();
     } catch {
     }
   }
+  for (const config2 of CONFIG_DIRS) {
+    const dirPath = join7(cwd, config2.path);
+    if (existsSync4(dirPath)) {
+      try {
+        const files = await readdir3(dirPath);
+        const ruleFiles = files.filter((f) => f.endsWith(".md") || f.endsWith(".mdc"));
+        if (ruleFiles.length > 0) {
+          foundAny = true;
+          console.log(`  ${chalk10.green("\u2713")} ${chalk10.bold(config2.name)}`);
+          console.log(`     ${chalk10.gray(`Platform: ${config2.platform}`)}`);
+          console.log(`     ${chalk10.gray(`Rules: ${ruleFiles.length} file${ruleFiles.length === 1 ? "" : "s"}`)}`);
+          for (const file of ruleFiles.slice(0, 3)) {
+            console.log(`     ${chalk10.gray(`  \u2022 ${file}`)}`);
+          }
+          if (ruleFiles.length > 3) {
+            console.log(`     ${chalk10.gray(`  ... and ${ruleFiles.length - 3} more`)}`);
+          }
+          console.log();
+        }
+      } catch {
+      }
+    }
+  }
   if (!foundAny) {
-    console.log(chalk8.yellow("  No AI configuration files found in this directory."));
+    console.log(chalk10.yellow("  No AI configuration files found."));
     console.log();
-    console.log(chalk8.gray("  Run 'lynxprompt init' to create a configuration."));
-    console.log(chalk8.gray("  Or run 'lynxprompt pull <id>' to download an existing blueprint."));
+    console.log(chalk10.gray("  Get started:"));
+    console.log(chalk10.gray("    lynxp wizard          Generate a configuration"));
+    console.log(chalk10.gray("    lynxp pull <id>       Download from marketplace"));
+    console.log(chalk10.gray("    lynxp search <query>  Search for blueprints"));
   } else {
-    console.log(chalk8.gray("Run 'lynxprompt init' to update or create additional configs."));
+    console.log(chalk10.gray("Commands:"));
+    console.log(chalk10.gray("  lynxp wizard     Regenerate configuration"));
+    console.log(chalk10.gray("  lynxp check      Validate files"));
+    console.log(chalk10.gray("  lynxp link --list  Show tracked blueprints"));
   }
   console.log();
 }
@@ -1274,7 +2728,7 @@ function getPreview(content) {
   const lines = content.split("\n");
   for (const line of lines) {
     const trimmed = line.trim();
-    if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("//") && !trimmed.startsWith("<!--")) {
+    if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("//") && !trimmed.startsWith("<!--") && !trimmed.startsWith("---") && !trimmed.startsWith(">")) {
       return truncate3(trimmed, 50);
     }
   }
@@ -1290,34 +2744,1179 @@ function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 
-// src/index.ts
-var program = new Command();
-program.name("lynxprompt").description("CLI for LynxPrompt - Generate AI IDE configuration files").version("0.1.0");
-program.command("login").description("Authenticate with LynxPrompt (opens browser)").action(loginCommand);
-program.command("logout").description("Log out and remove stored credentials").action(logoutCommand);
-program.command("whoami").description("Show current authenticated user").action(whoamiCommand);
-program.command("init").description("Interactive wizard to generate AI IDE configuration").option("-n, --name <name>", "Project name").option("-d, --description <description>", "Project description").option("-s, --stack <stack>", "Tech stack (comma-separated)").option("-p, --platforms <platforms>", "Target platforms (comma-separated)").option("--persona <persona>", "AI persona/role").option("--boundaries <level>", "Boundary preset (conservative, standard, permissive)").option("--preset <preset>", "Use an agent preset (test-agent, docs-agent, etc.)").option("-y, --yes", "Skip prompts and use defaults").action(initCommand);
-program.command("list").description("List your blueprints").option("-l, --limit <number>", "Number of results", "20").option("-v, --visibility <visibility>", "Filter by visibility (PRIVATE, TEAM, PUBLIC, all)").action(listCommand);
-program.command("pull <id>").description("Download a blueprint to the current directory").option("-o, --output <path>", "Output directory", ".").option("-y, --yes", "Overwrite existing files without prompting").action(pullCommand);
-program.command("search <query>").description("Search public blueprints").option("-l, --limit <number>", "Number of results", "20").action(searchCommand);
-program.command("status").description("Show current AI config status in this directory").action(statusCommand);
-program.addHelpText(
-  "beforeAll",
-  `
-${chalk9.cyan("\u{1F431} LynxPrompt CLI")}
-${chalk9.gray("Generate AI IDE configuration files from your terminal")}
-`
-);
-program.addHelpText(
-  "after",
-  `
-${chalk9.gray("Examples:")}
-  ${chalk9.cyan("$ lynxprompt init")}              ${chalk9.gray("Start interactive wizard")}
-  ${chalk9.cyan("$ lynxprompt pull bp_abc123")}    ${chalk9.gray("Download a blueprint")}
-  ${chalk9.cyan("$ lynxprompt list")}              ${chalk9.gray("List your blueprints")}
-  ${chalk9.cyan("$ lynxprompt search nextjs")}     ${chalk9.gray("Search public blueprints")}
+// src/commands/sync.ts
+import chalk11 from "chalk";
+import ora9 from "ora";
+import prompts5 from "prompts";
+import { readFile as readFile7, writeFile as writeFile5, mkdir as mkdir5, readdir as readdir4 } from "fs/promises";
+import { join as join8, dirname as dirname5 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import * as yaml3 from "yaml";
+var CONFIG_FILE = ".lynxprompt/conf.yml";
+var RULES_DIR = ".lynxprompt/rules";
+async function syncCommand(options = {}) {
+  console.log();
+  console.log(chalk11.cyan("\u{1F431} LynxPrompt Sync"));
+  console.log();
+  const cwd = process.cwd();
+  const configPath = join8(cwd, CONFIG_FILE);
+  if (!existsSync5(configPath)) {
+    console.log(chalk11.yellow("LynxPrompt is not initialized in this project."));
+    console.log();
+    console.log(chalk11.gray("Run 'lynxp init' first to set up LynxPrompt."));
+    return;
+  }
+  const spinner = ora9("Loading configuration...").start();
+  let config2;
+  try {
+    const configContent = await readFile7(configPath, "utf-8");
+    config2 = yaml3.parse(configContent);
+    spinner.succeed("Configuration loaded");
+  } catch (error) {
+    spinner.fail("Failed to load configuration");
+    console.log(chalk11.red("Could not parse .lynxprompt/conf.yml"));
+    return;
+  }
+  if (!config2.exporters || config2.exporters.length === 0) {
+    console.log(chalk11.yellow("No exporters configured."));
+    console.log();
+    console.log(chalk11.gray("Add exporters to .lynxprompt/conf.yml or run 'lynxp agents enable <agent>'"));
+    return;
+  }
+  const validExporters = [];
+  const invalidExporters = [];
+  for (const exporterId of config2.exporters) {
+    const agent = getAgent(exporterId);
+    if (agent) {
+      validExporters.push(agent);
+    } else {
+      invalidExporters.push(exporterId);
+    }
+  }
+  if (invalidExporters.length > 0) {
+    console.log(chalk11.yellow(`Unknown exporters: ${invalidExporters.join(", ")}`));
+  }
+  if (validExporters.length === 0) {
+    console.log(chalk11.red("No valid exporters configured."));
+    return;
+  }
+  console.log(chalk11.gray(`Exporters: ${validExporters.map((e) => e.name).join(", ")}`));
+  console.log();
+  const rulesPath = join8(cwd, RULES_DIR);
+  if (!existsSync5(rulesPath)) {
+    console.log(chalk11.yellow("No rules found."));
+    console.log(chalk11.gray(`Create rules in ${RULES_DIR}/ to sync them.`));
+    return;
+  }
+  const rulesContent = await loadRules(rulesPath);
+  if (!rulesContent) {
+    console.log(chalk11.yellow("No rule files found in .lynxprompt/rules/"));
+    return;
+  }
+  console.log(chalk11.gray(`Loaded ${rulesContent.fileCount} rule file${rulesContent.fileCount === 1 ? "" : "s"}`));
+  console.log();
+  if (options.dryRun) {
+    console.log(chalk11.cyan("Dry run - no files will be written"));
+    console.log();
+    console.log("Would write:");
+    for (const exporter of validExporters) {
+      console.log(chalk11.gray(`  ${exporter.output}`));
+    }
+    console.log();
+    return;
+  }
+  if (!options.force) {
+    const { confirm } = await prompts5({
+      type: "confirm",
+      name: "confirm",
+      message: `Sync to ${validExporters.length} agent${validExporters.length === 1 ? "" : "s"}?`,
+      initial: true
+    });
+    if (!confirm) {
+      console.log(chalk11.gray("Cancelled."));
+      return;
+    }
+  }
+  const result = { written: [], skipped: [], errors: [] };
+  const syncSpinner = ora9("Syncing rules...").start();
+  for (const exporter of validExporters) {
+    try {
+      await syncToAgent(cwd, exporter, rulesContent.combined);
+      result.written.push(exporter.output);
+    } catch (error) {
+      result.errors.push(`${exporter.id}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  syncSpinner.stop();
+  if (result.written.length > 0) {
+    console.log(chalk11.green(`\u2713 Synced to ${result.written.length} agent${result.written.length === 1 ? "" : "s"}:`));
+    for (const file of result.written) {
+      console.log(chalk11.gray(`  ${file}`));
+    }
+  }
+  if (result.errors.length > 0) {
+    console.log();
+    console.log(chalk11.red("Errors:"));
+    for (const error of result.errors) {
+      console.log(chalk11.red(`  ${error}`));
+    }
+  }
+  console.log();
+}
+async function loadRules(rulesPath) {
+  const files = [];
+  try {
+    const entries = await readdir4(rulesPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!entry.name.endsWith(".md")) continue;
+      const filePath = join8(rulesPath, entry.name);
+      const content = await readFile7(filePath, "utf-8");
+      if (content.trim()) {
+        files.push({ name: entry.name, content: content.trim() });
+      }
+    }
+  } catch {
+    return null;
+  }
+  if (files.length === 0) {
+    return null;
+  }
+  const combined = files.map((f) => f.content).join("\n\n---\n\n");
+  return { combined, files, fileCount: files.length };
+}
+async function syncToAgent(cwd, agent, content) {
+  const outputPath = join8(cwd, agent.output);
+  if (agent.output.endsWith("/")) {
+    await syncToDirectory(cwd, agent, content);
+    return;
+  }
+  const formatted = formatForAgent(agent, content);
+  const dir = dirname5(outputPath);
+  if (dir !== ".") {
+    await mkdir5(dir, { recursive: true });
+  }
+  await writeFile5(outputPath, formatted, "utf-8");
+}
+async function syncToDirectory(cwd, agent, content) {
+  const outputDir = join8(cwd, agent.output);
+  await mkdir5(outputDir, { recursive: true });
+  const extension = agent.format === "mdc" ? ".mdc" : ".md";
+  const filename = `lynxprompt-rules${extension}`;
+  const outputPath = join8(outputDir, filename);
+  const formatted = formatForAgent(agent, content);
+  await writeFile5(outputPath, formatted, "utf-8");
+}
+function formatForAgent(agent, content) {
+  switch (agent.format) {
+    case "mdc":
+      return formatAsMdc(content, agent);
+    case "markdown":
+      return formatAsMarkdown(content, agent);
+    case "json":
+      return formatAsJson(content, agent);
+    case "text":
+      return content;
+    default:
+      return content;
+  }
+}
+function formatAsMdc(content, agent) {
+  const frontmatter = yaml3.stringify({
+    description: "LynxPrompt rules - AI coding guidelines",
+    globs: ["**/*"],
+    alwaysApply: true
+  });
+  return `---
+${frontmatter}---
+
+${content}`;
+}
+function formatAsMarkdown(content, agent) {
+  const header = `# AI Coding Rules
+
+> Generated by [LynxPrompt](https://lynxprompt.com)
+
+`;
+  return header + content;
+}
+function formatAsJson(content, agent) {
+  return JSON.stringify(
+    {
+      $schema: "https://lynxprompt.com/schemas/rules.json",
+      version: "1.0",
+      rules: content,
+      meta: {
+        generator: "lynxprompt",
+        url: "https://lynxprompt.com"
+      }
+    },
+    null,
+    2
+  );
+}
+
+// src/commands/agents.ts
+import chalk12 from "chalk";
+import prompts6 from "prompts";
+import { readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
+import { join as join9 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import * as yaml4 from "yaml";
+var CONFIG_FILE2 = ".lynxprompt/conf.yml";
+async function agentsCommand(action, agentId, options = {}) {
+  console.log();
+  switch (action) {
+    case "enable":
+      await enableAgent(agentId, options);
+      break;
+    case "disable":
+      await disableAgent(agentId);
+      break;
+    case "detect":
+      await detectAgentsInProject();
+      break;
+    case "list":
+    default:
+      await listAgents();
+      break;
+  }
+}
+async function listAgents() {
+  console.log(chalk12.cyan("\u{1F431} LynxPrompt Agents"));
+  console.log();
+  const config2 = await loadConfig();
+  const enabledSet = new Set(config2?.exporters ?? []);
+  const detection = detectAgents();
+  if (enabledSet.size > 0) {
+    console.log(chalk12.green("Enabled:"));
+    for (const id of enabledSet) {
+      const agent = getAgent(id);
+      const detected = detection.detected.find((d) => d.agent.id === id);
+      const status = detected ? chalk12.gray("(detected)") : "";
+      console.log(`  ${chalk12.green("\u2713")} ${agent?.name ?? id} ${status}`);
+    }
+    console.log();
+  }
+  const detectedNotEnabled = detection.detected.filter(
+    (d) => !enabledSet.has(d.agent.id)
+  );
+  if (detectedNotEnabled.length > 0) {
+    console.log(chalk12.yellow("Detected (not enabled):"));
+    for (const detected of detectedNotEnabled) {
+      const rules = detected.ruleCount > 0 ? chalk12.gray(` (${detected.ruleCount} rules)`) : "";
+      console.log(`  ${chalk12.yellow("\u25CB")} ${detected.agent.name}${rules}`);
+    }
+    console.log();
+  }
+  const popular = getPopularAgents().filter(
+    (a) => !enabledSet.has(a.id) && !detectedNotEnabled.some((d) => d.agent.id === a.id)
+  );
+  if (popular.length > 0) {
+    console.log(chalk12.gray("Popular (available):"));
+    for (const agent of popular) {
+      console.log(`  ${chalk12.gray("-")} ${agent.name} - ${agent.description}`);
+    }
+    console.log();
+  }
+  console.log(chalk12.gray(`Total: ${AGENTS.length} agents supported`));
+  console.log();
+  console.log(chalk12.gray("Commands:"));
+  console.log(chalk12.gray("  lynxp agents enable <agent>   Enable an agent"));
+  console.log(chalk12.gray("  lynxp agents disable <agent>  Disable an agent"));
+  console.log(chalk12.gray("  lynxp agents detect           Auto-detect agents"));
+  console.log();
+}
+async function enableAgent(agentId, options = {}) {
+  const cwd = process.cwd();
+  const configPath = join9(cwd, CONFIG_FILE2);
+  if (!existsSync6(configPath)) {
+    console.log(chalk12.yellow("LynxPrompt not initialized. Run 'lynxp init' first."));
+    return;
+  }
+  let config2 = await loadConfig();
+  if (!config2) {
+    console.log(chalk12.red("Could not load configuration."));
+    return;
+  }
+  if (!agentId || options.interactive) {
+    const enabledSet = new Set(config2.exporters ?? []);
+    const choices = AGENTS.map((agent2) => ({
+      title: `${agent2.name} - ${agent2.description}`,
+      value: agent2.id,
+      selected: enabledSet.has(agent2.id)
+    }));
+    const { selected } = await prompts6({
+      type: "multiselect",
+      name: "selected",
+      message: "Select agents to enable:",
+      choices,
+      hint: "- Space to select, Enter to confirm"
+    });
+    if (!selected || selected.length === 0) {
+      console.log(chalk12.yellow("No agents selected."));
+      return;
+    }
+    config2.exporters = selected;
+    await saveConfig(config2);
+    console.log(chalk12.green(`\u2713 Enabled ${selected.length} agent${selected.length === 1 ? "" : "s"}`));
+    console.log();
+    console.log(chalk12.gray("Run 'lynxp sync' to sync your rules."));
+    return;
+  }
+  const agent = getAgent(agentId);
+  if (!agent) {
+    const similar = AGENTS.filter(
+      (a) => a.id.includes(agentId.toLowerCase()) || a.name.toLowerCase().includes(agentId.toLowerCase())
+    );
+    console.log(chalk12.red(`Unknown agent: ${agentId}`));
+    if (similar.length > 0) {
+      console.log();
+      console.log(chalk12.gray("Did you mean:"));
+      for (const a of similar.slice(0, 5)) {
+        console.log(chalk12.gray(`  ${a.id} - ${a.name}`));
+      }
+    }
+    return;
+  }
+  if (!config2.exporters) {
+    config2.exporters = [];
+  }
+  if (config2.exporters.includes(agent.id)) {
+    console.log(chalk12.yellow(`${agent.name} is already enabled.`));
+    return;
+  }
+  config2.exporters.push(agent.id);
+  await saveConfig(config2);
+  console.log(chalk12.green(`\u2713 Enabled ${agent.name}`));
+  console.log();
+  console.log(chalk12.gray(`Output: ${agent.output}`));
+  console.log(chalk12.gray("Run 'lynxp sync' to sync your rules."));
+}
+async function disableAgent(agentId) {
+  if (!agentId) {
+    console.log(chalk12.yellow("Usage: lynxp agents disable <agent>"));
+    return;
+  }
+  const cwd = process.cwd();
+  const configPath = join9(cwd, CONFIG_FILE2);
+  if (!existsSync6(configPath)) {
+    console.log(chalk12.yellow("LynxPrompt not initialized. Run 'lynxp init' first."));
+    return;
+  }
+  const config2 = await loadConfig();
+  if (!config2) {
+    console.log(chalk12.red("Could not load configuration."));
+    return;
+  }
+  if (!config2.exporters || !config2.exporters.includes(agentId)) {
+    const agent2 = getAgent(agentId);
+    console.log(chalk12.yellow(`${agent2?.name ?? agentId} is not enabled.`));
+    return;
+  }
+  if (config2.exporters.length === 1) {
+    console.log(chalk12.yellow("Cannot disable the last agent. At least one must be enabled."));
+    return;
+  }
+  config2.exporters = config2.exporters.filter((e) => e !== agentId);
+  await saveConfig(config2);
+  const agent = getAgent(agentId);
+  console.log(chalk12.green(`\u2713 Disabled ${agent?.name ?? agentId}`));
+}
+async function detectAgentsInProject() {
+  console.log(chalk12.cyan("\u{1F50D} Detecting AI agents..."));
+  console.log();
+  const detection = detectAgents();
+  console.log(formatDetectionResults(detection));
+  console.log();
+  if (detection.detected.length === 0) {
+    return;
+  }
+  const config2 = await loadConfig();
+  const enabledSet = new Set(config2?.exporters ?? []);
+  const newAgents = detection.detected.filter((d) => !enabledSet.has(d.agent.id));
+  if (newAgents.length === 0) {
+    console.log(chalk12.gray("All detected agents are already enabled."));
+    return;
+  }
+  const { enable } = await prompts6({
+    type: "confirm",
+    name: "enable",
+    message: `Enable ${newAgents.length} detected agent${newAgents.length === 1 ? "" : "s"}?`,
+    initial: true
+  });
+  if (enable && config2) {
+    config2.exporters = [
+      ...config2.exporters ?? [],
+      ...newAgents.map((d) => d.agent.id)
+    ];
+    await saveConfig(config2);
+    console.log(chalk12.green(`\u2713 Enabled ${newAgents.length} agent${newAgents.length === 1 ? "" : "s"}`));
+  }
+}
+async function loadConfig() {
+  const cwd = process.cwd();
+  const configPath = join9(cwd, CONFIG_FILE2);
+  if (!existsSync6(configPath)) {
+    return null;
+  }
+  try {
+    const content = await readFile8(configPath, "utf-8");
+    return yaml4.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function saveConfig(config2) {
+  const cwd = process.cwd();
+  const configPath = join9(cwd, CONFIG_FILE2);
+  const content = yaml4.stringify(config2);
+  await writeFile6(configPath, content, "utf-8");
+}
+
+// src/commands/check.ts
+import chalk13 from "chalk";
+import ora10 from "ora";
+import { readFile as readFile9, readdir as readdir5, stat as stat2 } from "fs/promises";
+import { join as join10 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import * as yaml5 from "yaml";
+var CONFIG_FILES2 = [
+  { path: "AGENTS.md", name: "AGENTS.md" },
+  { path: "CLAUDE.md", name: "CLAUDE.md" },
+  { path: ".github/copilot-instructions.md", name: "GitHub Copilot" },
+  { path: ".windsurfrules", name: "Windsurf" },
+  { path: ".clinerules", name: "Cline" },
+  { path: ".goosehints", name: "Goose" },
+  { path: ".zed/instructions.md", name: "Zed" }
+];
+var CONFIG_DIRS2 = [
+  { path: ".cursor/rules", name: "Cursor" },
+  { path: ".lynxprompt", name: "LynxPrompt" }
+];
+function validateMarkdown(content, filename) {
+  const errors = [];
+  const warnings = [];
+  if (!content.trim()) {
+    errors.push(`${filename}: File is empty`);
+    return { errors, warnings };
+  }
+  if (content.trim().length < 50) {
+    warnings.push(`${filename}: Content seems too short (< 50 chars)`);
+  }
+  if (!content.includes("#")) {
+    warnings.push(`${filename}: No markdown headers found`);
+  }
+  const placeholders = [
+    "TODO",
+    "FIXME",
+    "YOUR_",
+    "REPLACE_",
+    "[INSERT",
+    "example.com"
+  ];
+  for (const placeholder of placeholders) {
+    if (content.includes(placeholder)) {
+      warnings.push(`${filename}: Contains placeholder text "${placeholder}"`);
+    }
+  }
+  const secretPatterns = [
+    /sk[_-][a-zA-Z0-9]{20,}/,
+    // Stripe-like keys
+    /ghp_[a-zA-Z0-9]{36}/,
+    // GitHub tokens
+    /api[_-]?key[_-]?=\s*[a-zA-Z0-9]{20,}/i
+  ];
+  for (const pattern of secretPatterns) {
+    if (pattern.test(content)) {
+      errors.push(`${filename}: Potential secret/API key detected - DO NOT commit secrets!`);
+      break;
+    }
+  }
+  return { errors, warnings };
+}
+async function validateLynxPromptConfig(cwd) {
+  const errors = [];
+  const warnings = [];
+  const configPath = join10(cwd, ".lynxprompt/conf.yml");
+  if (!existsSync7(configPath)) {
+    return { errors, warnings };
+  }
+  try {
+    const content = await readFile9(configPath, "utf-8");
+    const config2 = yaml5.parse(content);
+    if (!config2.version) {
+      warnings.push(".lynxprompt/conf.yml: Missing 'version' field");
+    }
+    if (!config2.exporters || !Array.isArray(config2.exporters)) {
+      errors.push(".lynxprompt/conf.yml: Missing or invalid 'exporters' field");
+    } else if (config2.exporters.length === 0) {
+      warnings.push(".lynxprompt/conf.yml: No exporters configured");
+    }
+    if (!config2.sources || !Array.isArray(config2.sources)) {
+      errors.push(".lynxprompt/conf.yml: Missing or invalid 'sources' field");
+    } else {
+      for (const source of config2.sources) {
+        if (source.type === "local" && source.path) {
+          const sourcePath = join10(cwd, source.path);
+          if (!existsSync7(sourcePath)) {
+            errors.push(`.lynxprompt/conf.yml: Source path not found: ${source.path}`);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    errors.push(`.lynxprompt/conf.yml: Invalid YAML syntax - ${error instanceof Error ? error.message : "parse error"}`);
+  }
+  return { errors, warnings };
+}
+function validateMdc(content, filename) {
+  const errors = [];
+  const warnings = [];
+  if (!content.startsWith("---")) {
+    warnings.push(`${filename}: Missing YAML frontmatter`);
+  } else {
+    const frontmatterEnd = content.indexOf("---", 3);
+    if (frontmatterEnd === -1) {
+      errors.push(`${filename}: Unclosed YAML frontmatter`);
+    } else {
+      const frontmatter = content.substring(3, frontmatterEnd).trim();
+      try {
+        yaml5.parse(frontmatter);
+      } catch {
+        errors.push(`${filename}: Invalid YAML frontmatter`);
+      }
+    }
+  }
+  const bodyStart = content.indexOf("---", 3);
+  if (bodyStart !== -1) {
+    const body = content.substring(bodyStart + 3).trim();
+    const mdResult = validateMarkdown(body, filename);
+    warnings.push(...mdResult.warnings);
+  }
+  return { errors, warnings };
+}
+async function checkCommand(options = {}) {
+  const isCi = options.ci;
+  const cwd = process.cwd();
+  if (!isCi) {
+    console.log();
+    console.log(chalk13.cyan("\u{1F431} LynxPrompt Check"));
+    console.log();
+  }
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: [],
+    files: []
+  };
+  const spinner = !isCi ? ora10("Scanning for configuration files...").start() : null;
+  for (const file of CONFIG_FILES2) {
+    const filePath = join10(cwd, file.path);
+    if (existsSync7(filePath)) {
+      result.files.push(file.path);
+      try {
+        const content = await readFile9(filePath, "utf-8");
+        const validation = validateMarkdown(content, file.path);
+        result.errors.push(...validation.errors);
+        result.warnings.push(...validation.warnings);
+      } catch (error) {
+        result.errors.push(`${file.path}: Could not read file`);
+      }
+    }
+  }
+  for (const dir of CONFIG_DIRS2) {
+    const dirPath = join10(cwd, dir.path);
+    if (existsSync7(dirPath)) {
+      try {
+        const files = await readdir5(dirPath);
+        for (const file of files) {
+          const filePath = join10(dirPath, file);
+          const fileStat = await stat2(filePath);
+          if (fileStat.isFile()) {
+            result.files.push(`${dir.path}/${file}`);
+            const content = await readFile9(filePath, "utf-8");
+            if (file.endsWith(".mdc")) {
+              const validation = validateMdc(content, `${dir.path}/${file}`);
+              result.errors.push(...validation.errors);
+              result.warnings.push(...validation.warnings);
+            } else if (file.endsWith(".md")) {
+              const validation = validateMarkdown(content, `${dir.path}/${file}`);
+              result.errors.push(...validation.errors);
+              result.warnings.push(...validation.warnings);
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  const lynxpromptValidation = await validateLynxPromptConfig(cwd);
+  result.errors.push(...lynxpromptValidation.errors);
+  result.warnings.push(...lynxpromptValidation.warnings);
+  spinner?.stop();
+  result.valid = result.errors.length === 0;
+  if (isCi) {
+    if (!result.valid) {
+      console.error("\u2717 Validation failed");
+      for (const error of result.errors) {
+        console.error(`  ${error}`);
+      }
+      process.exit(1);
+    } else if (result.files.length === 0) {
+      console.error("\u2717 No configuration files found");
+      process.exit(1);
+    } else {
+      console.log("\u2713 Validation passed");
+      if (result.warnings.length > 0) {
+        console.log(`  (${result.warnings.length} warning${result.warnings.length === 1 ? "" : "s"})`);
+      }
+      process.exit(0);
+    }
+  } else {
+    if (result.files.length === 0) {
+      console.log(chalk13.yellow("\u26A0 No AI configuration files found."));
+      console.log();
+      console.log(chalk13.gray("Run 'lynxp wizard' to create a configuration."));
+      return;
+    }
+    console.log(chalk13.green(`\u2713 Found ${result.files.length} configuration file${result.files.length === 1 ? "" : "s"}:`));
+    for (const file of result.files) {
+      console.log(chalk13.gray(`  ${file}`));
+    }
+    console.log();
+    if (result.errors.length > 0) {
+      console.log(chalk13.red(`\u2717 ${result.errors.length} error${result.errors.length === 1 ? "" : "s"}:`));
+      for (const error of result.errors) {
+        console.log(chalk13.red(`  ${error}`));
+      }
+      console.log();
+    }
+    if (result.warnings.length > 0) {
+      console.log(chalk13.yellow(`\u26A0 ${result.warnings.length} warning${result.warnings.length === 1 ? "" : "s"}:`));
+      for (const warning of result.warnings) {
+        console.log(chalk13.yellow(`  ${warning}`));
+      }
+      console.log();
+    }
+    if (result.valid) {
+      console.log(chalk13.green("\u2705 Validation passed!"));
+    } else {
+      console.log(chalk13.red("\u274C Validation failed. Fix the errors above."));
+    }
+    console.log();
+  }
+}
+
+// src/commands/diff.ts
+import chalk14 from "chalk";
+import ora11 from "ora";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join11 } from "path";
+import { existsSync as existsSync8 } from "fs";
+function computeDiff(oldText, newText) {
+  const oldLines = oldText.split("\n");
+  const newLines = newText.split("\n");
+  const result = [];
+  const lcs = longestCommonSubsequence(oldLines, newLines);
+  let oldIndex = 0;
+  let newIndex = 0;
+  let lcsIndex = 0;
+  while (oldIndex < oldLines.length || newIndex < newLines.length) {
+    if (lcsIndex < lcs.length && oldIndex < oldLines.length && oldLines[oldIndex] === lcs[lcsIndex]) {
+      if (newIndex < newLines.length && newLines[newIndex] === lcs[lcsIndex]) {
+        result.push({ type: "same", line: oldLines[oldIndex] });
+        oldIndex++;
+        newIndex++;
+        lcsIndex++;
+      } else {
+        result.push({ type: "add", line: newLines[newIndex] });
+        newIndex++;
+      }
+    } else if (oldIndex < oldLines.length && (lcsIndex >= lcs.length || oldLines[oldIndex] !== lcs[lcsIndex])) {
+      result.push({ type: "remove", line: oldLines[oldIndex] });
+      oldIndex++;
+    } else if (newIndex < newLines.length) {
+      result.push({ type: "add", line: newLines[newIndex] });
+      newIndex++;
+    }
+  }
+  return result;
+}
+function longestCommonSubsequence(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      if (a[i2 - 1] === b[j2 - 1]) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
+  }
+  const lcs = [];
+  let i = m;
+  let j = n;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      lcs.unshift(a[i - 1]);
+      i--;
+      j--;
+    } else if (dp[i - 1][j] > dp[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+  return lcs;
+}
+function formatDiff(diff, contextLines = 3) {
+  const output = [];
+  let lastPrintedIndex = -1;
+  let inHunk = false;
+  const changeIndices = diff.map((d, i) => d.type !== "same" ? i : -1).filter((i) => i !== -1);
+  if (changeIndices.length === 0) {
+    return chalk14.gray("  (no changes)");
+  }
+  for (let i = 0; i < diff.length; i++) {
+    const item = diff[i];
+    const nearChange = changeIndices.some((ci) => Math.abs(ci - i) <= contextLines);
+    if (nearChange) {
+      if (lastPrintedIndex !== -1 && i - lastPrintedIndex > 1) {
+        output.push(chalk14.gray("  ..."));
+      }
+      if (item.type === "add") {
+        output.push(chalk14.green(`+ ${item.line}`));
+      } else if (item.type === "remove") {
+        output.push(chalk14.red(`- ${item.line}`));
+      } else {
+        output.push(chalk14.gray(`  ${item.line}`));
+      }
+      lastPrintedIndex = i;
+    }
+  }
+  return output.join("\n");
+}
+function getDiffStats(diff) {
+  return {
+    added: diff.filter((d) => d.type === "add").length,
+    removed: diff.filter((d) => d.type === "remove").length,
+    unchanged: diff.filter((d) => d.type === "same").length
+  };
+}
+async function diffCommand(blueprintId, options = {}) {
+  console.log();
+  console.log(chalk14.cyan("\u{1F431} LynxPrompt Diff"));
+  console.log();
+  const cwd = process.cwd();
+  if (options.local) {
+    await diffLocal(cwd);
+    return;
+  }
+  if (!blueprintId) {
+    console.log(chalk14.red("\u2717 Please provide a blueprint ID to compare with."));
+    console.log();
+    console.log(chalk14.gray("Usage:"));
+    console.log(chalk14.gray("  lynxp diff <blueprint-id>    Compare local with remote blueprint"));
+    console.log(chalk14.gray("  lynxp diff --local           Compare .lynxprompt/rules/ with exports"));
+    return;
+  }
+  if (!isAuthenticated()) {
+    console.log(chalk14.yellow("\u26A0 Not logged in. Some blueprints may not be accessible."));
+    console.log(chalk14.gray("Run 'lynxp login' to authenticate."));
+    console.log();
+  }
+  const spinner = ora11("Fetching blueprint...").start();
+  try {
+    const { blueprint } = await api.getBlueprint(blueprintId);
+    spinner.stop();
+    if (!blueprint || !blueprint.content) {
+      console.log(chalk14.red(`\u2717 Blueprint not found or has no content: ${blueprintId}`));
+      return;
+    }
+    console.log(chalk14.green(`\u2713 Blueprint: ${blueprint.name || blueprintId}`));
+    if (blueprint.description) {
+      console.log(chalk14.gray(`  ${blueprint.description}`));
+    }
+    console.log();
+    const localPaths = [
+      "AGENTS.md",
+      "CLAUDE.md",
+      ".cursor/rules/project.mdc",
+      ".github/copilot-instructions.md",
+      ".windsurfrules"
+    ];
+    let localContent = null;
+    let localPath = null;
+    for (const path2 of localPaths) {
+      const fullPath = join11(cwd, path2);
+      if (existsSync8(fullPath)) {
+        try {
+          localContent = await readFile10(fullPath, "utf-8");
+          localPath = path2;
+          break;
+        } catch {
+        }
+      }
+    }
+    if (!localContent) {
+      console.log(chalk14.yellow("\u26A0 No local AI configuration file found."));
+      console.log(chalk14.gray("Run 'lynxp wizard' to create one, or 'lynxp pull' to download the blueprint."));
+      return;
+    }
+    console.log(chalk14.gray(`Comparing with: ${localPath}`));
+    console.log();
+    const diff = computeDiff(blueprint.content, localContent);
+    const stats = getDiffStats(diff);
+    if (stats.added === 0 && stats.removed === 0) {
+      console.log(chalk14.green("\u2713 Files are identical!"));
+    } else {
+      console.log(chalk14.gray("Changes (remote \u2192 local):"));
+      console.log();
+      console.log(formatDiff(diff));
+      console.log();
+      console.log(chalk14.gray(`Summary: ${chalk14.green(`+${stats.added}`)} ${chalk14.red(`-${stats.removed}`)} lines changed`));
+    }
+    console.log();
+  } catch (error) {
+    spinner.stop();
+    if (error instanceof ApiRequestError) {
+      if (error.statusCode === 401) {
+        console.log(chalk14.red("\u2717 Authentication required. Run 'lynxp login' first."));
+      } else if (error.statusCode === 404) {
+        console.log(chalk14.red(`\u2717 Blueprint not found: ${blueprintId}`));
+      } else if (error.statusCode === 403) {
+        console.log(chalk14.red("\u2717 Access denied to this blueprint."));
+      } else {
+        console.log(chalk14.red(`\u2717 API error: ${error.message}`));
+      }
+    } else {
+      console.log(chalk14.red("\u2717 Failed to fetch blueprint"));
+      if (error instanceof Error) {
+        console.log(chalk14.gray(`  ${error.message}`));
+      }
+    }
+  }
+}
+async function diffLocal(cwd) {
+  const rulesDir = join11(cwd, ".lynxprompt/rules");
+  if (!existsSync8(rulesDir)) {
+    console.log(chalk14.yellow("\u26A0 No .lynxprompt/rules/ directory found."));
+    console.log(chalk14.gray("Run 'lynxp init' to set up the advanced workflow, or 'lynxp wizard' for simple file generation."));
+    return;
+  }
+  console.log(chalk14.gray("Comparing .lynxprompt/rules/ with exported files..."));
+  console.log();
+  const rulesPath = join11(rulesDir, "agents.md");
+  if (!existsSync8(rulesPath)) {
+    console.log(chalk14.yellow("\u26A0 No rules files found in .lynxprompt/rules/"));
+    return;
+  }
+  let rulesContent;
+  try {
+    rulesContent = await readFile10(rulesPath, "utf-8");
+  } catch {
+    console.log(chalk14.red("\u2717 Could not read .lynxprompt/rules/agents.md"));
+    return;
+  }
+  const exportedFiles = [
+    { path: "AGENTS.md", name: "AGENTS.md" },
+    { path: ".cursor/rules/lynxprompt-rules.mdc", name: "Cursor" }
+  ];
+  let hasChanges = false;
+  for (const file of exportedFiles) {
+    const filePath = join11(cwd, file.path);
+    if (existsSync8(filePath)) {
+      try {
+        const exportedContent = await readFile10(filePath, "utf-8");
+        let compareContent = exportedContent;
+        if (file.path.endsWith(".mdc")) {
+          const frontmatterEnd = exportedContent.indexOf("---", 3);
+          if (frontmatterEnd !== -1) {
+            compareContent = exportedContent.substring(frontmatterEnd + 3).trim();
+          }
+        }
+        compareContent = compareContent.replace(/^# AI Coding Rules\n\n> Generated by \[LynxPrompt\].*\n\n/m, "").trim();
+        const diff = computeDiff(rulesContent.trim(), compareContent);
+        const stats = getDiffStats(diff);
+        if (stats.added > 0 || stats.removed > 0) {
+          hasChanges = true;
+          console.log(chalk14.yellow(`\u26A0 ${file.name} differs from source:`));
+          console.log(formatDiff(diff));
+          console.log(chalk14.gray(`  ${chalk14.green(`+${stats.added}`)} ${chalk14.red(`-${stats.removed}`)} lines`));
+          console.log();
+        } else {
+          console.log(chalk14.green(`\u2713 ${file.name} is in sync`));
+        }
+      } catch {
+      }
+    }
+  }
+  if (!hasChanges) {
+    console.log();
+    console.log(chalk14.green("\u2713 All exported files are in sync with .lynxprompt/rules/"));
+  } else {
+    console.log();
+    console.log(chalk14.gray("Run 'lynxp sync' to update exported files from .lynxprompt/rules/"));
+  }
+  console.log();
+}
+
+// src/commands/link.ts
+import chalk15 from "chalk";
+import ora12 from "ora";
+import prompts7 from "prompts";
+import { join as join12 } from "path";
+import { existsSync as existsSync9 } from "fs";
+function getSourceFromVisibility2(visibility) {
+  switch (visibility) {
+    case "PUBLIC":
+      return "marketplace";
+    case "TEAM":
+      return "team";
+    case "PRIVATE":
+      return "private";
+    default:
+      return "marketplace";
+  }
+}
+async function linkCommand(file, blueprintId, options = {}) {
+  const cwd = process.cwd();
+  if (options.list) {
+    await listTrackedBlueprints(cwd);
+    return;
+  }
+  if (!file) {
+    console.log(chalk15.red("\u2717 Please provide a file path to link."));
+    console.log();
+    console.log(chalk15.gray("Usage:"));
+    console.log(chalk15.gray("  lynxp link <file> <blueprint-id>   Link a local file to a cloud blueprint"));
+    console.log(chalk15.gray("  lynxp link --list                  List all tracked blueprints"));
+    console.log();
+    console.log(chalk15.gray("Example:"));
+    console.log(chalk15.gray("  lynxp link AGENTS.md bp_abc123"));
+    return;
+  }
+  if (!blueprintId) {
+    console.log(chalk15.red("\u2717 Please provide a blueprint ID to link to."));
+    console.log();
+    console.log(chalk15.gray("Usage: lynxp link <file> <blueprint-id>"));
+    console.log(chalk15.gray("Example: lynxp link AGENTS.md bp_abc123"));
+    console.log();
+    console.log(chalk15.gray("To find blueprint IDs:"));
+    console.log(chalk15.gray("  lynxp list      - Show your blueprints"));
+    console.log(chalk15.gray("  lynxp search <query>  - Search marketplace"));
+    return;
+  }
+  const filePath = join12(cwd, file);
+  if (!existsSync9(filePath)) {
+    console.log(chalk15.red(`\u2717 File not found: ${file}`));
+    return;
+  }
+  const existing = await findBlueprintByFile(cwd, file);
+  if (existing) {
+    console.log(chalk15.yellow(`\u26A0 This file is already linked to: ${existing.id}`));
+    const { proceed } = await prompts7({
+      type: "confirm",
+      name: "proceed",
+      message: "Replace the existing link?",
+      initial: false
+    });
+    if (!proceed) {
+      console.log(chalk15.gray("Cancelled."));
+      return;
+    }
+  }
+  if (!isAuthenticated()) {
+    console.log(
+      chalk15.yellow("Not logged in. Run 'lynxp login' to authenticate.")
+    );
+    process.exit(1);
+  }
+  const spinner = ora12(`Fetching blueprint ${chalk15.cyan(blueprintId)}...`).start();
+  try {
+    const { blueprint } = await api.getBlueprint(blueprintId);
+    spinner.stop();
+    const source = getSourceFromVisibility2(blueprint.visibility);
+    const isMarketplace = source === "marketplace";
+    console.log();
+    console.log(chalk15.cyan(`\u{1F431} Blueprint: ${chalk15.bold(blueprint.name)}`));
+    if (blueprint.description) {
+      console.log(chalk15.gray(`   ${blueprint.description}`));
+    }
+    console.log(chalk15.gray(`   Visibility: ${blueprint.visibility}`));
+    console.log();
+    if (isMarketplace) {
+      console.log(chalk15.yellow("\u26A0 This is a marketplace blueprint."));
+      console.log(chalk15.gray("  Your local changes will NOT sync back to the cloud."));
+      console.log(chalk15.gray("  To make changes, you'll need to create your own copy."));
+      console.log();
+    }
+    const { confirm } = await prompts7({
+      type: "confirm",
+      name: "confirm",
+      message: `Link ${chalk15.cyan(file)} to ${chalk15.cyan(blueprint.name)}?`,
+      initial: true
+    });
+    if (!confirm) {
+      console.log(chalk15.gray("Cancelled."));
+      return;
+    }
+    await linkBlueprint(cwd, file, blueprint.id, blueprint.name, source);
+    console.log();
+    console.log(chalk15.green(`\u2705 Linked: ${file} \u2192 ${blueprint.id}`));
+    console.log();
+    console.log(chalk15.gray("Next steps:"));
+    console.log(chalk15.gray(`  \u2022 Run 'lynxp pull ${blueprintId}' to update local file from cloud`));
+    console.log(chalk15.gray(`  \u2022 Run 'lynxp diff ${blueprintId}' to see differences`));
+    console.log(chalk15.gray(`  \u2022 Run 'lynxp status' to see all tracked blueprints`));
+    if (!isMarketplace) {
+      console.log(chalk15.gray(`  \u2022 Run 'lynxp push ${file}' to push local changes to cloud`));
+    }
+    console.log();
+  } catch (error) {
+    spinner.stop();
+    if (error instanceof ApiRequestError) {
+      if (error.statusCode === 404) {
+        console.log(chalk15.red(`\u2717 Blueprint not found: ${blueprintId}`));
+        console.log(chalk15.gray("  Make sure the ID is correct. Use 'lynxp list' or 'lynxp search' to find blueprints."));
+      } else if (error.statusCode === 403) {
+        console.log(chalk15.red("\u2717 You don't have access to this blueprint."));
+      } else {
+        console.log(chalk15.red(`\u2717 Error: ${error.message}`));
+      }
+    } else {
+      console.log(chalk15.red("\u2717 An unexpected error occurred."));
+    }
+  }
+}
+async function unlinkCommand(file) {
+  const cwd = process.cwd();
+  if (!file) {
+    console.log(chalk15.red("\u2717 Please provide a file path to unlink."));
+    console.log();
+    console.log(chalk15.gray("Usage: lynxp unlink <file>"));
+    console.log(chalk15.gray("Example: lynxp unlink AGENTS.md"));
+    return;
+  }
+  const tracked = await findBlueprintByFile(cwd, file);
+  if (!tracked) {
+    console.log(chalk15.yellow(`\u26A0 File is not linked to any blueprint: ${file}`));
+    return;
+  }
+  console.log();
+  console.log(chalk15.cyan(`Currently linked to: ${tracked.id}`));
+  console.log(chalk15.gray(`   Name: ${tracked.name}`));
+  console.log(chalk15.gray(`   Source: ${tracked.source}`));
+  console.log();
+  const { confirm } = await prompts7({
+    type: "confirm",
+    name: "confirm",
+    message: `Unlink ${chalk15.cyan(file)} from ${chalk15.cyan(tracked.name)}?`,
+    initial: true
+  });
+  if (!confirm) {
+    console.log(chalk15.gray("Cancelled."));
+    return;
+  }
+  const success = await untrackBlueprint(cwd, file);
+  if (success) {
+    console.log();
+    console.log(chalk15.green(`\u2705 Unlinked: ${file}`));
+    console.log(chalk15.gray("  The file is now a standalone local file."));
+    console.log(chalk15.gray("  It will no longer receive updates from the cloud blueprint."));
+    console.log();
+  } else {
+    console.log(chalk15.red("\u2717 Failed to unlink file."));
+  }
+}
+async function listTrackedBlueprints(cwd) {
+  console.log();
+  console.log(chalk15.cyan("\u{1F431} Tracked Blueprints"));
+  console.log();
+  const status = await checkSyncStatus(cwd);
+  if (status.length === 0) {
+    console.log(chalk15.gray("No blueprints are currently tracked."));
+    console.log();
+    console.log(chalk15.gray("To track a blueprint:"));
+    console.log(chalk15.gray("  lynxp pull <blueprint-id>     Download and track a blueprint"));
+    console.log(chalk15.gray("  lynxp link <file> <id>        Link an existing file to a blueprint"));
+    return;
+  }
+  for (const { blueprint, localModified, fileExists: fileExists2 } of status) {
+    const statusIcon = !fileExists2 ? chalk15.red("\u2717") : localModified ? chalk15.yellow("\u25CF") : chalk15.green("\u2713");
+    const sourceLabel = {
+      marketplace: chalk15.gray("[marketplace]"),
+      team: chalk15.blue("[team]"),
+      private: chalk15.green("[private]"),
+      local: chalk15.gray("[local]")
+    }[blueprint.source];
+    console.log(`${statusIcon} ${chalk15.cyan(blueprint.file)}`);
+    console.log(`  ${sourceLabel} ${blueprint.name}`);
+    console.log(`  ${chalk15.gray(`ID: ${blueprint.id}`)}`);
+    if (!fileExists2) {
+      console.log(chalk15.red(`  \u26A0 File not found`));
+    } else if (localModified) {
+      console.log(chalk15.yellow(`  \u26A0 Local changes detected`));
+    }
+    console.log();
+  }
+  console.log(chalk15.gray("Legend:"));
+  console.log(chalk15.gray(`  ${chalk15.green("\u2713")} In sync  ${chalk15.yellow("\u25CF")} Modified locally  ${chalk15.red("\u2717")} Missing`));
+  console.log();
+}
+
+// src/index.ts
+var program = new Command();
+program.name("lynxprompt").description("CLI for LynxPrompt - Generate AI IDE configuration files").version("0.2.0");
+program.command("wizard").description("Generate AI IDE configuration (recommended for most users)").option("-n, --name <name>", "Project name").option("-d, --description <description>", "Project description").option("-s, --stack <stack>", "Tech stack (comma-separated)").option("-f, --format <format>", "Output format: agents, cursor, or comma-separated for multiple").option("-p, --platforms <platforms>", "Alias for --format (deprecated)").option("--persona <persona>", "AI persona (fullstack, backend, frontend, devops, data, security)").option("--boundaries <level>", "Boundary preset (conservative, standard, permissive)").option("-y, --yes", "Skip prompts, use defaults (generates AGENTS.md)").action(wizardCommand);
+program.command("check").description("Validate AI configuration files (for CI/CD)").option("--ci", "CI mode - exit codes only (0=pass, 1=fail)").action(checkCommand);
+program.command("status").description("Show current AI configuration and tracked blueprints").action(statusCommand);
+program.command("pull <id>").description("Download and track a blueprint from the marketplace").option("-o, --output <path>", "Output directory", ".").option("-y, --yes", "Overwrite existing files without prompting").option("--preview", "Preview content without downloading").option("--no-track", "Don't track the blueprint for future syncs").action(pullCommand);
+program.command("search <query>").description("Search public blueprints in the marketplace").option("-l, --limit <number>", "Number of results", "20").action(searchCommand);
+program.command("list").description("List your blueprints").option("-l, --limit <number>", "Number of results", "20").option("-v, --visibility <visibility>", "Filter: PRIVATE, TEAM, PUBLIC, or all").action(listCommand);
+program.command("push [file]").description("Push local file to LynxPrompt cloud as a blueprint").option("-n, --name <name>", "Blueprint name").option("-d, --description <desc>", "Blueprint description").option("-v, --visibility <vis>", "Visibility: PRIVATE, TEAM, or PUBLIC", "PRIVATE").option("-t, --tags <tags>", "Tags (comma-separated)").option("-y, --yes", "Skip prompts").action(pushCommand);
+program.command("link [file] [blueprint-id]").description("Link a local file to a cloud blueprint for tracking").option("--list", "List all tracked blueprints").action(linkCommand);
+program.command("unlink <file>").description("Disconnect a local file from its cloud blueprint").action(unlinkCommand);
+program.command("diff [blueprint-id]").description("Show changes between local and remote blueprint").option("--local", "Compare .lynxprompt/rules/ with exported files").action(diffCommand);
+program.command("init").description("Initialize .lynxprompt/ for multi-editor sync (advanced)").option("-y, --yes", "Skip prompts and use defaults").option("-f, --force", "Re-initialize even if already initialized").action(initCommand);
+program.command("sync").description("Sync .lynxprompt/rules/ to all configured agents").option("--dry-run", "Preview changes without writing files").option("-f, --force", "Skip prompts (for CI/automation)").action(syncCommand);
+program.command("agents [action] [agent]").description("Manage AI agents (list, enable, disable, detect)").option("-i, --interactive", "Interactive agent selection").action(agentsCommand);
+program.command("login").description("Authenticate with LynxPrompt (opens browser)").action(loginCommand);
+program.command("logout").description("Log out and remove stored credentials").action(logoutCommand);
+program.command("whoami").description("Show current authenticated user").action(whoamiCommand);
+program.addHelpText(
+  "beforeAll",
+  `
+${chalk16.cyan("\u{1F431} LynxPrompt CLI")} ${chalk16.gray("(also available as: lynxp)")}
+${chalk16.gray("Generate AI IDE configuration files from your terminal")}
+`
+);
+program.addHelpText(
+  "after",
+  `
+${chalk16.cyan("Quick Start:")}
+  ${chalk16.white("$ lynxp wizard")}                ${chalk16.gray("Generate config interactively")}
+  ${chalk16.white("$ lynxp wizard -y")}             ${chalk16.gray("Generate AGENTS.md with defaults")}
+  ${chalk16.white("$ lynxp wizard -f cursor")}      ${chalk16.gray("Generate .cursor/rules/")}
+
+${chalk16.cyan("Marketplace:")}
+  ${chalk16.white("$ lynxp search nextjs")}         ${chalk16.gray("Search blueprints")}
+  ${chalk16.white("$ lynxp pull bp_abc123")}        ${chalk16.gray("Download and track a blueprint")}
+  ${chalk16.white("$ lynxp push")}                  ${chalk16.gray("Push local file to cloud")}
+  ${chalk16.white("$ lynxp link --list")}           ${chalk16.gray("Show tracked blueprints")}
+
+${chalk16.cyan("Blueprint Tracking:")}
+  ${chalk16.white("$ lynxp link AGENTS.md bp_xyz")} ${chalk16.gray("Link existing file to blueprint")}
+  ${chalk16.white("$ lynxp unlink AGENTS.md")}      ${chalk16.gray("Disconnect from cloud")}
+  ${chalk16.white("$ lynxp diff bp_abc123")}        ${chalk16.gray("Show changes vs cloud version")}
+
+${chalk16.cyan("CI/CD:")}
+  ${chalk16.white("$ lynxp check --ci")}            ${chalk16.gray("Validate config (exit code)")}
 
-${chalk9.gray("Documentation: https://lynxprompt.com/docs/cli")}
+${chalk16.gray("Docs: https://lynxprompt.com/docs/cli")}
 `
 );
 program.parse();