lynxprompt 0.1.0

package/dist/index.js

@@ -0,0 +1,1324 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk9 from "chalk";
+
+// src/commands/login.ts
+import chalk from "chalk";
+import ora from "ora";
+
+// src/config.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: "lynxprompt",
+  schema: {
+    token: {
+      type: "string"
+    },
+    apiUrl: {
+      type: "string",
+      default: "https://lynxprompt.com"
+    },
+    user: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        email: { type: "string" },
+        name: { type: ["string", "null"] },
+        plan: { type: "string" }
+      }
+    }
+  },
+  defaults: {
+    apiUrl: "https://lynxprompt.com"
+  }
+});
+function getToken() {
+  const envToken = process.env.LYNXPROMPT_TOKEN;
+  if (envToken) {
+    return envToken;
+  }
+  return config.get("token");
+}
+function setToken(token) {
+  config.set("token", token);
+}
+function clearToken() {
+  config.delete("token");
+  config.delete("user");
+}
+function getApiUrl() {
+  const envUrl = process.env.LYNXPROMPT_API_URL;
+  if (envUrl) {
+    return envUrl;
+  }
+  return config.get("apiUrl");
+}
+function getUser() {
+  return config.get("user");
+}
+function setUser(user) {
+  config.set("user", user);
+}
+function isAuthenticated() {
+  return !!getToken();
+}
+
+// src/api.ts
+var ApiClient = class {
+  getHeaders() {
+    const token = getToken();
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    return headers;
+  }
+  async request(endpoint, options = {}) {
+    const baseUrl = getApiUrl();
+    const url = `${baseUrl}${endpoint}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        ...this.getHeaders(),
+        ...options.headers
+      }
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      const error = data;
+      throw new ApiRequestError(
+        error.message || error.error || "Request failed",
+        response.status,
+        error
+      );
+    }
+    return data;
+  }
+  // Auth endpoints
+  async initCliSession() {
+    return this.request("/api/cli-auth/init", {
+      method: "POST"
+    });
+  }
+  async pollCliSession(sessionId) {
+    return this.request(
+      `/api/cli-auth/poll?session=${sessionId}`
+    );
+  }
+  // User endpoints
+  async getUser() {
+    return this.request("/api/v1/user");
+  }
+  // Blueprint endpoints
+  async listBlueprints(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", options.limit.toString());
+    if (options.offset) params.set("offset", options.offset.toString());
+    if (options.visibility) params.set("visibility", options.visibility);
+    const query = params.toString();
+    return this.request(
+      `/api/v1/blueprints${query ? `?${query}` : ""}`
+    );
+  }
+  async getBlueprint(id) {
+    const apiId = id.startsWith("bp_") ? id : `bp_${id}`;
+    return this.request(`/api/v1/blueprints/${apiId}`);
+  }
+  async searchBlueprints(query, limit = 20) {
+    const params = new URLSearchParams({
+      q: query,
+      limit: limit.toString()
+    });
+    return this.request(`/api/blueprints?${params}`);
+  }
+};
+var ApiRequestError = class extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.statusCode = statusCode;
+    this.response = response;
+    this.name = "ApiRequestError";
+  }
+};
+var api = new ApiClient();
+
+// src/commands/login.ts
+async function loginCommand() {
+  if (isAuthenticated()) {
+    console.log(
+      chalk.yellow(
+        "You are already logged in. Use 'lynxprompt logout' first to switch accounts."
+      )
+    );
+    return;
+  }
+  const spinner = ora("Initializing authentication...").start();
+  try {
+    const session = await api.initCliSession();
+    spinner.stop();
+    console.log();
+    console.log(chalk.cyan("\u{1F510} Opening browser to authenticate..."));
+    console.log(chalk.gray(`   ${session.auth_url}`));
+    console.log();
+    const openBrowser = await tryOpenBrowser(session.auth_url);
+    if (!openBrowser) {
+      console.log(
+        chalk.yellow("Could not open browser automatically. Please open the URL above manually.")
+      );
+    }
+    const pollSpinner = ora("Waiting for authentication...").start();
+    const maxWaitTime = 5 * 60 * 1e3;
+    const pollInterval = 2e3;
+    const startTime = Date.now();
+    while (Date.now() - startTime < maxWaitTime) {
+      await sleep(pollInterval);
+      try {
+        const result = await api.pollCliSession(session.session_id);
+        if (result.status === "completed" && result.token && result.user) {
+          pollSpinner.succeed("Authentication successful!");
+          setToken(result.token);
+          setUser(result.user);
+          console.log();
+          console.log(chalk.green(`\u2705 Logged in as ${chalk.bold(result.user.email)}`));
+          console.log(chalk.gray(`   Plan: ${result.user.plan}`));
+          console.log(chalk.gray(`   Token stored securely in config`));
+          console.log();
+          console.log(chalk.cyan("You're ready to use LynxPrompt CLI!"));
+          return;
+        }
+        if (result.status === "expired") {
+          pollSpinner.fail("Authentication session expired. Please try again.");
+          return;
+        }
+      } catch (error) {
+      }
+    }
+    pollSpinner.fail("Authentication timed out. Please try again.");
+  } catch (error) {
+    spinner.fail("Failed to initialize authentication");
+    if (error instanceof ApiRequestError) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      if (error.statusCode === 503) {
+        console.error(chalk.gray("The server may be temporarily unavailable. Please try again later."));
+      }
+    } else {
+      console.error(chalk.red("An unexpected error occurred."));
+      console.error(chalk.gray("Make sure you have internet connectivity and try again."));
+    }
+    process.exit(1);
+  }
+}
+async function tryOpenBrowser(url) {
+  try {
+    const { default: open } = await import("open");
+    await open(url);
+    return true;
+  } catch {
+    const { exec } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(exec);
+    const platform = process.platform;
+    let command;
+    if (platform === "darwin") {
+      command = `open "${url}"`;
+    } else if (platform === "win32") {
+      command = `start "" "${url}"`;
+    } else {
+      command = `xdg-open "${url}"`;
+    }
+    try {
+      await execAsync(command);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/logout.ts
+import chalk2 from "chalk";
+async function logoutCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk2.yellow("You are not currently logged in."));
+    return;
+  }
+  const user = getUser();
+  const email = user?.email || "unknown";
+  clearToken();
+  console.log(chalk2.green(`\u2713 Logged out from ${chalk2.bold(email)}`));
+  console.log(chalk2.gray("  Removed stored credentials"));
+}
+
+// src/commands/whoami.ts
+import chalk3 from "chalk";
+import ora2 from "ora";
+async function whoamiCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk3.yellow("Not logged in. Run 'lynxprompt login' to authenticate."));
+    process.exit(1);
+  }
+  const spinner = ora2("Fetching user info...").start();
+  try {
+    const { user } = await api.getUser();
+    spinner.stop();
+    setUser({
+      id: user.id,
+      email: user.email,
+      name: user.name,
+      plan: user.subscription.plan
+    });
+    console.log();
+    console.log(chalk3.cyan("\u{1F431} LynxPrompt Account"));
+    console.log();
+    console.log(`  ${chalk3.gray("Email:")}       ${chalk3.bold(user.email)}`);
+    if (user.name) {
+      console.log(`  ${chalk3.gray("Name:")}        ${user.name}`);
+    }
+    if (user.display_name) {
+      console.log(`  ${chalk3.gray("Display:")}     ${user.display_name}`);
+    }
+    console.log(`  ${chalk3.gray("Plan:")}        ${formatPlan(user.subscription.plan)}`);
+    if (user.subscription.status) {
+      console.log(`  ${chalk3.gray("Status:")}      ${user.subscription.status}`);
+    }
+    if (user.subscription.current_period_end) {
+      const endDate = new Date(user.subscription.current_period_end);
+      console.log(`  ${chalk3.gray("Renews:")}      ${endDate.toLocaleDateString()}`);
+    }
+    console.log();
+    console.log(`  ${chalk3.gray("Blueprints:")}  ${user.stats.blueprints_count}`);
+    console.log(`  ${chalk3.gray("Member since:")} ${new Date(user.created_at).toLocaleDateString()}`);
+    console.log();
+  } catch (error) {
+    spinner.fail("Failed to fetch user info");
+    if (error instanceof ApiRequestError) {
+      if (error.statusCode === 401) {
+        console.error(chalk3.red("Your session has expired. Please run 'lynxprompt login' again."));
+      } else if (error.statusCode === 403) {
+        console.error(chalk3.red("API access requires Pro, Max, or Teams subscription."));
+        console.error(chalk3.gray("Upgrade at https://lynxprompt.com/pricing"));
+      } else {
+        console.error(chalk3.red(`Error: ${error.message}`));
+      }
+    } else {
+      console.error(chalk3.red("An unexpected error occurred."));
+    }
+    process.exit(1);
+  }
+}
+function formatPlan(plan) {
+  const planColors = {
+    FREE: chalk3.gray,
+    PRO: chalk3.blue,
+    MAX: chalk3.magenta,
+    TEAMS: chalk3.cyan
+  };
+  const colorFn = planColors[plan] || chalk3.white;
+  return colorFn(plan);
+}
+
+// src/commands/list.ts
+import chalk4 from "chalk";
+import ora3 from "ora";
+async function listCommand(options) {
+  if (!isAuthenticated()) {
+    console.log(chalk4.yellow("Not logged in. Run 'lynxprompt login' to authenticate."));
+    process.exit(1);
+  }
+  const spinner = ora3("Fetching your blueprints...").start();
+  try {
+    const limit = parseInt(options.limit, 10) || 20;
+    const { blueprints, total, has_more } = await api.listBlueprints({
+      limit,
+      visibility: options.visibility
+    });
+    spinner.stop();
+    if (blueprints.length === 0) {
+      console.log();
+      console.log(chalk4.yellow("No blueprints found."));
+      console.log(chalk4.gray("Create your first blueprint at https://lynxprompt.com/blueprints/create"));
+      console.log(chalk4.gray("Or run 'lynxprompt init' to generate one from the CLI!"));
+      return;
+    }
+    console.log();
+    console.log(chalk4.cyan(`\u{1F431} Your Blueprints (${total} total)`));
+    console.log();
+    for (const bp of blueprints) {
+      printBlueprint(bp);
+    }
+    if (has_more) {
+      console.log(chalk4.gray(`Showing ${blueprints.length} of ${total}. Use --limit to see more.`));
+    }
+  } catch (error) {
+    spinner.fail("Failed to fetch blueprints");
+    handleApiError(error);
+  }
+}
+function printBlueprint(bp) {
+  const visibilityIcon = {
+    PRIVATE: "\u{1F512}",
+    TEAM: "\u{1F465}",
+    PUBLIC: "\u{1F310}"
+  }[bp.visibility] || "\u{1F4C4}";
+  const tierBadge = {
+    SIMPLE: chalk4.gray("[Basic]"),
+    INTERMEDIATE: chalk4.blue("[Pro]"),
+    ADVANCED: chalk4.magenta("[Max]")
+  }[bp.tier] || "";
+  console.log(`  ${visibilityIcon} ${chalk4.bold(bp.name)} ${tierBadge}`);
+  console.log(`     ${chalk4.cyan(bp.id)}`);
+  if (bp.description) {
+    console.log(`     ${chalk4.gray(truncate(bp.description, 60))}`);
+  }
+  console.log(`     ${chalk4.gray(`\u2193${bp.downloads}`)} ${chalk4.gray(`\u2665${bp.favorites}`)} ${formatTags(bp.tags)}`);
+  console.log();
+}
+function formatTags(tags) {
+  if (!tags || tags.length === 0) return "";
+  return tags.slice(0, 3).map((t) => chalk4.gray(`#${t}`)).join(" ");
+}
+function truncate(str, maxLength) {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - 3) + "...";
+}
+function handleApiError(error) {
+  if (error instanceof ApiRequestError) {
+    if (error.statusCode === 401) {
+      console.error(chalk4.red("Your session has expired. Please run 'lynxprompt login' again."));
+    } else if (error.statusCode === 403) {
+      console.error(chalk4.red("API access requires Pro, Max, or Teams subscription."));
+      console.error(chalk4.gray("Upgrade at https://lynxprompt.com/pricing"));
+    } else {
+      console.error(chalk4.red(`Error: ${error.message}`));
+    }
+  } else {
+    console.error(chalk4.red("An unexpected error occurred."));
+  }
+  process.exit(1);
+}
+
+// src/commands/pull.ts
+import chalk5 from "chalk";
+import ora4 from "ora";
+import prompts from "prompts";
+import { writeFile, access, mkdir } from "fs/promises";
+import { join, dirname } from "path";
+var TYPE_TO_FILENAME = {
+  AGENTS_MD: "AGENTS.md",
+  CURSOR_RULES: ".cursorrules",
+  COPILOT_INSTRUCTIONS: ".github/copilot-instructions.md",
+  WINDSURF_RULES: ".windsurfrules",
+  ZED_INSTRUCTIONS: ".zed/instructions.md",
+  CLAUDE_MD: "CLAUDE.md",
+  GENERIC: "ai-config.md"
+};
+async function pullCommand(id, options) {
+  if (!isAuthenticated()) {
+    console.log(
+      chalk5.yellow("Not logged in. Run 'lynxprompt login' to authenticate.")
+    );
+    process.exit(1);
+  }
+  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."));
+      process.exit(1);
+    }
+    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 {
+    }
+    if (fileExists2 && !options.yes) {
+      const response = await prompts({
+        type: "confirm",
+        name: "overwrite",
+        message: `File ${chalk5.cyan(outputPath)} already exists. Overwrite?`,
+        initial: false
+      });
+      if (!response.overwrite) {
+        console.log(chalk5.yellow("Aborted."));
+        return;
+      }
+    }
+    const dir = dirname(outputPath);
+    if (dir !== ".") {
+      await mkdir(dir, { recursive: true });
+    }
+    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}`));
+    }
+  } catch (error) {
+    spinner.fail("Failed to pull blueprint");
+    handleApiError2(error);
+  }
+}
+function getEditorHint(type) {
+  switch (type) {
+    case "CURSOR_RULES":
+      return "This file will be automatically read by Cursor.";
+    case "COPILOT_INSTRUCTIONS":
+      return "This file will be read by GitHub Copilot in VS Code.";
+    case "AGENTS_MD":
+      return "This AGENTS.md file works with Claude Code, Cursor, and other AI agents.";
+    case "WINDSURF_RULES":
+      return "This file will be automatically read by Windsurf.";
+    case "ZED_INSTRUCTIONS":
+      return "This file will be read by Zed's AI assistant.";
+    case "CLAUDE_MD":
+      return "This CLAUDE.md file will be read by Claude Code.";
+    default:
+      return null;
+  }
+}
+function handleApiError2(error) {
+  if (error instanceof ApiRequestError) {
+    if (error.statusCode === 401) {
+      console.error(
+        chalk5.red("Your session has expired. Please run 'lynxprompt login' again.")
+      );
+    } else if (error.statusCode === 403) {
+      console.error(
+        chalk5.red("You don't have access to this blueprint.")
+      );
+      console.error(
+        chalk5.gray(
+          "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.gray(
+          "Make sure you have the correct blueprint ID. Use 'lynxprompt list' to see your blueprints."
+        )
+      );
+    } else {
+      console.error(chalk5.red(`Error: ${error.message}`));
+    }
+  } else {
+    console.error(chalk5.red("An unexpected error occurred."));
+  }
+  process.exit(1);
+}
+
+// src/commands/init.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";
+
+// src/utils/detect.ts
+import { readFile, access as access2 } from "fs/promises";
+import { join as join2 } from "path";
+async function detectProject(cwd) {
+  const detected = {
+    name: null,
+    stack: [],
+    commands: {},
+    packageManager: null
+  };
+  const packageJsonPath = join2(cwd, "package.json");
+  if (await fileExists(packageJsonPath)) {
+    try {
+      const content = await readFile(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(content);
+      detected.name = pkg.name || null;
+      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");
+      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;
+      }
+      if (await fileExists(join2(cwd, "pnpm-lock.yaml"))) {
+        detected.packageManager = "pnpm";
+      } else if (await fileExists(join2(cwd, "yarn.lock"))) {
+        detected.packageManager = "yarn";
+      } else if (await fileExists(join2(cwd, "bun.lockb"))) {
+        detected.packageManager = "bun";
+      } else if (await fileExists(join2(cwd, "package-lock.json"))) {
+        detected.packageManager = "npm";
+      }
+      return detected;
+    } catch {
+    }
+  }
+  const pyprojectPath = join2(cwd, "pyproject.toml");
+  if (await fileExists(pyprojectPath)) {
+    try {
+      const content = await readFile(pyprojectPath, "utf-8");
+      detected.stack.push("python");
+      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");
+      detected.commands.test = "pytest";
+      detected.commands.lint = "ruff check";
+      return detected;
+    } catch {
+    }
+  }
+  const requirementsPath = join2(cwd, "requirements.txt");
+  if (await fileExists(requirementsPath)) {
+    try {
+      const content = await readFile(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.commands.test = "pytest";
+      detected.commands.lint = "ruff check";
+      return detected;
+    } catch {
+    }
+  }
+  const cargoPath = join2(cwd, "Cargo.toml");
+  if (await fileExists(cargoPath)) {
+    try {
+      const content = await readFile(cargoPath, "utf-8");
+      detected.stack.push("rust");
+      const nameMatch = content.match(/name\s*=\s*"([^"]+)"/);
+      if (nameMatch) detected.name = nameMatch[1];
+      detected.commands.build = "cargo build";
+      detected.commands.test = "cargo test";
+      detected.commands.lint = "cargo clippy";
+      return detected;
+    } catch {
+    }
+  }
+  const goModPath = join2(cwd, "go.mod");
+  if (await fileExists(goModPath)) {
+    try {
+      const content = await readFile(goModPath, "utf-8");
+      detected.stack.push("go");
+      const moduleMatch = content.match(/module\s+(\S+)/);
+      if (moduleMatch) {
+        const parts = moduleMatch[1].split("/");
+        detected.name = parts[parts.length - 1];
+      }
+      detected.commands.build = "go build";
+      detected.commands.test = "go test ./...";
+      detected.commands.lint = "golangci-lint run";
+      return detected;
+    } catch {
+    }
+  }
+  const makefilePath = join2(cwd, "Makefile");
+  if (await fileExists(makefilePath)) {
+    try {
+      const content = await readFile(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 (Object.keys(detected.commands).length > 0) {
+        return detected;
+      }
+    } catch {
+    }
+  }
+  return detected.stack.length > 0 || detected.name ? detected : null;
+}
+async function fileExists(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/generator.ts
+var PLATFORM_FILES = {
+  cursor: ".cursorrules",
+  claude: "AGENTS.md",
+  copilot: ".github/copilot-instructions.md",
+  windsurf: ".windsurfrules",
+  zed: ".zed/instructions.md"
+};
+var PERSONA_DESCRIPTIONS = {
+  backend: "a senior backend developer specializing in APIs, databases, and microservices architecture",
+  frontend: "a senior frontend developer specializing in UI components, styling, and user experience",
+  fullstack: "a senior full-stack developer capable of working across the entire application stack",
+  devops: "a DevOps engineer specializing in infrastructure, CI/CD pipelines, and containerization",
+  data: "a data engineer specializing in data pipelines, ETL processes, and database optimization",
+  security: "a security engineer focused on secure coding practices and vulnerability prevention"
+};
+var STACK_NAMES = {
+  typescript: "TypeScript",
+  javascript: "JavaScript",
+  python: "Python",
+  go: "Go",
+  rust: "Rust",
+  java: "Java",
+  csharp: "C#/.NET",
+  ruby: "Ruby",
+  php: "PHP",
+  swift: "Swift",
+  react: "React",
+  nextjs: "Next.js",
+  vue: "Vue.js",
+  angular: "Angular",
+  svelte: "Svelte",
+  express: "Express.js",
+  fastapi: "FastAPI",
+  django: "Django",
+  flask: "Flask",
+  spring: "Spring Boot",
+  rails: "Ruby on Rails",
+  laravel: "Laravel",
+  prisma: "Prisma",
+  tailwind: "Tailwind CSS",
+  fastify: "Fastify"
+};
+var BOUNDARIES = {
+  conservative: {
+    always: ["Read any file in the project", "Run lint and format commands"],
+    askFirst: [
+      "Modify any source file",
+      "Add new dependencies",
+      "Create new files",
+      "Run test commands",
+      "Modify configuration files"
+    ],
+    never: [
+      "Delete any files",
+      "Modify .env or secret files",
+      "Push to git or make commits",
+      "Access external APIs or services"
+    ]
+  },
+  standard: {
+    always: [
+      "Read any file in the project",
+      "Modify files in src/ or lib/",
+      "Run build, test, and lint commands",
+      "Create test files",
+      "Fix linting errors automatically"
+    ],
+    askFirst: [
+      "Add new dependencies to package.json",
+      "Modify configuration files at root level",
+      "Create new modules or directories",
+      "Refactor code structure significantly"
+    ],
+    never: [
+      "Modify .env files or secrets",
+      "Delete critical files without backup",
+      "Force push to git",
+      "Expose sensitive information in logs"
+    ]
+  },
+  permissive: {
+    always: [
+      "Modify any file in src/ or lib/",
+      "Run any build, test, or dev scripts",
+      "Add or update dependencies",
+      "Create new files and directories",
+      "Refactor and reorganize code"
+    ],
+    askFirst: [
+      "Modify root-level configuration files",
+      "Delete directories",
+      "Make breaking changes to public APIs"
+    ],
+    never: [
+      "Modify .env files directly",
+      "Commit secrets or credentials",
+      "Access production databases"
+    ]
+  }
+};
+function generateConfig(options) {
+  const files = {};
+  for (const platform of options.platforms) {
+    const filename = PLATFORM_FILES[platform];
+    if (filename) {
+      files[filename] = generateFileContent(options, platform);
+    }
+  }
+  return files;
+}
+function generateFileContent(options, platform) {
+  const sections = [];
+  const isMarkdown = platform !== "cursor" && platform !== "windsurf";
+  if (isMarkdown) {
+    sections.push(`# ${options.name} - AI Assistant Configuration`);
+    sections.push("");
+  }
+  const personaDesc = PERSONA_DESCRIPTIONS[options.persona] || options.persona;
+  if (isMarkdown) {
+    sections.push("## Persona");
+    sections.push("");
+    sections.push(`You are ${personaDesc}. You assist developers working on ${options.name}.`);
+  } else {
+    sections.push(`You are ${personaDesc}. You assist developers working on ${options.name}.`);
+  }
+  if (options.description) {
+    sections.push("");
+    sections.push(`Project description: ${options.description}`);
+  }
+  sections.push("");
+  if (options.stack.length > 0) {
+    if (isMarkdown) {
+      sections.push("## Tech Stack");
+      sections.push("");
+    } else {
+      sections.push("Tech Stack:");
+    }
+    const stackList = options.stack.map((s) => STACK_NAMES[s] || s);
+    if (isMarkdown) {
+      for (const tech of stackList) {
+        sections.push(`- ${tech}`);
+      }
+    } else {
+      sections.push(stackList.join(", "));
+    }
+    sections.push("");
+  }
+  const hasCommands = Object.values(options.commands).some(Boolean);
+  if (hasCommands) {
+    if (isMarkdown) {
+      sections.push("## Commands");
+      sections.push("");
+      sections.push("Use these commands for common tasks:");
+      sections.push("");
+      sections.push("```bash");
+    } else {
+      sections.push("Commands:");
+    }
+    if (options.commands.build) {
+      sections.push(isMarkdown ? `# Build: ${options.commands.build}` : `- Build: ${options.commands.build}`);
+    }
+    if (options.commands.test) {
+      sections.push(isMarkdown ? `# Test: ${options.commands.test}` : `- Test: ${options.commands.test}`);
+    }
+    if (options.commands.lint) {
+      sections.push(isMarkdown ? `# Lint: ${options.commands.lint}` : `- Lint: ${options.commands.lint}`);
+    }
+    if (options.commands.dev) {
+      sections.push(isMarkdown ? `# Dev: ${options.commands.dev}` : `- Dev: ${options.commands.dev}`);
+    }
+    if (isMarkdown) {
+      sections.push("```");
+    }
+    sections.push("");
+  }
+  const boundaries = BOUNDARIES[options.boundaries];
+  if (boundaries) {
+    if (isMarkdown) {
+      sections.push("## Boundaries");
+      sections.push("");
+      sections.push("### \u2705 Always (do without asking)");
+      sections.push("");
+      for (const item of boundaries.always) {
+        sections.push(`- ${item}`);
+      }
+      sections.push("");
+      sections.push("### \u26A0\uFE0F Ask First");
+      sections.push("");
+      for (const item of boundaries.askFirst) {
+        sections.push(`- ${item}`);
+      }
+      sections.push("");
+      sections.push("### \u{1F6AB} Never");
+      sections.push("");
+      for (const item of boundaries.never) {
+        sections.push(`- ${item}`);
+      }
+    } else {
+      sections.push("Boundaries:");
+      sections.push("");
+      sections.push("ALWAYS (do without asking):");
+      for (const item of boundaries.always) {
+        sections.push(`- ${item}`);
+      }
+      sections.push("");
+      sections.push("ASK FIRST:");
+      for (const item of boundaries.askFirst) {
+        sections.push(`- ${item}`);
+      }
+      sections.push("");
+      sections.push("NEVER:");
+      for (const item of boundaries.never) {
+        sections.push(`- ${item}`);
+      }
+    }
+    sections.push("");
+  }
+  if (isMarkdown) {
+    sections.push("## Code Style");
+    sections.push("");
+    sections.push("Follow these conventions:");
+    sections.push("");
+    if (options.stack.includes("typescript") || options.stack.includes("javascript")) {
+      sections.push("- Use TypeScript strict mode when available");
+      sections.push("- Prefer const over let, avoid var");
+      sections.push("- Use async/await over raw promises");
+      sections.push("- Use descriptive variable and function names");
+    }
+    if (options.stack.includes("react") || options.stack.includes("nextjs")) {
+      sections.push("- Use functional components with hooks");
+      sections.push("- Keep components small and focused");
+      sections.push("- Colocate related files (component, styles, tests)");
+    }
+    if (options.stack.includes("python")) {
+      sections.push("- Follow PEP 8 style guidelines");
+      sections.push("- Use type hints for function signatures");
+      sections.push("- Prefer f-strings for string formatting");
+    }
+    if (options.stack.includes("go")) {
+      sections.push("- Follow Go conventions (gofmt, golint)");
+      sections.push("- Use meaningful package names");
+      sections.push("- Handle errors explicitly");
+    }
+    if (options.stack.includes("rust")) {
+      sections.push("- Follow Rust conventions (clippy)");
+      sections.push("- Use idiomatic Rust patterns");
+      sections.push("- Prefer Result over panic");
+    }
+    sections.push("- Write self-documenting code");
+    sections.push("- Add comments for complex logic only");
+    sections.push("- Keep functions focused and testable");
+    sections.push("");
+  }
+  if (isMarkdown) {
+    sections.push("---");
+    sections.push("");
+    sections.push(`*Generated by [LynxPrompt](https://lynxprompt.com) CLI*`);
+  }
+  return sections.join("\n");
+}
+
+// src/commands/init.ts
+var TECH_STACKS = [
+  { title: "TypeScript", value: "typescript" },
+  { title: "JavaScript", value: "javascript" },
+  { title: "Python", value: "python" },
+  { title: "Go", value: "go" },
+  { title: "Rust", value: "rust" },
+  { title: "Java", value: "java" },
+  { title: "C#/.NET", value: "csharp" },
+  { title: "Ruby", value: "ruby" },
+  { title: "PHP", value: "php" },
+  { title: "Swift", value: "swift" }
+];
+var FRAMEWORKS = [
+  { title: "React", value: "react" },
+  { title: "Next.js", value: "nextjs" },
+  { title: "Vue.js", value: "vue" },
+  { title: "Angular", value: "angular" },
+  { title: "Svelte", value: "svelte" },
+  { title: "Express", value: "express" },
+  { title: "FastAPI", value: "fastapi" },
+  { title: "Django", value: "django" },
+  { title: "Flask", value: "flask" },
+  { title: "Spring Boot", value: "spring" },
+  { title: "Rails", value: "rails" },
+  { title: "Laravel", value: "laravel" }
+];
+var PLATFORMS = [
+  { title: "Cursor (.cursorrules)", value: "cursor", filename: ".cursorrules" },
+  { title: "Claude Code (AGENTS.md)", value: "claude", filename: "AGENTS.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: "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: "Conservative - Ask before most changes",
+    value: "conservative",
+    always: ["Read any file", "Run lint/format commands"],
+    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",
+    always: ["Modify any file in src/", "Run any script", "Add dependencies", "Create files"],
+    askFirst: ["Modify root configs", "Delete directories"],
+    never: ["Modify .env", "Access external APIs without confirmation"]
+  }
+];
+async function initCommand(options) {
+  console.log();
+  console.log(chalk6.cyan("\u{1F431} Welcome to LynxPrompt!"));
+  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();
+  }
+  let config2;
+  if (options.yes) {
+    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"],
+      persona: options.persona || "fullstack",
+      boundaries: options.boundaries || "standard",
+      commands: detected?.commands || {}
+    };
+  } else {
+    config2 = await runInteractiveWizard(options, detected);
+  }
+  const spinner = ora5("Generating configuration files...").start();
+  try {
+    const files = generateConfig(config2);
+    spinner.stop();
+    console.log();
+    console.log(chalk6.green("\u2705 Generated files:"));
+    for (const [filename, content] of Object.entries(files)) {
+      const outputPath = join3(process.cwd(), filename);
+      let exists = false;
+      try {
+        await access3(outputPath);
+        exists = true;
+      } catch {
+      }
+      if (exists && !options.yes) {
+        const response = await prompts2({
+          type: "confirm",
+          name: "overwrite",
+          message: `${filename} already exists. Overwrite?`,
+          initial: false
+        });
+        if (!response.overwrite) {
+          console.log(chalk6.yellow(`   Skipped: ${filename}`));
+          continue;
+        }
+      }
+      const dir = dirname2(outputPath);
+      if (dir !== ".") {
+        await mkdir2(dir, { recursive: true });
+      }
+      await writeFile2(outputPath, content, "utf-8");
+      console.log(`   ${chalk6.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();
+  } catch (error) {
+    spinner.fail("Failed to generate files");
+    console.error(chalk6.red("An error occurred while generating configuration files."));
+    if (error instanceof Error) {
+      console.error(chalk6.gray(error.message));
+    }
+    process.exit(1);
+  }
+}
+async function runInteractiveWizard(options, detected) {
+  const answers = {};
+  const nameResponse = await prompts2({
+    type: "text",
+    name: "name",
+    message: "What's your project name?",
+    initial: options.name || detected?.name || "my-project"
+  });
+  answers.name = nameResponse.name;
+  const descResponse = await prompts2({
+    type: "text",
+    name: "description",
+    message: "Describe your project in one sentence:",
+    initial: options.description || ""
+  });
+  answers.description = descResponse.description;
+  const allStackOptions = [...TECH_STACKS, ...FRAMEWORKS];
+  const stackResponse = await prompts2({
+    type: "multiselect",
+    name: "stack",
+    message: "Select your tech stack:",
+    choices: allStackOptions,
+    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({
+    type: "select",
+    name: "persona",
+    message: "What's the AI's persona/role?",
+    choices: PERSONAS,
+    initial: 2
+    // Full-stack by default
+  });
+  if (personaResponse.persona === "custom") {
+    const customPersona = await prompts2({
+      type: "text",
+      name: "value",
+      message: "Describe the custom persona:"
+    });
+    answers.persona = customPersona.value || "fullstack";
+  } else {
+    answers.persona = personaResponse.persona;
+  }
+  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({
+      type: "confirm",
+      name: "edit",
+      message: "Edit these 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 }
+      ]);
+      answers.commands = commandsResponse;
+    } else {
+      answers.commands = detected.commands;
+    }
+  } 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,
+    stack: answers.stack,
+    platforms: answers.platforms,
+    persona: answers.persona,
+    boundaries: answers.boundaries,
+    commands: answers.commands
+  };
+}
+
+// src/commands/search.ts
+import chalk7 from "chalk";
+import ora6 from "ora";
+async function searchCommand(query, options) {
+  const spinner = ora6(`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"));
+      return;
+    }
+    console.log();
+    console.log(chalk7.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();
+    console.log(chalk7.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}`);
+  if (result.description) {
+    console.log(`     ${chalk7.gray(truncate2(result.description, 60))}`);
+  }
+  console.log(`     ${chalk7.gray(`by ${result.author}`)} \u2022 ${chalk7.gray(`\u2193${result.downloads}`)} ${chalk7.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(" ");
+}
+function truncate2(str, maxLength) {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - 3) + "...";
+}
+function handleApiError3(error) {
+  if (error instanceof ApiRequestError) {
+    console.error(chalk7.red(`Error: ${error.message}`));
+  } else {
+    console.error(chalk7.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";
+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" }
+];
+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();
+  let foundAny = false;
+  for (const config2 of CONFIG_FILES) {
+    const filePath = join4(cwd, config2.path);
+    try {
+      await access4(filePath);
+      const content = await readFile3(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 preview = getPreview(content);
+      if (preview) {
+        console.log(`     ${chalk8.gray(`Preview: ${preview}`)}`);
+      }
+      console.log();
+    } catch {
+    }
+  }
+  if (!foundAny) {
+    console.log(chalk8.yellow("  No AI configuration files found in this directory."));
+    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."));
+  } else {
+    console.log(chalk8.gray("Run 'lynxprompt init' to update or create additional configs."));
+  }
+  console.log();
+}
+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("<!--")) {
+      return truncate3(trimmed, 50);
+    }
+  }
+  return null;
+}
+function truncate3(str, maxLength) {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - 3) + "...";
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/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")}
+
+${chalk9.gray("Documentation: https://lynxprompt.com/docs/cli")}
+`
+);
+program.parse();
+//# sourceMappingURL=index.js.map