claudish 1.7.1 → 2.0.0

package/dist/index.js

@@ -331,14 +331,14 @@ function getAvailableModels() {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync, copyFileSync } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { dirname as dirname2, join as join3 } from "node:path";
 var __filename3 = fileURLToPath2(import.meta.url);
 var __dirname3 = dirname2(__filename3);
 var packageJson = JSON.parse(readFileSync2(join3(__dirname3, "../package.json"), "utf-8"));
 var VERSION = packageJson.version;
-function parseArgs(args) {
+async function parseArgs(args) {
   const config = {
     model: undefined,
     autoApprove: true,
@@ -429,8 +429,21 @@ function parseArgs(args) {
     } else if (arg === "--help" || arg === "-h") {
       printHelp();
       process.exit(0);
+    } else if (arg === "--help-ai") {
+      printAIAgentGuide();
+      process.exit(0);
+    } else if (arg === "--init") {
+      await initializeClaudishSkill();
+      process.exit(0);
     } else if (arg === "--list-models") {
-      printAvailableModels();
+      const hasJsonFlag = args.includes("--json");
+      const forceUpdate = args.includes("--force-update");
+      await checkAndUpdateModelsCache(forceUpdate);
+      if (hasJsonFlag) {
+        printAvailableModelsJSON();
+      } else {
+        printAvailableModels();
+      }
       process.exit(0);
     } else {
       config.claudeArgs = args.slice(i);
@@ -478,6 +491,164 @@ function parseArgs(args) {
   }
   return config;
 }
+var CACHE_MAX_AGE_DAYS = 2;
+var MODELS_JSON_PATH = join3(__dirname3, "../recommended-models.json");
+function isCacheStale() {
+  if (!existsSync2(MODELS_JSON_PATH)) {
+    return true;
+  }
+  try {
+    const jsonContent = readFileSync2(MODELS_JSON_PATH, "utf-8");
+    const data = JSON.parse(jsonContent);
+    if (!data.lastUpdated) {
+      return true;
+    }
+    const lastUpdated = new Date(data.lastUpdated);
+    const now = new Date;
+    const ageInDays = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
+    return ageInDays > CACHE_MAX_AGE_DAYS;
+  } catch (error) {
+    return true;
+  }
+}
+async function updateModelsFromOpenRouter() {
+  console.error("\uD83D\uDD04 Updating model recommendations from OpenRouter...");
+  try {
+    const topWeeklyProgrammingModels = [
+      "x-ai/grok-code-fast-1",
+      "anthropic/claude-sonnet-4.5",
+      "google/gemini-2.5-flash",
+      "minimax/minimax-m2",
+      "anthropic/claude-sonnet-4",
+      "z-ai/glm-4.6",
+      "anthropic/claude-haiku-4.5",
+      "openai/gpt-5",
+      "qwen/qwen3-vl-235b-a22b-instruct",
+      "openrouter/polaris-alpha"
+    ];
+    const apiResponse = await fetch("https://openrouter.ai/api/v1/models");
+    if (!apiResponse.ok) {
+      throw new Error(`OpenRouter API returned ${apiResponse.status}`);
+    }
+    const openrouterData = await apiResponse.json();
+    const allModels = openrouterData.data;
+    const modelMap = new Map;
+    for (const model of allModels) {
+      modelMap.set(model.id, model);
+    }
+    const recommendations = [];
+    const providers = new Set;
+    for (const modelId of topWeeklyProgrammingModels) {
+      const provider = modelId.split("/")[0];
+      if (provider === "anthropic") {
+        continue;
+      }
+      if (providers.has(provider)) {
+        continue;
+      }
+      const model = modelMap.get(modelId);
+      if (!model) {
+        console.error(`⚠️  Model ${modelId} not found in OpenRouter API (including with limited metadata)`);
+        recommendations.push({
+          id: modelId,
+          name: modelId.split("/")[1].replace(/-/g, " ").replace(/\b\w/g, (l) => l.toUpperCase()),
+          description: `${modelId} (metadata pending - not yet available in API)`,
+          provider: provider.charAt(0).toUpperCase() + provider.slice(1),
+          category: "programming",
+          priority: recommendations.length + 1,
+          pricing: {
+            input: "N/A",
+            output: "N/A",
+            average: "N/A"
+          },
+          context: "N/A",
+          maxOutputTokens: null,
+          modality: "text->text",
+          supportsTools: false,
+          supportsReasoning: false,
+          supportsVision: false,
+          isModerated: false,
+          recommended: true
+        });
+        providers.add(provider);
+        continue;
+      }
+      const name = model.name || modelId;
+      const description = model.description || `${name} model`;
+      const architecture = model.architecture || {};
+      const topProvider = model.top_provider || {};
+      const supportedParams = model.supported_parameters || [];
+      const promptPrice = parseFloat(model.pricing?.prompt || "0");
+      const completionPrice = parseFloat(model.pricing?.completion || "0");
+      const inputPrice = promptPrice > 0 ? `$${(promptPrice * 1e6).toFixed(2)}/1M` : "FREE";
+      const outputPrice = completionPrice > 0 ? `$${(completionPrice * 1e6).toFixed(2)}/1M` : "FREE";
+      const avgPrice = promptPrice > 0 || completionPrice > 0 ? `$${((promptPrice + completionPrice) / 2 * 1e6).toFixed(2)}/1M` : "FREE";
+      let category = "programming";
+      const lowerDesc = description.toLowerCase() + " " + name.toLowerCase();
+      if (lowerDesc.includes("vision") || lowerDesc.includes("vl-") || lowerDesc.includes("multimodal")) {
+        category = "vision";
+      } else if (lowerDesc.includes("reason")) {
+        category = "reasoning";
+      }
+      recommendations.push({
+        id: modelId,
+        name,
+        description,
+        provider: provider.charAt(0).toUpperCase() + provider.slice(1),
+        category,
+        priority: recommendations.length + 1,
+        pricing: {
+          input: inputPrice,
+          output: outputPrice,
+          average: avgPrice
+        },
+        context: topProvider.context_length ? `${Math.floor(topProvider.context_length / 1000)}K` : "N/A",
+        maxOutputTokens: topProvider.max_completion_tokens || null,
+        modality: architecture.modality || "text->text",
+        supportsTools: supportedParams.includes("tools") || supportedParams.includes("tool_choice"),
+        supportsReasoning: supportedParams.includes("reasoning") || supportedParams.includes("include_reasoning"),
+        supportsVision: (architecture.input_modalities || []).includes("image") || (architecture.input_modalities || []).includes("video"),
+        isModerated: topProvider.is_moderated || false,
+        recommended: true
+      });
+      providers.add(provider);
+    }
+    let version = "1.1.5";
+    if (existsSync2(MODELS_JSON_PATH)) {
+      try {
+        const existing = JSON.parse(readFileSync2(MODELS_JSON_PATH, "utf-8"));
+        version = existing.version || version;
+      } catch {}
+    }
+    const updatedData = {
+      version,
+      lastUpdated: new Date().toISOString().split("T")[0],
+      source: "https://openrouter.ai/models?categories=programming&fmt=cards&order=top-weekly",
+      models: recommendations
+    };
+    writeFileSync2(MODELS_JSON_PATH, JSON.stringify(updatedData, null, 2), "utf-8");
+    console.error(`✅ Updated ${recommendations.length} models (last updated: ${updatedData.lastUpdated})`);
+  } catch (error) {
+    console.error(`❌ Failed to update models: ${error instanceof Error ? error.message : String(error)}`);
+    console.error("   Using cached models (if available)");
+  }
+}
+async function checkAndUpdateModelsCache(forceUpdate = false) {
+  if (forceUpdate) {
+    console.error("\uD83D\uDD04 Force update requested...");
+    await updateModelsFromOpenRouter();
+    return;
+  }
+  if (isCacheStale()) {
+    console.error("⚠️  Model cache is stale (>2 days old), updating...");
+    await updateModelsFromOpenRouter();
+  } else {
+    try {
+      const data = JSON.parse(readFileSync2(MODELS_JSON_PATH, "utf-8"));
+      console.error(`✓ Using cached models (last updated: ${data.lastUpdated})`);
+    } catch {}
+  }
+}
 function printVersion() {
   console.log(`claudish version ${VERSION}`);
 }
@@ -505,9 +676,13 @@ OPTIONS:
   --cost-tracker           Enable cost tracking for API usage (NB!)
   --audit-costs            Show cost analysis report
   --reset-costs            Reset accumulated cost statistics
-  --list-models            List available OpenRouter models
+  --list-models            List available OpenRouter models (auto-updates if stale >2 days)
+  --list-models --json     Output model list in JSON format
+  --force-update           Force refresh model cache from OpenRouter API
   --version                Show version information
   -h, --help               Show this help message
+  --help-ai                Show AI agent usage guide (file-based patterns, sub-agents)
+  --init                   Install Claudish skill in current project (.claude/skills/)
 
 MODES:
   • Interactive mode (default): Shows model selector, starts persistent session
@@ -568,30 +743,185 @@ EXAMPLES:
   claudish --verbose "analyze code structure"
 
 AVAILABLE MODELS:
-  Run: claudish --list-models
+  List models: claudish --list-models
+  JSON output: claudish --list-models --json
+  Force update: claudish --list-models --force-update
+  (Cache auto-updates every 2 days)
 
 MORE INFO:
   GitHub: https://github.com/MadAppGang/claude-code
   OpenRouter: https://openrouter.ai
 `);
 }
+function printAIAgentGuide() {
+  try {
+    const guidePath = join3(__dirname3, "../AI_AGENT_GUIDE.md");
+    const guideContent = readFileSync2(guidePath, "utf-8");
+    console.log(guideContent);
+  } catch (error) {
+    console.error("Error reading AI Agent Guide:");
+    console.error(error instanceof Error ? error.message : String(error));
+    console.error(`
+The guide should be located at: AI_AGENT_GUIDE.md`);
+    console.error("You can also view it online at:");
+    console.error("https://github.com/MadAppGang/claude-code/blob/main/mcp/claudish/AI_AGENT_GUIDE.md");
+    process.exit(1);
+  }
+}
+async function initializeClaudishSkill() {
+  console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
+`);
+  const cwd = process.cwd();
+  const claudeDir = join3(cwd, ".claude");
+  const skillsDir = join3(claudeDir, "skills");
+  const claudishSkillDir = join3(skillsDir, "claudish-usage");
+  const skillFile = join3(claudishSkillDir, "SKILL.md");
+  if (existsSync2(skillFile)) {
+    console.log("✅ Claudish skill already installed at:");
+    console.log(`   ${skillFile}
+`);
+    console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
+    return;
+  }
+  const sourceSkillPath = join3(__dirname3, "../skills/claudish-usage/SKILL.md");
+  if (!existsSync2(sourceSkillPath)) {
+    console.error("❌ Error: Claudish skill file not found in installation.");
+    console.error(`   Expected at: ${sourceSkillPath}`);
+    console.error(`
+\uD83D\uDCA1 Try reinstalling Claudish:`);
+    console.error("   npm install -g claudish@latest");
+    process.exit(1);
+  }
+  try {
+    if (!existsSync2(claudeDir)) {
+      mkdirSync(claudeDir, { recursive: true });
+      console.log("\uD83D\uDCC1 Created .claude/ directory");
+    }
+    if (!existsSync2(skillsDir)) {
+      mkdirSync(skillsDir, { recursive: true });
+      console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
+    }
+    if (!existsSync2(claudishSkillDir)) {
+      mkdirSync(claudishSkillDir, { recursive: true });
+      console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
+    }
+    copyFileSync(sourceSkillPath, skillFile);
+    console.log("✅ Installed Claudish skill at:");
+    console.log(`   ${skillFile}
+`);
+    console.log("━".repeat(60));
+    console.log(`
+\uD83C\uDF89 Claudish skill installed successfully!
+`);
+    console.log(`\uD83D\uDCCB Next steps:
+`);
+    console.log("1. Reload Claude Code to discover the skill");
+    console.log("   - Restart Claude Code, or");
+    console.log(`   - Re-open your project
+`);
+    console.log("2. Use Claudish with external models:");
+    console.log('   - User: "use Grok to implement feature X"');
+    console.log(`   - Claude will automatically use the skill
+`);
+    console.log("\uD83D\uDCA1 The skill enforces best practices:");
+    console.log("   ✅ Mandatory sub-agent delegation");
+    console.log("   ✅ File-based instruction patterns");
+    console.log(`   ✅ Context window protection
+`);
+    console.log(`\uD83D\uDCD6 For more info: claudish --help-ai
+`);
+    console.log("━".repeat(60));
+  } catch (error) {
+    console.error(`
+❌ Error installing Claudish skill:`);
+    console.error(error instanceof Error ? error.message : String(error));
+    console.error(`
+\uD83D\uDCA1 Make sure you have write permissions in the current directory.`);
+    process.exit(1);
+  }
+}
 function printAvailableModels() {
+  let lastUpdated = "unknown";
+  let models = [];
+  try {
+    if (existsSync2(MODELS_JSON_PATH)) {
+      const data = JSON.parse(readFileSync2(MODELS_JSON_PATH, "utf-8"));
+      lastUpdated = data.lastUpdated || "unknown";
+      models = data.models || [];
+    }
+  } catch {
+    const basicModels = getAvailableModels();
+    const modelInfo = loadModelInfo();
+    for (const model of basicModels) {
+      const info = modelInfo[model];
+      console.log(`  ${model}`);
+      console.log(`    ${info.name} - ${info.description}`);
+      console.log("");
+    }
+    return;
+  }
   console.log(`
-Available OpenRouter Models (in priority order):
+Available OpenRouter Models (last updated: ${lastUpdated}):
 `);
-  const models = getAvailableModels();
-  const modelInfo = loadModelInfo();
+  console.log("  Model                          Provider    Pricing     Context  Capabilities");
+  console.log("  " + "─".repeat(86));
   for (const model of models) {
-    const info = modelInfo[model];
-    console.log(`  ${model}`);
-    console.log(`    ${info.name} - ${info.description}`);
-    console.log("");
-  }
+    const modelId = model.id.length > 30 ? model.id.substring(0, 27) + "..." : model.id;
+    const modelIdPadded = modelId.padEnd(30);
+    const provider = model.provider.length > 10 ? model.provider.substring(0, 7) + "..." : model.provider;
+    const providerPadded = provider.padEnd(10);
+    let pricing = model.pricing?.average || "N/A";
+    if (pricing.includes("-1000000")) {
+      pricing = "varies";
+    } else if (pricing === "$0.00/1M" || pricing === "FREE") {
+      pricing = "FREE";
+    }
+    const pricingPadded = pricing.padEnd(10);
+    const context = model.context || "N/A";
+    const contextPadded = context.padEnd(7);
+    const tools = model.supportsTools ? "\uD83D\uDD27" : "  ";
+    const reasoning = model.supportsReasoning ? "\uD83E\uDDE0" : "  ";
+    const vision = model.supportsVision ? "\uD83D\uDC41️ " : "  ";
+    const capabilities = `${tools} ${reasoning} ${vision}`;
+    console.log(`  ${modelIdPadded} ${providerPadded} ${pricingPadded} ${contextPadded} ${capabilities}`);
+  }
+  console.log("");
+  console.log("  Capabilities: \uD83D\uDD27 Tools  \uD83E\uDDE0 Reasoning  \uD83D\uDC41️  Vision");
+  console.log("");
   console.log("Set default with: export CLAUDISH_MODEL=<model>");
   console.log("               or: export ANTHROPIC_MODEL=<model>");
-  console.log(`Or use: claudish --model <model> ...
+  console.log("Or use: claudish --model <model> ...");
+  console.log(`
+Force update: claudish --list-models --force-update
 `);
 }
+function printAvailableModelsJSON() {
+  const jsonPath = join3(__dirname3, "../recommended-models.json");
+  try {
+    const jsonContent = readFileSync2(jsonPath, "utf-8");
+    const data = JSON.parse(jsonContent);
+    console.log(JSON.stringify(data, null, 2));
+  } catch (error) {
+    const models = getAvailableModels();
+    const modelInfo = loadModelInfo();
+    const output = {
+      version: VERSION,
+      lastUpdated: new Date().toISOString().split("T")[0],
+      source: "runtime",
+      models: models.filter((m) => m !== "custom").map((modelId) => {
+        const info = modelInfo[modelId];
+        return {
+          id: modelId,
+          name: info.name,
+          description: info.description,
+          provider: info.provider,
+          priority: info.priority
+        };
+      })
+    };
+    console.log(JSON.stringify(output, null, 2));
+  }
+}
 
 // src/index.ts
 init_config();
@@ -742,7 +1072,7 @@ async function selectModelInteractively() {
 }
 
 // src/logger.ts
-import { writeFileSync as writeFileSync2, appendFile, existsSync as existsSync2, mkdirSync } from "fs";
+import { writeFileSync as writeFileSync3, appendFile, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
 import { join as join4 } from "path";
 var logFilePath = null;
 var logLevel = "info";
@@ -773,7 +1103,7 @@ function scheduleFlush() {
       flushTimer = null;
     }
     if (logFilePath && logBuffer.length > 0) {
-      writeFileSync2(logFilePath, logBuffer.join(""), { flag: "a" });
+      writeFileSync3(logFilePath, logBuffer.join(""), { flag: "a" });
       logBuffer = [];
     }
   });
@@ -789,12 +1119,12 @@ function initLogger(debugMode, level = "info") {
   }
   logLevel = level;
   const logsDir = join4(process.cwd(), "logs");
-  if (!existsSync2(logsDir)) {
-    mkdirSync(logsDir, { recursive: true });
+  if (!existsSync3(logsDir)) {
+    mkdirSync2(logsDir, { recursive: true });
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-").split("T").join("_").slice(0, -5);
   logFilePath = join4(logsDir, `claudish_${timestamp}.log`);
-  writeFileSync2(logFilePath, `Claudish Debug Log - ${new Date().toISOString()}
+  writeFileSync3(logFilePath, `Claudish Debug Log - ${new Date().toISOString()}
 Log Level: ${level}
 ${"=".repeat(80)}
 
@@ -3029,7 +3359,7 @@ var serve = (options, listeningListener) => {
 };
 
 // src/proxy-server.ts
-import { writeFileSync as writeFileSync3 } from "node:fs";
+import { writeFileSync as writeFileSync4 } from "node:fs";
 
 // src/transform.ts
 function removeUriFormat(schema) {
@@ -3817,7 +4147,7 @@ data: ${JSON.stringify(data)}
                 total_tokens: cumulativeInputTokens + cumulativeOutputTokens,
                 updated_at: Date.now()
               };
-              writeFileSync3(tokenFilePath, JSON.stringify(tokenData), "utf-8");
+              writeFileSync4(tokenFilePath, JSON.stringify(tokenData), "utf-8");
             } catch (error) {
               if (isLoggingEnabled()) {
                 log(`[Proxy] Failed to write token file: ${error}`);
@@ -4296,7 +4626,7 @@ async function readStdin() {
 }
 async function main() {
   try {
-    const config = parseArgs(process.argv.slice(2));
+    const config = await parseArgs(process.argv.slice(2));
     initLogger(config.debug, config.logLevel);
     if (config.debug && !config.quiet) {
       const logFile = getLogFilePath();

package/package.json

@@ -1,29 +1,12 @@
 {
   "name": "claudish",
-  "version": "1.7.1",
+  "version": "2.0.0",
   "description": "CLI tool to run Claude Code with any OpenRouter model (Grok, GPT-5, MiniMax, etc.) via local Anthropic API-compatible proxy",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {
     "claudish": "dist/index.js"
   },
-  "scripts": {
-    "dev": "bun run src/index.ts",
-    "dev:grok": "bun run src/index.ts --interactive --model x-ai/grok-code-fast-1",
-    "dev:grok:debug": "bun run src/index.ts --interactive --debug --log-level info --model x-ai/grok-code-fast-1",
-    "dev:info": "bun run src/index.ts --interactive --monitor",
-    "extract-models": "bun run scripts/extract-models.ts",
-    "build": "bun run extract-models && bun build src/index.ts --outdir dist --target node && chmod +x dist/index.js",
-    "link": "npm link",
-    "unlink": "npm unlink -g claudish",
-    "install-global": "bun run build && npm link",
-    "kill-all": "pkill -f 'bun.*claudish' || pkill -f 'claude.*claudish-settings' || echo 'No claudish processes found'",
-    "test": "bun test ./tests/comprehensive-model-test.ts",
-    "typecheck": "tsc --noEmit",
-    "lint": "biome check .",
-    "format": "biome format --write .",
-    "postinstall": "node scripts/postinstall.cjs"
-  },
   "dependencies": {
     "@hono/node-server": "^1.19.6",
     "hono": "^4.10.6"
@@ -35,7 +18,10 @@
   },
   "files": [
     "dist/",
-    "scripts/"
+    "scripts/",
+    "skills/",
+    "AI_AGENT_GUIDE.md",
+    "recommended-models.json"
   ],
   "engines": {
     "node": ">=18.0.0",
@@ -51,5 +37,22 @@
     "ai"
   ],
   "author": "Jack Rudenko <i@madappgang.com>",
-  "license": "MIT"
-}
+  "license": "MIT",
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "dev:grok": "bun run src/index.ts --interactive --model x-ai/grok-code-fast-1",
+    "dev:grok:debug": "bun run src/index.ts --interactive --debug --log-level info --model x-ai/grok-code-fast-1",
+    "dev:info": "bun run src/index.ts --interactive --monitor",
+    "extract-models": "bun run scripts/extract-models.ts",
+    "build": "bun run extract-models && bun build src/index.ts --outdir dist --target node && chmod +x dist/index.js",
+    "link": "npm link",
+    "unlink": "npm unlink -g claudish",
+    "install-global": "bun run build && npm link",
+    "kill-all": "pkill -f 'bun.*claudish' || pkill -f 'claude.*claudish-settings' || echo 'No claudish processes found'",
+    "test": "bun test ./tests/comprehensive-model-test.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "format": "biome format --write .",
+    "postinstall": "node scripts/postinstall.cjs"
+  }
+}