@jawkit.cc/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1180 @@
+#!/usr/bin/env node
+import {
+  AgentError,
+  ConfigService,
+  Logger,
+  checkCliUpdate,
+  checkContentUpdates,
+  description,
+  getAuthService,
+  getCliVersion,
+  getContentService,
+  getTierDisplayName,
+  handleError,
+  isNewerVersion,
+  version
+} from "./chunk-V3HNAAHL.js";
+
+// src/cli.ts
+import { Command as Command5 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import { select, confirm } from "@inquirer/prompts";
+import chalk2 from "chalk";
+import fs4 from "fs/promises";
+import path4 from "path";
+
+// src/agents/base-agent.ts
+import fs from "fs/promises";
+import path from "path";
+import crypto from "crypto";
+var BaseAgent = class {
+  /**
+   * Default detection based on markers
+   */
+  async detect(projectPath) {
+    for (const marker of this.config.detection.markers) {
+      const markerPath = path.join(projectPath, marker);
+      try {
+        await fs.access(markerPath);
+        return true;
+      } catch {
+      }
+    }
+    return false;
+  }
+  /**
+   * Create target directory structure
+   */
+  async prepare(projectPath) {
+    const targetDir = path.join(projectPath, this.config.targetDirectory);
+    await fs.mkdir(targetDir, { recursive: true });
+    for (const contentType of this.config.supportedContentTypes) {
+      const mapping = this.config.fileMappings.find(
+        (m) => m.contentType === contentType
+      );
+      if (mapping && mapping.targetSubdir) {
+        const subdir = path.join(targetDir, mapping.targetSubdir);
+        await fs.mkdir(subdir, { recursive: true });
+      }
+    }
+  }
+  /**
+   * Install content files
+   */
+  async install(projectPath, files, options) {
+    const result = {
+      success: true,
+      installed: [],
+      skipped: [],
+      errors: []
+    };
+    for (const file of files) {
+      if (!options.contentTypes.includes(file.type)) {
+        result.skipped.push({
+          sourcePath: file.sourcePath,
+          targetPath: this.getTargetPath(projectPath, file),
+          reason: "filtered"
+        });
+        continue;
+      }
+      const targetPath = this.getTargetPath(projectPath, file);
+      try {
+        const exists = await this.fileExists(targetPath);
+        if (exists && !options.force) {
+          result.skipped.push({
+            sourcePath: file.sourcePath,
+            targetPath,
+            reason: "exists"
+          });
+          continue;
+        }
+        if (exists && options.backup) {
+          await this.backupFile(targetPath);
+        }
+        const content = this.transform(file.content, file);
+        if (!options.dryRun) {
+          await fs.mkdir(path.dirname(targetPath), { recursive: true });
+          await fs.writeFile(targetPath, content, "utf-8");
+        }
+        result.installed.push({
+          sourcePath: file.sourcePath,
+          targetPath,
+          contentType: file.type
+        });
+      } catch (error) {
+        result.success = false;
+        result.errors.push({
+          sourcePath: file.sourcePath,
+          targetPath,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+    }
+    return result;
+  }
+  /**
+   * Verify installed files
+   */
+  async verify(projectPath) {
+    const targetDir = path.join(projectPath, this.config.targetDirectory);
+    try {
+      await fs.access(targetDir);
+      return {
+        valid: true,
+        verified: [targetDir],
+        failed: []
+      };
+    } catch {
+      return {
+        valid: false,
+        verified: [],
+        failed: [
+          {
+            path: targetDir,
+            expected: "exists",
+            actual: "missing",
+            reason: "missing"
+          }
+        ]
+      };
+    }
+  }
+  /**
+   * Clean up installed files
+   */
+  async clean(_projectPath) {
+    return {
+      success: true,
+      removed: [],
+      restored: []
+    };
+  }
+  /**
+   * Get target path for a content file
+   */
+  getTargetPath(projectPath, file) {
+    const mapping = this.config.fileMappings.find(
+      (m) => m.contentType === file.type
+    );
+    if (!mapping) {
+      throw new Error(`No mapping found for content type: ${file.type}`);
+    }
+    const filename = path.basename(file.sourcePath);
+    const targetFilename = mapping.nameTransform ? mapping.nameTransform(filename) : filename;
+    return path.join(
+      projectPath,
+      this.config.targetDirectory,
+      mapping.targetSubdir,
+      targetFilename
+    );
+  }
+  /**
+   * Transform content before writing (override in subclasses if needed)
+   */
+  transform(content, _file) {
+    return content;
+  }
+  /**
+   * Check if file exists
+   */
+  async fileExists(filePath) {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Backup a file before overwriting
+   */
+  async backupFile(filePath) {
+    const backupPath = `${filePath}.jawkit-backup`;
+    await fs.copyFile(filePath, backupPath);
+  }
+  /**
+   * Calculate file checksum
+   */
+  calculateChecksum(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+  }
+};
+
+// src/agents/claude-code/index.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+var ClaudeCodeAgent = class extends BaseAgent {
+  config = {
+    id: "claude-code",
+    name: "Claude Code",
+    description: "Anthropic Claude Code AI assistant",
+    targetDirectory: ".claude",
+    supportedContentTypes: ["commands", "skills", "agents"],
+    fileMappings: [
+      {
+        contentType: "commands",
+        sourcePattern: "commands/**/*.md",
+        targetSubdir: "commands"
+      },
+      {
+        contentType: "skills",
+        sourcePattern: "skills/**/*.md",
+        targetSubdir: "skills"
+      },
+      {
+        contentType: "agents",
+        sourcePattern: "agents/**/*.md",
+        targetSubdir: "agents"
+      }
+    ],
+    detection: {
+      markers: [
+        ".claude",
+        // Existing Claude directory
+        "CLAUDE.md",
+        // Claude project file
+        ".claude.json"
+        // Claude config
+      ],
+      priority: 100
+      // Highest priority - primary agent
+    },
+    docsUrl: "https://docs.anthropic.com/claude-code"
+  };
+  /**
+   * Enhanced detection: also detect any code project
+   * Claude Code is our primary agent, so we suggest it for all code projects
+   */
+  async detect(projectPath) {
+    const hasMarkers = await super.detect(projectPath);
+    if (hasMarkers) return true;
+    return this.isCodeProject(projectPath);
+  }
+  /**
+   * Check if the directory appears to be a code project
+   */
+  async isCodeProject(projectPath) {
+    const codeMarkers = [
+      // JavaScript/TypeScript
+      "package.json",
+      "tsconfig.json",
+      // Rust
+      "Cargo.toml",
+      // Python
+      "pyproject.toml",
+      "requirements.txt",
+      "setup.py",
+      // Go
+      "go.mod",
+      // Java/Kotlin
+      "pom.xml",
+      "build.gradle",
+      "build.gradle.kts",
+      // Ruby
+      "Gemfile",
+      // PHP
+      "composer.json",
+      // .NET
+      "*.csproj",
+      "*.fsproj",
+      // Git (any repo is likely code)
+      ".git"
+    ];
+    for (const marker of codeMarkers) {
+      if (marker.includes("*")) {
+        try {
+          const files = await fs2.readdir(projectPath);
+          const pattern = marker.replace("*", "");
+          if (files.some((f) => f.endsWith(pattern))) {
+            return true;
+          }
+        } catch {
+        }
+      } else {
+        try {
+          await fs2.access(path2.join(projectPath, marker));
+          return true;
+        } catch {
+        }
+      }
+    }
+    return false;
+  }
+};
+var claudeCodeAgent = new ClaudeCodeAgent();
+
+// src/agents/github-copilot/index.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+var GitHubCopilotAgent = class extends BaseAgent {
+  config = {
+    id: "github-copilot",
+    name: "GitHub Copilot",
+    description: "GitHub Copilot AI assistant",
+    targetDirectory: ".github",
+    supportedContentTypes: ["commands", "skills"],
+    fileMappings: [
+      {
+        contentType: "commands",
+        sourcePattern: "commands/**/*.md",
+        targetSubdir: "copilot/commands"
+      },
+      {
+        contentType: "skills",
+        sourcePattern: "skills/**/*.md",
+        targetSubdir: "copilot/skills"
+      }
+    ],
+    detection: {
+      markers: [
+        ".github",
+        ".github/copilot-instructions.md"
+      ],
+      priority: 50
+      // Lower priority than Claude Code
+    },
+    docsUrl: "https://docs.github.com/copilot"
+  };
+  /**
+   * Transform content for GitHub Copilot format if needed
+   * Adds a title header if not present
+   */
+  transform(content, file) {
+    if (!content.startsWith("# ")) {
+      const filename = path3.basename(file.sourcePath, ".md");
+      const title = filename.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+      return `# ${title}
+
+${content}`;
+    }
+    return content;
+  }
+  /**
+   * GitHub Copilot specific: also create main instructions file
+   */
+  async prepare(projectPath) {
+    await super.prepare(projectPath);
+    const instructionsPath = path3.join(
+      projectPath,
+      ".github",
+      "copilot-instructions.md"
+    );
+    try {
+      await fs3.access(instructionsPath);
+    } catch {
+      const defaultContent = `# GitHub Copilot Instructions
+
+This file configures GitHub Copilot behavior for this project.
+
+## Custom Commands
+
+See the \`copilot/commands/\` directory for available commands.
+
+## Skills
+
+See the \`copilot/skills/\` directory for available skills.
+
+---
+
+*Managed by JawKit CLI*
+`;
+      await fs3.writeFile(instructionsPath, defaultContent, "utf-8");
+    }
+  }
+};
+var gitHubCopilotAgent = new GitHubCopilotAgent();
+
+// src/agents/registry.ts
+var AgentRegistry = class {
+  agents = /* @__PURE__ */ new Map();
+  constructor() {
+    this.register(claudeCodeAgent);
+    this.register(gitHubCopilotAgent);
+  }
+  /**
+   * Register an agent adapter
+   */
+  register(agent) {
+    if (this.agents.has(agent.config.id)) {
+      throw new Error(`Agent already registered: ${agent.config.id}`);
+    }
+    this.agents.set(agent.config.id, agent);
+  }
+  /**
+   * Get agent by ID
+   */
+  get(id) {
+    return this.agents.get(id);
+  }
+  /**
+   * Get all registered agents
+   */
+  getAll() {
+    return Array.from(this.agents.values());
+  }
+  /**
+   * Get all agent IDs
+   */
+  getIds() {
+    return Array.from(this.agents.keys());
+  }
+  /**
+   * Detect applicable agents for a project
+   * Returns agents sorted by priority (highest first)
+   */
+  async detectAgents(projectPath) {
+    const detected = [];
+    for (const agent of this.agents.values()) {
+      if (await agent.detect(projectPath)) {
+        detected.push(agent);
+      }
+    }
+    return detected.sort(
+      (a, b) => b.config.detection.priority - a.config.detection.priority
+    );
+  }
+  /**
+   * Check if an agent ID is valid
+   */
+  isValidAgent(id) {
+    return this.agents.has(id);
+  }
+  /**
+   * Get agent count
+   */
+  get size() {
+    return this.agents.size;
+  }
+};
+var agentRegistry = new AgentRegistry();
+
+// src/lib/promo.ts
+import chalk from "chalk";
+var PROMO_URL = "https://jawkit.cc/pro";
+function getPromoMessage() {
+  return [
+    "",
+    chalk.dim("\u2500".repeat(60)),
+    `${chalk.yellow("\u{1F48E}")} ${chalk.bold("Professional")}: Advanced skills + priority support`,
+    chalk.dim(`   ${PROMO_URL}`),
+    chalk.dim("\u2500".repeat(60))
+  ];
+}
+function showPromoIfFree(tier, logger) {
+  if (tier === "free") {
+    for (const line of getPromoMessage()) {
+      logger.info(line);
+    }
+  }
+}
+
+// src/commands/init.ts
+function initCommand() {
+  return new Command("init").description("Initialize JawKit content for a coding agent").option("-a, --agent <agent>", "Agent to install (claude-code, github-copilot)").option("-y, --yes", "Skip confirmation prompts").option("--dry-run", "Show what would be installed without making changes").action(async (options) => {
+    const logger = new Logger({});
+    const authService = getAuthService();
+    const contentService = getContentService();
+    const projectPath = process.cwd();
+    try {
+      logger.info("JawKit Init");
+      logger.divider();
+      const isAuthenticated = await authService.isAuthenticated();
+      const user = isAuthenticated ? await authService.getCurrentUser() : null;
+      const userTier = user?.tier ?? "free";
+      if (isAuthenticated && user) {
+        logger.info(`Licensed: ${chalk2.cyan(user.email)} (${getTierDisplayName(userTier)})`);
+      } else {
+        logger.info(chalk2.yellow("No license - using free tier content"));
+        logger.info(chalk2.dim("Run 'jawkit auth activate <key>' or 'jawkit auth redeem' for Professional"));
+        logger.info(chalk2.dim(`Purchase at ${chalk2.cyan("https://jawkit.cc/pro")}`));
+      }
+      logger.divider();
+      let agent;
+      if (options.agent) {
+        const specifiedAgent = agentRegistry.get(options.agent);
+        if (!specifiedAgent) {
+          const availableIds = agentRegistry.getIds().join(", ");
+          throw AgentError.notFound(`${options.agent}. Available: ${availableIds}`);
+        }
+        agent = specifiedAgent;
+      } else {
+        const detectedAgents = await agentRegistry.detectAgents(projectPath);
+        if (detectedAgents.length === 0) {
+          const defaultAgent = agentRegistry.get("claude-code");
+          if (!defaultAgent) {
+            throw new Error("Claude Code agent not found");
+          }
+          agent = defaultAgent;
+          logger.info(`No specific agent detected, using ${chalk2.cyan(agent.config.name)}`);
+        } else if (detectedAgents.length === 1) {
+          const singleAgent = detectedAgents[0];
+          if (!singleAgent) {
+            throw new Error("No agent found");
+          }
+          agent = singleAgent;
+          logger.info(`Detected ${chalk2.cyan(agent.config.name)}`);
+        } else if (options.yes) {
+          const firstAgent = detectedAgents[0];
+          if (!firstAgent) {
+            throw new Error("No agent found");
+          }
+          agent = firstAgent;
+          logger.info(`Using ${chalk2.cyan(agent.config.name)} (highest priority)`);
+        } else {
+          const selectedId = await select({
+            message: "Select agent to initialize:",
+            choices: detectedAgents.map((a) => ({
+              name: a.config.name,
+              value: a.config.id,
+              description: a.config.description
+            }))
+          });
+          agent = agentRegistry.get(selectedId);
+        }
+      }
+      logger.info(`Agent: ${chalk2.cyan(agent.config.name)}`);
+      logger.info(`Target: ${chalk2.dim(agent.config.targetDirectory + "/")}`);
+      logger.divider();
+      const bundleInfo = await contentService.getBundleInfo(agent.config.id, userTier);
+      logger.info(`Bundle size: ${chalk2.dim(formatBytes(bundleInfo.size))}`);
+      logger.info(`Files: ${chalk2.dim(bundleInfo.fileCount.toString())}`);
+      if (!options.yes && !options.dryRun) {
+        const shouldContinue = await confirm({
+          message: "Proceed with installation?",
+          default: true
+        });
+        if (!shouldContinue) {
+          logger.info("Installation cancelled");
+          return;
+        }
+      }
+      const targetDir = path4.join(projectPath, agent.config.targetDirectory);
+      let backupPath = null;
+      try {
+        const stats = await fs4.stat(targetDir);
+        if (stats.isDirectory()) {
+          backupPath = `${targetDir}.backup`;
+          logger.info(chalk2.yellow(`Existing ${agent.config.targetDirectory}/ found - will backup to ${agent.config.targetDirectory}.backup/`));
+        }
+      } catch {
+      }
+      if (options.dryRun) {
+        logger.info(chalk2.yellow("\n[DRY RUN] Would perform the following:"));
+        if (backupPath) {
+          logger.info(`  - Backup existing: ${agent.config.targetDirectory}/ \u2192 ${agent.config.targetDirectory}.backup/`);
+        }
+        logger.info(`  - Prepare directory: ${agent.config.targetDirectory}/`);
+        logger.info(`  - Download bundle: ${bundleInfo.filename}`);
+        logger.info(`  - Extract ${bundleInfo.fileCount} files`);
+        return;
+      }
+      logger.divider();
+      if (backupPath) {
+        const backupSpinner = logger.spinner("Backing up existing content...");
+        try {
+          await fs4.rm(backupPath, { recursive: true, force: true });
+        } catch {
+        }
+        await fs4.rename(targetDir, backupPath);
+        backupSpinner.succeed(`Backed up to ${agent.config.targetDirectory}.backup/`);
+      }
+      const prepareSpinner = logger.spinner("Preparing target directory...");
+      await agent.prepare(projectPath);
+      prepareSpinner.succeed("Target directory ready");
+      const downloadSpinner = logger.spinner("Downloading content...");
+      const result = await contentService.downloadAndExtractBundle(
+        agent.config.id,
+        userTier,
+        targetDir,
+        (progress) => {
+          if (progress.phase === "downloading") {
+            downloadSpinner.text = `Downloading... ${progress.percentage}%`;
+          } else if (progress.phase === "extracting") {
+            downloadSpinner.text = `Extracting ${progress.currentFile || ""}`;
+          }
+        }
+      );
+      if (result.success) {
+        downloadSpinner.succeed(`Installed ${result.filesExtracted.length} files (v${result.version})`);
+        const config = new ConfigService();
+        await config.addInstallation({
+          path: projectPath,
+          agent: agent.config.id,
+          contentVersion: result.version,
+          installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          files: result.filesExtracted,
+          tier: userTier,
+          checksum: bundleInfo.checksum
+        });
+        const currentVersions = await config.get("contentVersions") ?? {};
+        await config.set("contentVersions", {
+          ...currentVersions,
+          [agent.config.id]: result.version
+        });
+      } else {
+        downloadSpinner.fail("Installation failed");
+        for (const error of result.errors) {
+          logger.error(`  ${error}`);
+        }
+        process.exit(1);
+      }
+      logger.divider();
+      logger.success("JawKit content installed successfully!");
+      logger.info(`
+Installed to: ${chalk2.cyan(targetDir)}`);
+      if (result.filesExtracted.length > 0) {
+        logger.info("\nFiles installed:");
+        for (const file of result.filesExtracted.slice(0, 5)) {
+          logger.info(chalk2.dim(`  ${file}`));
+        }
+        if (result.filesExtracted.length > 5) {
+          logger.info(chalk2.dim(`  ... and ${result.filesExtracted.length - 5} more`));
+        }
+      }
+      showPromoIfFree(userTier, logger);
+    } catch (error) {
+      handleError(error, logger);
+      process.exit(1);
+    }
+  });
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}
+
+// src/commands/auth.ts
+import { Command as Command2 } from "commander";
+import { confirm as confirm2, input } from "@inquirer/prompts";
+import chalk3 from "chalk";
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function isValidEmail(email) {
+  return EMAIL_REGEX.test(email);
+}
+function authCommand() {
+  const auth = new Command2("auth").description("Manage license key authentication");
+  auth.command("activate <license-key>").description("Activate a license key").action(async (licenseKey, options) => {
+    const logger = new Logger(options);
+    const authService = getAuthService();
+    try {
+      const isAuthenticated = await authService.isAuthenticated();
+      if (isAuthenticated) {
+        const user = await authService.getCurrentUser();
+        if (user) {
+          logger.info(`You already have an active license for ${chalk3.cyan(user.email)} (${getTierDisplayName(user.tier)})`);
+          logger.divider();
+          const continueActivation = await confirm2({
+            message: "Replace with new license key?",
+            default: false
+          });
+          if (!continueActivation) {
+            return;
+          }
+        }
+      }
+      const spinner = logger.spinner("Validating license key...");
+      const result = await authService.activate(licenseKey);
+      if (result.success && result.user) {
+        spinner.succeed("License activated!");
+        logger.divider();
+        logger.info(`${chalk3.green("Email:")}  ${result.user.email}`);
+        logger.info(`${chalk3.green("Tier:")}   ${getTierDisplayName(result.user.tier)}`);
+        if (result.user.tierExpiresAt) {
+          const expiresDate = new Date(result.user.tierExpiresAt);
+          logger.info(`${chalk3.green("Expires:")} ${expiresDate.toLocaleDateString()}`);
+        } else {
+          logger.info(`${chalk3.green("Expires:")} Never (Lifetime)`);
+        }
+        logger.divider();
+        logger.info("You now have access to Professional content!");
+      } else {
+        spinner.fail("License activation failed");
+        if (result.error) {
+          logger.error(result.error);
+        }
+        process.exit(1);
+      }
+    } catch (error) {
+      handleError(error, logger);
+      process.exit(1);
+    }
+  });
+  auth.command("redeem [invite-code]").description("Redeem an invitation code to get a license").option("-e, --email <email>", "Email address for the license").action(async (inviteCode, options) => {
+    const logger = new Logger(options);
+    const authService = getAuthService();
+    try {
+      const isAuthenticated = await authService.isAuthenticated();
+      if (isAuthenticated) {
+        const user = await authService.getCurrentUser();
+        if (user) {
+          logger.info(`You already have an active license for ${chalk3.cyan(user.email)} (${getTierDisplayName(user.tier)})`);
+          logger.divider();
+          const continueRedeem = await confirm2({
+            message: "Replace with new license from invitation?",
+            default: false
+          });
+          if (!continueRedeem) {
+            return;
+          }
+        }
+      }
+      let code = inviteCode;
+      if (!code) {
+        code = await input({
+          message: "Enter invitation code:",
+          validate: (value) => {
+            if (!value.startsWith("JAWKIT_INV_")) {
+              return "Invitation codes start with JAWKIT_INV_";
+            }
+            return true;
+          }
+        });
+      }
+      let email = options.email;
+      if (!email) {
+        email = await input({
+          message: "Enter your email address:",
+          validate: (value) => {
+            if (!isValidEmail(value)) {
+              return "Please enter a valid email address (e.g., user@example.com)";
+            }
+            return true;
+          }
+        });
+      } else {
+        if (!isValidEmail(email)) {
+          logger.error("Invalid email format. Please provide a valid email address (e.g., user@example.com)");
+          process.exit(1);
+        }
+      }
+      const spinner = logger.spinner("Redeeming invitation...");
+      const result = await authService.redeem(code, email);
+      if (result.success && result.user) {
+        spinner.succeed("Invitation redeemed!");
+        logger.divider();
+        logger.info(`${chalk3.green("Email:")}  ${result.user.email}`);
+        logger.info(`${chalk3.green("Tier:")}   ${getTierDisplayName(result.user.tier)}`);
+        if (result.user.tierExpiresAt) {
+          const expiresDate = new Date(result.user.tierExpiresAt);
+          logger.info(`${chalk3.green("Expires:")} ${expiresDate.toLocaleDateString()}`);
+        } else {
+          logger.info(`${chalk3.green("Expires:")} Never (Lifetime)`);
+        }
+        logger.divider();
+        logger.info("Your license has been activated!");
+      } else {
+        spinner.fail("Redemption failed");
+        if (result.error) {
+          logger.error(result.error);
+        }
+        process.exit(1);
+      }
+    } catch (error) {
+      handleError(error, logger);
+      process.exit(1);
+    }
+  });
+  auth.command("deactivate").description("Remove stored license key").action(async (options) => {
+    const logger = new Logger(options);
+    const authService = getAuthService();
+    try {
+      const isAuthenticated = await authService.isAuthenticated();
+      if (!isAuthenticated) {
+        logger.info("No license key is currently stored");
+        return;
+      }
+      const user = await authService.getCurrentUser();
+      const proceed = await confirm2({
+        message: `Remove license for ${user?.email}?`,
+        default: false
+      });
+      if (!proceed) {
+        return;
+      }
+      await authService.deactivate();
+      logger.success("License key removed");
+      logger.info(chalk3.dim("Free tier content is still accessible."));
+    } catch (error) {
+      handleError(error, logger);
+      process.exit(1);
+    }
+  });
+  auth.command("status").description("Show current license status").option("--json", "Output as JSON").option("--revalidate", "Revalidate license with server").action(async (options) => {
+    const logger = new Logger(options);
+    const authService = getAuthService();
+    try {
+      if (options.revalidate) {
+        const spinner = logger.spinner("Revalidating license...");
+        const result = await authService.revalidate();
+        if (result.success) {
+          spinner.succeed("License revalidated");
+        } else {
+          spinner.fail("Revalidation failed");
+          if (result.error) {
+            logger.error(result.error);
+          }
+        }
+        logger.divider();
+      }
+      const isAuthenticated = await authService.isAuthenticated();
+      const user = isAuthenticated ? await authService.getCurrentUser() : null;
+      if (options.json) {
+        logger.json({
+          authenticated: isAuthenticated,
+          user: user ? {
+            email: user.email,
+            tier: user.tier,
+            tierDisplayName: getTierDisplayName(user.tier),
+            tierExpiresAt: user.tierExpiresAt
+          } : null
+        });
+        return;
+      }
+      logger.info("License Status");
+      logger.divider();
+      if (!isAuthenticated || !user) {
+        logger.info(`${chalk3.yellow("Status:")}  No license activated`);
+        logger.divider();
+        logger.info("Run 'jawkit auth activate <key>' or 'jawkit auth redeem' for Professional.");
+        logger.info("Free tier content is available without a license.");
+        logger.info(`Purchase at ${chalk3.cyan("https://jawkit.cc/pro")}`);
+        return;
+      }
+      logger.info(`${chalk3.green("Status:")}  Licensed ${chalk3.green("\u2713")}`);
+      logger.info(`${chalk3.green("Email:")}   ${user.email}`);
+      logger.info(`${chalk3.green("Tier:")}    ${getTierDisplayName(user.tier)}`);
+      if (user.tierExpiresAt) {
+        const expiresDate = new Date(user.tierExpiresAt);
+        const now = /* @__PURE__ */ new Date();
+        const daysUntilExpiry = Math.ceil((expiresDate.getTime() - now.getTime()) / (1e3 * 60 * 60 * 24));
+        if (daysUntilExpiry < 0) {
+          logger.info(`${chalk3.red("Expired:")} ${expiresDate.toLocaleDateString()} (fallen back to Free tier)`);
+        } else if (daysUntilExpiry <= 7) {
+          logger.info(`${chalk3.yellow("Expires:")} ${expiresDate.toLocaleDateString()} (${daysUntilExpiry} days)`);
+        } else {
+          logger.info(`${chalk3.green("Expires:")} ${expiresDate.toLocaleDateString()}`);
+        }
+      } else {
+        logger.info(`${chalk3.green("Expires:")} Never (Lifetime)`);
+      }
+    } catch (error) {
+      handleError(error, logger);
+      process.exit(1);
+    }
+  });
+  return auth;
+}
+
+// src/commands/version.ts
+import { Command as Command3 } from "commander";
+function versionCommand() {
+  return new Command3("version").description("Show CLI and content version information").option("--check", "Check for available updates").option("--json", "Output as JSON format").action(async (options) => {
+    const logger = new Logger(options);
+    const config = new ConfigService();
+    try {
+      const cliVersion = getCliVersion();
+      const contentVersions = await config.get("contentVersions") ?? {};
+      let cliLatest = null;
+      let contentUpdates = {};
+      if (options.check) {
+        const spinner = logger.spinner("Checking for updates...");
+        spinner.start();
+        cliLatest = await checkCliUpdate();
+        contentUpdates = await checkContentUpdates(contentVersions);
+        spinner.stop();
+      }
+      if (options.json) {
+        const output = {
+          cli: {
+            current: cliVersion,
+            latest: cliLatest ?? cliVersion,
+            updateAvailable: cliLatest ? isNewerVersion(cliLatest, cliVersion) : false
+          },
+          content: Object.fromEntries(
+            Object.entries(contentVersions).map(([agent, version2]) => [
+              agent,
+              {
+                current: version2,
+                latest: contentUpdates[agent] ?? version2,
+                updateAvailable: Boolean(contentUpdates[agent])
+              }
+            ])
+          )
+        };
+        logger.json(output);
+      } else {
+        let cliLine = `@jawkit/cli v${cliVersion}`;
+        if (cliLatest && isNewerVersion(cliLatest, cliVersion)) {
+          cliLine += ` (latest: v${cliLatest} available)`;
+          logger.info(cliLine);
+          logger.info("  Run: npm update -g @jawkit/cli");
+        } else if (options.check) {
+          cliLine += " (up to date)";
+          logger.info(cliLine);
+        } else {
+          logger.info(cliLine);
+        }
+        logger.newline();
+        if (Object.keys(contentVersions).length > 0) {
+          logger.info("Content Versions:");
+          for (const [agent, version2] of Object.entries(contentVersions)) {
+            const latestVersion = contentUpdates[agent];
+            let line = `  ${agent.padEnd(18)} v${version2}`;
+            if (latestVersion) {
+              line += ` (latest: v${latestVersion} available)`;
+            } else if (options.check) {
+              line += " (up to date)";
+            }
+            logger.info(line);
+          }
+          if (Object.keys(contentUpdates).length > 0) {
+            logger.newline();
+            logger.info("Run 'jawkit upgrade' to update content.");
+          }
+        } else {
+          logger.info("No content installed yet.");
+          logger.info("Run 'jawkit init' to install content.");
+        }
+      }
+    } catch (error) {
+      handleError(error, logger);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/upgrade.ts
+import { Command as Command4 } from "commander";
+import { confirm as confirm3 } from "@inquirer/prompts";
+import fs5 from "fs/promises";
+import path5 from "path";
+function upgradeCommand() {
+  return new Command4("upgrade").description("Upgrade content in current folder (use --all for all projects)").option("-a, --agent <agent>", "Upgrade specific agent only").option("--all", "Upgrade all registered projects").option("-y, --yes", "Skip confirmation prompts").option("--check-only", "Only check for updates, do not upgrade").option("--force", "Force re-download even if up to date").action(async (options) => {
+    const logger = new Logger(options);
+    const config = new ConfigService();
+    const contentService = getContentService();
+    const authService = getAuthService();
+    const projectPath = process.cwd();
+    try {
+      const allInstallations = await config.getInstallations();
+      let targetInstalls;
+      if (options.all) {
+        targetInstalls = allInstallations;
+      } else {
+        const currentInstall = allInstallations.find(
+          (i) => i.path === projectPath
+        );
+        if (!currentInstall) {
+          logger.warn("No JawKit installation found in current folder.");
+          logger.info(`Current folder: ${projectPath}`);
+          logger.newline();
+          logger.info("Run 'jawkit init' to install content first.");
+          logger.info("Or use 'jawkit upgrade --all' to upgrade all registered projects.");
+          return;
+        }
+        const agent = agentRegistry.get(currentInstall.agent);
+        if (agent) {
+          const targetDir = path5.join(projectPath, agent.config.targetDirectory);
+          try {
+            await fs5.access(targetDir);
+          } catch {
+            logger.warn("Content directory not found (may have been deleted).");
+            logger.info(`Expected: ${targetDir}`);
+            logger.newline();
+            logger.info("Run 'jawkit init' to reinstall content.");
+            return;
+          }
+        }
+        targetInstalls = [currentInstall];
+      }
+      if (targetInstalls.length === 0) {
+        logger.warn("No registered installations found.");
+        logger.info("Run 'jawkit init' in a project to install content first.");
+        return;
+      }
+      const cliVersion = getCliVersion();
+      logger.info(`CLI: @jawkit/cli v${cliVersion}`);
+      for (const install of targetInstalls) {
+        const displayPath = options.all ? ` (${install.path})` : "";
+        logger.info(`Content: ${install.agent} v${install.contentVersion}${displayPath}`);
+      }
+      logger.newline();
+      const spinner = logger.spinner("Checking for updates...");
+      spinner.start();
+      const manifest = await contentService.getManifest("latest");
+      const currentTier = await authService.getUserTier();
+      const installUpdates = [];
+      for (const install of targetInstalls) {
+        const agentId = install.agent;
+        if (options.agent && agentId !== options.agent) continue;
+        const agentManifest = manifest.agents[agentId];
+        const latest = agentManifest?.version;
+        const current = install.contentVersion;
+        const installedTier = install.tier || "free";
+        if (!latest) continue;
+        const bundleInfo = agentManifest.bundles[currentTier] || agentManifest.bundles["free"];
+        const latestChecksum = bundleInfo?.checksum || "";
+        const installedChecksum = install.checksum;
+        const hasVersionUpdate = !current || isNewerVersion(latest, current);
+        const hasTierChange = installedTier !== currentTier;
+        const hasChecksumChange = latestChecksum && installedChecksum && latestChecksum !== installedChecksum;
+        const needsChecksumUpdate = latestChecksum && !installedChecksum;
+        let reason = null;
+        if (options.force) reason = "force";
+        else if (hasVersionUpdate) reason = "version";
+        else if (hasTierChange) reason = "tier";
+        else if (hasChecksumChange || needsChecksumUpdate) reason = "checksum";
+        if (reason) {
+          installUpdates.push({
+            install,
+            agentId,
+            currentVersion: current || "not installed",
+            latestVersion: latest,
+            latestChecksum,
+            changelog: manifest.changelog,
+            reason,
+            tierChange: hasTierChange ? { from: installedTier, to: currentTier } : void 0
+          });
+        }
+      }
+      spinner.stop();
+      if (installUpdates.length === 0) {
+        logger.success("All content is up to date!");
+        return;
+      }
+      const agentGroups = /* @__PURE__ */ new Map();
+      for (const update of installUpdates) {
+        const existing = agentGroups.get(update.agentId) || [];
+        existing.push(update);
+        agentGroups.set(update.agentId, existing);
+      }
+      logger.info("Updates Available:");
+      logger.divider();
+      for (const [agentId, updates] of agentGroups) {
+        const first = updates[0];
+        if (first.tierChange) {
+          logger.info(
+            `${agentId}: ${first.tierChange.from} \u2192 ${first.tierChange.to} tier`
+          );
+        } else if (first.reason === "checksum") {
+          logger.info(
+            `${agentId}: v${first.currentVersion} (content updated)`
+          );
+        } else if (first.reason === "force") {
+          logger.info(
+            `${agentId}: v${first.currentVersion} (forced)`
+          );
+        } else {
+          logger.info(
+            `${agentId}: v${first.currentVersion} \u2192 v${first.latestVersion}`
+          );
+        }
+        if (first.changelog && first.reason === "version") {
+          logger.info("  Changelog:");
+          const lines = first.changelog.split("\n").slice(0, 5);
+          for (const line of lines) {
+            if (line.trim()) {
+              logger.info(`    ${line}`);
+            }
+          }
+        }
+      }
+      logger.newline();
+      logger.info(`${installUpdates.length} project(s) to update:`);
+      for (const update of installUpdates) {
+        logger.info(`  - ${update.install.path}`);
+      }
+      if (options.checkOnly) {
+        logger.newline();
+        logger.info("Run 'jawkit upgrade' to apply updates.");
+        return;
+      }
+      if (!options.yes) {
+        const proceed = await confirm3({
+          message: "Apply updates?",
+          default: true
+        });
+        if (!proceed) {
+          logger.info("Upgrade cancelled.");
+          return;
+        }
+      }
+      const tier = await authService.getUserTier();
+      const currentVersions = await config.get("contentVersions") ?? {};
+      for (const [agentId, updates] of agentGroups) {
+        logger.newline();
+        const agentSpinner = logger.spinner(
+          `Updating ${agentId} content...`
+        );
+        agentSpinner.start();
+        const agent = agentRegistry.get(agentId);
+        if (!agent) {
+          agentSpinner.fail(`Agent not found: ${agentId}`);
+          continue;
+        }
+        let totalUpdated = 0;
+        for (const update of updates) {
+          try {
+            const targetDir = `${update.install.path}/${agent.config.targetDirectory}`;
+            const result = await contentService.downloadAndExtractBundle(
+              agentId,
+              tier,
+              targetDir,
+              (progress) => {
+                if (progress.phase === "downloading") {
+                  agentSpinner.text = `Downloading ${agentId}: ${progress.percentage}%`;
+                } else {
+                  agentSpinner.text = `Extracting ${agentId}: ${progress.currentFile || ""}`;
+                }
+              }
+            );
+            await config.updateInstallation(update.install.path, {
+              contentVersion: update.latestVersion,
+              installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              files: result.filesExtracted,
+              tier,
+              checksum: update.latestChecksum
+            });
+            totalUpdated++;
+          } catch (err) {
+            logger.error(
+              `Failed to update ${update.install.path}: ${err instanceof Error ? err.message : "Unknown error"}`
+            );
+          }
+        }
+        const latestVersion = updates[0].latestVersion;
+        await config.set("contentVersions", {
+          ...currentVersions,
+          [agentId]: latestVersion
+        });
+        agentSpinner.succeed(
+          `Updated ${totalUpdated} project(s) to ${agentId} v${latestVersion}`
+        );
+      }
+      logger.newline();
+      logger.success("Upgrade complete!");
+      showPromoIfFree(tier, logger);
+    } catch (error) {
+      handleError(error, logger);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli.ts
+var program = new Command5();
+program.name("jawkit").description(description).version(version, "-v, --version", "Show CLI version");
+program.addCommand(initCommand());
+program.addCommand(authCommand());
+program.addCommand(versionCommand());
+program.addCommand(upgradeCommand());
+program.action(() => {
+  program.help();
+});
+program.parse();
+//# sourceMappingURL=cli.js.map