caik-cli 0.1.1 → 0.6.0

package/dist/chunk-US4CYDNS.js

@@ -0,0 +1,524 @@
+#!/usr/bin/env node
+
+// src/platform/claude-code.ts
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  readdirSync,
+  rmSync,
+  cpSync,
+  symlinkSync
+} from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+var MCP_KEY = "caik";
+var PLUGIN_NAME = "caik";
+var PLUGIN_MARKETPLACE = "caikdev";
+var PLUGIN_REPO = "caikdev/plugins";
+var PLUGIN_KEY = `${PLUGIN_NAME}@${PLUGIN_MARKETPLACE}`;
+var _pluginDetectedLogged = false;
+var PLUGIN_MANAGED_SKILLS = [
+  "caik",
+  "caik-discover",
+  "caik-observe",
+  "caik-improve",
+  "caik-status"
+];
+var ClaudeCodeAdapter = class {
+  name = "claude-code";
+  tier = "full-plugin";
+  get claudeDir() {
+    return join(homedir(), ".claude");
+  }
+  get mcpPath() {
+    return join(this.claudeDir, "mcp.json");
+  }
+  get settingsPath() {
+    return join(this.claudeDir, "settings.json");
+  }
+  get skillsDir() {
+    return join(this.claudeDir, "skills");
+  }
+  get localSkillsDir() {
+    return join(process.cwd(), ".claude", "skills");
+  }
+  get pluginsCacheDir() {
+    return join(this.claudeDir, "plugins", "cache");
+  }
+  // ---------------------------------------------------------------------------
+  // JSON helpers
+  // ---------------------------------------------------------------------------
+  readJson(path) {
+    if (!existsSync(path)) return {};
+    try {
+      const raw = readFileSync(path, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        return parsed;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  writeJson(path, data) {
+    const dir = join(path, "..");
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  }
+  // ---------------------------------------------------------------------------
+  // Plugin detection
+  // ---------------------------------------------------------------------------
+  /**
+   * Check if CAIK is installed as a Claude Code plugin.
+   * Looks for "caik" in enabledPlugins in settings.json, or for a caik
+   * directory in the plugins cache.
+   */
+  isPluginInstalled() {
+    const settings = this.readJson(this.settingsPath);
+    const enabledPlugins = settings.enabledPlugins;
+    if (enabledPlugins) {
+      for (const key of Object.keys(enabledPlugins)) {
+        if (key.toLowerCase().includes("caik") && enabledPlugins[key] !== false) {
+          return true;
+        }
+      }
+    }
+    if (existsSync(this.pluginsCacheDir)) {
+      try {
+        const publishers = readdirSync(this.pluginsCacheDir);
+        for (const publisher of publishers) {
+          const publisherDir = join(this.pluginsCacheDir, publisher);
+          const caikDir = join(publisherDir, "caik");
+          if (existsSync(caikDir)) {
+            return true;
+          }
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  /**
+   * Returns the current install method:
+   * - "plugin" if CAIK plugin is installed via marketplace
+   * - "manual" if CAIK is registered in mcp.json manually
+   * - "none" if not installed
+   */
+  getInstallMethod() {
+    if (this.isPluginInstalled()) return "plugin";
+    if (existsSync(this.mcpPath)) {
+      const config = this.readJson(this.mcpPath);
+      const servers = config.mcpServers;
+      if (servers && MCP_KEY in servers) return "manual";
+    }
+    return "none";
+  }
+  // ---------------------------------------------------------------------------
+  // Plugin installation
+  // ---------------------------------------------------------------------------
+  /**
+   * Resolve the path to the plugin source directory.
+   * In local dev, this is `packages/claude-code-plugin/` in the monorepo.
+   * Falls back to null if not found.
+   */
+  resolvePluginSource() {
+    const candidates = [
+      // Running from packages/cli/dist/ or packages/cli/src/
+      join(dirname(new URL(import.meta.url).pathname), "..", "..", "..", "claude-code-plugin"),
+      // Running via npx or global install — check cwd-based monorepo
+      join(process.cwd(), "packages", "claude-code-plugin")
+    ];
+    for (const candidate of candidates) {
+      const pluginJson = join(candidate, ".claude-plugin", "plugin.json");
+      if (existsSync(pluginJson)) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+  /**
+   * Programmatically install the CAIK plugin into Claude Code.
+   *
+   * This replicates what `/plugin marketplace add caikdev/caik` + `/plugin install caik`
+   * would do:
+   *
+   * 1. Register the `caikdev` marketplace in `known_marketplaces.json`
+   * 2. Copy the plugin files into `~/.claude/plugins/cache/caikdev/caik/<version>/`
+   * 3. Register the plugin in `installed_plugins.json`
+   * 4. Enable the plugin in `settings.json` under `enabledPlugins`
+   *
+   * Returns true if successful, false if plugin source files could not be found.
+   */
+  installPlugin() {
+    const source = this.resolvePluginSource();
+    if (!source) {
+      return false;
+    }
+    let version = "0.1.0";
+    try {
+      const pluginMeta = JSON.parse(
+        readFileSync(join(source, ".claude-plugin", "plugin.json"), "utf-8")
+      );
+      if (typeof pluginMeta.version === "string") {
+        version = pluginMeta.version;
+      }
+    } catch {
+    }
+    const pluginsDir = join(this.claudeDir, "plugins");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const marketplacesPath = join(pluginsDir, "known_marketplaces.json");
+    const marketplaces = this.readJson(marketplacesPath);
+    if (!marketplaces[PLUGIN_MARKETPLACE]) {
+      marketplaces[PLUGIN_MARKETPLACE] = {
+        source: {
+          source: "github",
+          repo: PLUGIN_REPO
+        },
+        installLocation: join(pluginsDir, "marketplaces", PLUGIN_MARKETPLACE),
+        lastUpdated: now
+      };
+      this.writeJson(marketplacesPath, marketplaces);
+    }
+    const marketplaceDir = join(pluginsDir, "marketplaces", PLUGIN_MARKETPLACE);
+    const marketplaceCatalogDir = join(marketplaceDir, ".claude-plugin");
+    if (!existsSync(join(marketplaceCatalogDir, "marketplace.json"))) {
+      mkdirSync(marketplaceCatalogDir, { recursive: true });
+      const catalog = {
+        name: PLUGIN_MARKETPLACE,
+        description: "CAIK \u2014 The package manager for AI agents",
+        plugins: [
+          {
+            name: PLUGIN_NAME,
+            description: "Search, install, and share AI artifacts from the CAIK community registry",
+            source: `./${PLUGIN_NAME}`
+          }
+        ]
+      };
+      writeFileSync(join(marketplaceCatalogDir, "marketplace.json"), JSON.stringify(catalog, null, 2), "utf-8");
+    }
+    const marketplacePluginDir = join(marketplaceDir, PLUGIN_NAME);
+    if (!existsSync(marketplacePluginDir)) {
+      try {
+        symlinkSync(source, marketplacePluginDir);
+      } catch {
+        cpSync(source, marketplacePluginDir, { recursive: true, force: true });
+      }
+    }
+    const installPath = join(this.pluginsCacheDir, PLUGIN_MARKETPLACE, PLUGIN_NAME, version);
+    if (!existsSync(installPath)) {
+      mkdirSync(installPath, { recursive: true });
+    }
+    try {
+      cpSync(source, installPath, { recursive: true, force: true });
+    } catch (err) {
+      const essentialDirs = [".claude-plugin", "hooks", "skills"];
+      const essentialFiles = [".mcp.json"];
+      for (const dir of essentialDirs) {
+        const srcDir = join(source, dir);
+        const destDir = join(installPath, dir);
+        if (existsSync(srcDir)) {
+          try {
+            cpSync(srcDir, destDir, { recursive: true, force: true });
+          } catch {
+          }
+        }
+      }
+      for (const file of essentialFiles) {
+        const srcFile = join(source, file);
+        const destFile = join(installPath, file);
+        if (existsSync(srcFile)) {
+          try {
+            const content = readFileSync(srcFile, "utf-8");
+            const destDir = join(destFile, "..");
+            if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+            writeFileSync(destFile, content, "utf-8");
+          } catch {
+          }
+        }
+      }
+      if (!existsSync(join(installPath, ".claude-plugin", "plugin.json"))) {
+        throw err;
+      }
+    }
+    const installedPath = join(pluginsDir, "installed_plugins.json");
+    const installedData = this.readJson(installedPath);
+    if (!installedData.version) installedData.version = 2;
+    if (!installedData.plugins) installedData.plugins = {};
+    installedData.plugins[PLUGIN_KEY] = [
+      {
+        scope: "user",
+        installPath,
+        version,
+        installedAt: now,
+        lastUpdated: now,
+        gitCommitSha: ""
+      }
+    ];
+    this.writeJson(installedPath, installedData);
+    const settings = this.readJson(this.settingsPath);
+    const enabledPlugins = settings.enabledPlugins ?? {};
+    enabledPlugins[PLUGIN_KEY] = true;
+    settings.enabledPlugins = enabledPlugins;
+    const extraMarketplaces = settings.extraKnownMarketplaces ?? {};
+    if (!extraMarketplaces[PLUGIN_MARKETPLACE]) {
+      extraMarketplaces[PLUGIN_MARKETPLACE] = {
+        source: {
+          source: "github",
+          repo: PLUGIN_REPO
+        }
+      };
+      settings.extraKnownMarketplaces = extraMarketplaces;
+    }
+    this.writeJson(this.settingsPath, settings);
+    return true;
+  }
+  // ---------------------------------------------------------------------------
+  // Manual registration cleanup (when plugin is installed)
+  // ---------------------------------------------------------------------------
+  /**
+   * Remove manual CAIK registrations that are superseded by the plugin.
+   * Returns a summary of what was cleaned up.
+   */
+  cleanupManualRegistration() {
+    const cleaned = [];
+    if (existsSync(this.settingsPath)) {
+      const settings = this.readJson(this.settingsPath);
+      const hooks = settings.hooks;
+      if (hooks) {
+        let removedHooks = 0;
+        for (const event of Object.keys(hooks)) {
+          const entries = hooks[event];
+          if (!Array.isArray(entries)) continue;
+          const before = entries.length;
+          hooks[event] = entries.filter((group) => {
+            if (typeof group === "object" && group !== null) {
+              const g = group;
+              if (Array.isArray(g.hooks)) {
+                const hasCAIK = g.hooks.some(
+                  (h) => typeof h.command === "string" && h.command.toLowerCase().includes("caik")
+                );
+                if (hasCAIK) return false;
+              }
+              if ("command" in g) {
+                return !g.command.toLowerCase().includes("caik");
+              }
+            }
+            return true;
+          });
+          removedHooks += before - hooks[event].length;
+          if (hooks[event].length === 0) {
+            delete hooks[event];
+          }
+        }
+        if (removedHooks > 0) {
+          if (Object.keys(hooks).length === 0) {
+            delete settings.hooks;
+          } else {
+            settings.hooks = hooks;
+          }
+          this.writeJson(this.settingsPath, settings);
+          cleaned.push(`Removed ${removedHooks} CAIK hook(s) from settings.json`);
+        }
+      }
+    }
+    if (existsSync(this.mcpPath)) {
+      const config = this.readJson(this.mcpPath);
+      const servers = config.mcpServers;
+      if (servers && MCP_KEY in servers) {
+        delete servers[MCP_KEY];
+        config.mcpServers = servers;
+        this.writeJson(this.mcpPath, config);
+        cleaned.push("Removed CAIK entry from mcp.json");
+      }
+    }
+    for (const slug of PLUGIN_MANAGED_SKILLS) {
+      const skillDir = join(this.skillsDir, slug);
+      if (existsSync(skillDir)) {
+        try {
+          rmSync(skillDir, { recursive: true, force: true });
+          cleaned.push(`Removed old skill directory: ${slug}`);
+        } catch {
+        }
+      }
+    }
+    return cleaned;
+  }
+  // ---------------------------------------------------------------------------
+  // PlatformAdapter implementation
+  // ---------------------------------------------------------------------------
+  async detect() {
+    if (!existsSync(this.claudeDir)) return null;
+    const hasSettings = existsSync(this.settingsPath);
+    const hasMcp = existsSync(this.mcpPath);
+    const hasStatsig = existsSync(join(this.claudeDir, "statsig"));
+    if (!hasSettings && !hasMcp && !hasStatsig) return null;
+    const configPaths = [];
+    if (hasSettings) configPaths.push(this.settingsPath);
+    if (hasMcp) configPaths.push(this.mcpPath);
+    return {
+      name: this.name,
+      tier: this.tier,
+      configPaths,
+      capabilities: { hooks: true, mcp: true, skills: true }
+    };
+  }
+  async registerMcp(serverConfig) {
+    if (this.isPluginInstalled()) {
+      if (!_pluginDetectedLogged) {
+        console.log("CAIK plugin detected \u2014 hooks, MCP, and skills managed by plugin.");
+        _pluginDetectedLogged = true;
+      }
+      return;
+    }
+    const config = this.readJson(this.mcpPath);
+    const servers = config.mcpServers ?? {};
+    const serverKey = serverConfig.key ?? MCP_KEY;
+    servers[serverKey] = {
+      command: serverConfig.command,
+      args: serverConfig.args,
+      ...serverConfig.env && Object.keys(serverConfig.env).length > 0 ? { env: serverConfig.env } : {}
+    };
+    config.mcpServers = servers;
+    this.writeJson(this.mcpPath, config);
+  }
+  async unregisterMcp() {
+    if (!existsSync(this.mcpPath)) return;
+    const config = this.readJson(this.mcpPath);
+    const servers = config.mcpServers;
+    if (!servers || !(MCP_KEY in servers)) return;
+    delete servers[MCP_KEY];
+    config.mcpServers = servers;
+    this.writeJson(this.mcpPath, config);
+  }
+  async registerHooks(hookConfig) {
+    if (this.isPluginInstalled()) {
+      if (!_pluginDetectedLogged) {
+        console.log("CAIK plugin detected \u2014 hooks, MCP, and skills managed by plugin.");
+        _pluginDetectedLogged = true;
+      }
+      return;
+    }
+    const settings = this.readJson(this.settingsPath);
+    const existingHooks = settings.hooks ?? {};
+    for (const [event, entries] of Object.entries(hookConfig.hooks)) {
+      const newEntries = Array.isArray(entries) ? entries : [entries];
+      const existing = Array.isArray(existingHooks[event]) ? existingHooks[event] : [];
+      const filtered = existing.filter((group) => {
+        if (typeof group === "object" && group !== null) {
+          const g = group;
+          if (Array.isArray(g.hooks)) {
+            const hasCAIK = g.hooks.some(
+              (h) => typeof h.command === "string" && h.command.toLowerCase().includes("caik")
+            );
+            if (hasCAIK) return false;
+          }
+          if ("command" in g) {
+            return !g.command.toLowerCase().includes("caik");
+          }
+        }
+        return true;
+      });
+      const wrappedEntries = newEntries.map((entry) => {
+        if (typeof entry === "object" && entry !== null) {
+          const e = entry;
+          const hookEntry = {
+            type: "command",
+            timeout: 10,
+            ...e
+          };
+          return { hooks: [hookEntry] };
+        }
+        return entry;
+      });
+      existingHooks[event] = [...filtered, ...wrappedEntries];
+    }
+    settings.hooks = existingHooks;
+    this.writeJson(this.settingsPath, settings);
+  }
+  async unregisterHooks() {
+    if (!existsSync(this.settingsPath)) return;
+    const settings = this.readJson(this.settingsPath);
+    const hooks = settings.hooks;
+    if (!hooks) return;
+    for (const event of Object.keys(hooks)) {
+      const entries = hooks[event];
+      if (!Array.isArray(entries)) continue;
+      hooks[event] = entries.filter((group) => {
+        if (typeof group === "object" && group !== null) {
+          const g = group;
+          if (Array.isArray(g.hooks)) {
+            const hasCAIK = g.hooks.some(
+              (h) => typeof h.command === "string" && h.command.includes("caik")
+            );
+            if (hasCAIK) return false;
+          }
+          if ("command" in g) {
+            return !g.command.includes("caik");
+          }
+        }
+        return true;
+      });
+      if (hooks[event].length === 0) {
+        delete hooks[event];
+      }
+    }
+    if (Object.keys(hooks).length === 0) {
+      delete settings.hooks;
+    } else {
+      settings.hooks = hooks;
+    }
+    this.writeJson(this.settingsPath, settings);
+  }
+  async installSkill(slug, content, files, local) {
+    if (!local && this.isPluginInstalled() && PLUGIN_MANAGED_SKILLS.includes(slug)) {
+      return;
+    }
+    const baseDir = local ? this.localSkillsDir : this.skillsDir;
+    const skillDir = join(baseDir, slug);
+    if (!existsSync(skillDir)) {
+      mkdirSync(skillDir, { recursive: true });
+    }
+    writeFileSync(join(skillDir, "SKILL.md"), content, "utf-8");
+    if (files) {
+      for (const file of files) {
+        const filePath = join(skillDir, file.path);
+        const fileDir = join(filePath, "..");
+        if (!existsSync(fileDir)) {
+          mkdirSync(fileDir, { recursive: true });
+        }
+        writeFileSync(filePath, file.content, "utf-8");
+      }
+    }
+  }
+  async uninstallSkill(slug, local) {
+    const baseDir = local ? this.localSkillsDir : this.skillsDir;
+    const skillDir = join(baseDir, slug);
+    if (!existsSync(skillDir)) return;
+    try {
+      rmSync(skillDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  getConfigPath() {
+    return this.mcpPath;
+  }
+  async readConfig() {
+    return this.readJson(this.mcpPath);
+  }
+  async isRegistered() {
+    if (this.isPluginInstalled()) return true;
+    if (!existsSync(this.mcpPath)) return false;
+    const config = this.readJson(this.mcpPath);
+    const servers = config.mcpServers;
+    return !!servers && MCP_KEY in servers;
+  }
+};
+
+export {
+  ClaudeCodeAdapter
+};

package/dist/chunk-ZLRN7Q7C.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __esm,
+  __export,
+  __toCommonJS
+};

package/dist/claude-code-6DF4YARB.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import {
+  ClaudeCodeAdapter
+} from "./chunk-US4CYDNS.js";
+import "./chunk-ZLRN7Q7C.js";
+export {
+  ClaudeCodeAdapter
+};

package/dist/config-CS7734SA.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import {
+  CONTRIBUTION_LEVELS,
+  getApiKey,
+  getConfigDir,
+  getConfigPath,
+  getOrCreateInstallationId,
+  readConfig,
+  resolveConfig,
+  setApiKey,
+  writeConfig
+} from "./chunk-KYTHKH6V.js";
+import "./chunk-ZLRN7Q7C.js";
+export {
+  CONTRIBUTION_LEVELS,
+  getApiKey,
+  getConfigDir,
+  getConfigPath,
+  getOrCreateInstallationId,
+  readConfig,
+  resolveConfig,
+  setApiKey,
+  writeConfig
+};

package/dist/correction-classifier-TLPKRNLI.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import "./chunk-ZLRN7Q7C.js";
+
+// src/correction-classifier.ts
+var MIN_LENGTH = 2;
+var MAX_LENGTH = 500;
+function shouldClassify(prompt) {
+  if (!prompt || prompt.length < MIN_LENGTH) return false;
+  if (prompt.length > MAX_LENGTH) return false;
+  if (prompt.includes("```")) return false;
+  return true;
+}
+var POSITIVE_PREFIXES = [
+  "yes",
+  "perfect",
+  "looks good",
+  "thanks",
+  "thank you",
+  "great",
+  "awesome",
+  "nice",
+  "good",
+  "correct",
+  "exactly",
+  "that works",
+  "that's right",
+  "lgtm"
+];
+function isPositive(lower) {
+  return POSITIVE_PREFIXES.some((p) => lower.startsWith(p));
+}
+function isQuestion(prompt) {
+  return prompt.trimEnd().endsWith("?");
+}
+function looksLikeCode(lower) {
+  if (/\b\w+_(?:wrong|no|bad|fail)\b/.test(lower)) return true;
+  if (/\b(?:wrong|no|bad|fail)_\w+\b/.test(lower)) return true;
+  if (/[=(){}[\];]/.test(lower) && lower.length < 100) return true;
+  return false;
+}
+var PATTERNS = [
+  // ── HIGH confidence: explicit rejection ───────────────────────────
+  { regex: /\bthat'?s\s+(?:not\s+)?wrong\b/, correctionType: "output_rejected", confidence: "high" },
+  { regex: /\bthat\s+is\s+(?:not\s+)?wrong\b/, correctionType: "output_rejected", confidence: "high" },
+  { regex: /\bnot\s+what\s+i\s+(?:asked|wanted|meant|need)\b/, correctionType: "output_rejected", confidence: "high" },
+  { regex: /\bi\s+said\b/, correctionType: "output_rejected", confidence: "high" },
+  { regex: /\bi\s+already\s+told\s+you\b/, correctionType: "output_rejected", confidence: "high" },
+  { regex: /\bthat'?s\s+not\s+(?:right|correct)\b/, correctionType: "output_rejected", confidence: "high" },
+  // ── MEDIUM confidence: redirection → approach_changed ─────────────
+  { regex: /\binstead\b/, correctionType: "approach_changed", confidence: "medium" },
+  { regex: /\bactually[\s,]/, correctionType: "approach_changed", confidence: "medium" },
+  { regex: /\bdon'?t\s+use\b/, correctionType: "approach_changed", confidence: "medium" },
+  { regex: /\buse\s+a\s+different\b/, correctionType: "approach_changed", confidence: "medium" },
+  { regex: /\bdifferent\s+approach\b/, correctionType: "approach_changed", confidence: "medium" },
+  { regex: /\bnot\s+like\s+that\b/, correctionType: "approach_changed", confidence: "medium" },
+  // ── MEDIUM confidence: retry → output_rejected ────────────────────
+  { regex: /\btry\s+again\b/, correctionType: "output_rejected", confidence: "medium" },
+  { regex: /\bredo\s+(?:this|that|it)\b/, correctionType: "output_rejected", confidence: "medium" },
+  { regex: /\bstart\s+over\b/, correctionType: "output_rejected", confidence: "medium" },
+  // ── MEDIUM confidence: modification → output_modified ─────────────
+  { regex: /\bmake\s+it\s+\w+/, correctionType: "output_modified", confidence: "medium" },
+  { regex: /\bfix\s+(?:the|this|that|it)\b/, correctionType: "output_modified", confidence: "medium" },
+  // ── MEDIUM confidence: scope → scope_adjusted ─────────────────────
+  { regex: /\btoo\s+(?:verbose|much|long|detailed)\b/, correctionType: "scope_adjusted", confidence: "medium" },
+  { regex: /\bi\s+only\s+need\b/, correctionType: "scope_adjusted", confidence: "medium" },
+  { regex: /\bkeep\s+it\s+(?:concise|brief|short|simple)\b/, correctionType: "scope_adjusted", confidence: "medium" },
+  // ── MEDIUM confidence: format → format_changed ────────────────────
+  { regex: /\bformat\s+(?:it|the|as|this|that)\b/, correctionType: "format_changed", confidence: "medium" },
+  // ── LOW confidence: bare negatives (too ambiguous to log) ─────────
+  { regex: /^no[.,!]?\s*$/i, correctionType: "output_rejected", confidence: "low" },
+  { regex: /^wrong[.,!]?\s*$/i, correctionType: "output_rejected", confidence: "low" }
+];
+function classifyPrompt(prompt) {
+  if (!shouldClassify(prompt)) return null;
+  const lower = prompt.toLowerCase().trim();
+  if (isPositive(lower)) return null;
+  if (isQuestion(prompt)) return null;
+  if (looksLikeCode(lower)) return null;
+  for (const pattern of PATTERNS) {
+    if (pattern.regex.test(lower)) {
+      if (pattern.confidence === "low") return null;
+      return {
+        correctionType: pattern.correctionType,
+        confidence: pattern.confidence
+      };
+    }
+  }
+  return null;
+}
+export {
+  classifyPrompt,
+  shouldClassify
+};

package/dist/cursor-Z4XXDCAM.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import {
+  CursorAdapter
+} from "./chunk-T73Z5UMA.js";
+import "./chunk-ZLRN7Q7C.js";
+export {
+  CursorAdapter
+};