@arcteninc/core 0.0.142 → 0.0.143

package/scripts/cli-tools.ts

@@ -0,0 +1,320 @@
+#!/usr/bin/env tsx
+/**
+ * arcten tools - Interactive tool classification
+ *
+ * Usage:
+ *   arcten tools              # Interactive AI chat for reclassification
+ *   arcten tools --list       # Show current safe/sensitive classification
+ *   arcten tools --reset      # Re-run pattern-based classification
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as readline from "readline";
+
+// Classification patterns (fallback when no AI)
+const safePatterns = /^(get|list|search|find|fetch|load|calculate|count|query|read)/i;
+const sensitivePatterns = /^(create|update|delete|remove|set|add|modify|insert|patch|put|post|reset|regenerate|change|batch)/i;
+const sensitiveReads = /^(get|fetch).*(api.?key|credential|secret|password|token|auth)/i;
+
+interface SyncState {
+  lastSync: string;
+  toolsFile: string;
+  functions: Record<string, { classification: "safe" | "sensitive" }>;
+}
+
+function findProjectRoot(): string {
+  let dir = process.cwd();
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+function readSyncState(projectRoot: string): SyncState | null {
+  const syncStatePath = path.join(projectRoot, ".arcten", "sync-state.json");
+  if (!fs.existsSync(syncStatePath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(syncStatePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!parsed.functions || typeof parsed.functions !== "object") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function writeSyncState(projectRoot: string, state: SyncState): void {
+  const arctenDir = path.join(projectRoot, ".arcten");
+  if (!fs.existsSync(arctenDir)) {
+    fs.mkdirSync(arctenDir, { recursive: true });
+  }
+  const syncStatePath = path.join(arctenDir, "sync-state.json");
+  fs.writeFileSync(syncStatePath, JSON.stringify(state, null, 2));
+}
+
+function classifyByPattern(name: string): "safe" | "sensitive" {
+  // Sensitive reads take priority
+  if (sensitiveReads.test(name)) return "sensitive";
+  // Then check for sensitive action patterns
+  if (sensitivePatterns.test(name)) return "sensitive";
+  // Then check for safe read patterns
+  if (safePatterns.test(name)) return "safe";
+  // Default to sensitive (fail-safe)
+  return "sensitive";
+}
+
+function listClassifications(state: SyncState): void {
+  const safeTools: string[] = [];
+  const sensitiveTools: string[] = [];
+
+  for (const [name, data] of Object.entries(state.functions)) {
+    if (data.classification === "safe") {
+      safeTools.push(name);
+    } else {
+      sensitiveTools.push(name);
+    }
+  }
+
+  console.log("\n📋 Tool Classifications\n");
+  console.log(`Source: ${state.toolsFile}`);
+  console.log(`Last sync: ${state.lastSync}\n`);
+
+  console.log(`✅ Safe (${safeTools.length}) - auto-execute without approval:`);
+  if (safeTools.length === 0) {
+    console.log("   (none)");
+  } else {
+    safeTools.sort().forEach((name) => console.log(`   • ${name}`));
+  }
+
+  console.log(`\n⚠️  Sensitive (${sensitiveTools.length}) - require user approval:`);
+  if (sensitiveTools.length === 0) {
+    console.log("   (none)");
+  } else {
+    sensitiveTools.sort().forEach((name) => console.log(`   • ${name}`));
+  }
+
+  console.log(`\nTotal: ${safeTools.length + sensitiveTools.length} tools`);
+  console.log("\nTo change classifications, run: arcten tools");
+  console.log("After changes, run: arcten sync");
+}
+
+function resetClassifications(state: SyncState): SyncState {
+  console.log("\n🔄 Resetting classifications using pattern matching...\n");
+
+  const newFunctions: Record<string, { classification: "safe" | "sensitive" }> = {};
+  let safeCount = 0;
+  let sensitiveCount = 0;
+
+  for (const name of Object.keys(state.functions)) {
+    const classification = classifyByPattern(name);
+    newFunctions[name] = { classification };
+    if (classification === "safe") {
+      safeCount++;
+    } else {
+      sensitiveCount++;
+    }
+    console.log(`  ${classification === "safe" ? "✅" : "⚠️"}  ${name} → ${classification}`);
+  }
+
+  console.log(`\nReset complete: ${safeCount} safe, ${sensitiveCount} sensitive`);
+
+  return {
+    ...state,
+    functions: newFunctions,
+  };
+}
+
+async function interactiveClassification(projectRoot: string, state: SyncState): Promise<void> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const ask = (question: string): Promise<string> => {
+    return new Promise((resolve) => {
+      rl.question(question, (answer) => {
+        resolve(answer.trim());
+      });
+    });
+  };
+
+  console.log("\n🔧 Interactive Tool Classification\n");
+  console.log("Commands:");
+  console.log("  list                    Show all classifications");
+  console.log("  safe <tool>             Mark tool as safe (auto-execute)");
+  console.log("  sensitive <tool>        Mark tool as sensitive (requires approval)");
+  console.log("  safe <tool1> <tool2>    Mark multiple tools as safe");
+  console.log("  find <pattern>          Find tools matching pattern");
+  console.log("  reset                   Reset all to pattern-based classification");
+  console.log("  save                    Save changes and exit");
+  console.log("  quit                    Exit without saving");
+  console.log("");
+
+  let modified = false;
+  let currentState = { ...state };
+
+  while (true) {
+    const input = await ask("\n> ");
+    const parts = input.split(/\s+/);
+    const command = parts[0]?.toLowerCase();
+
+    if (!command) continue;
+
+    if (command === "quit" || command === "exit" || command === "q") {
+      if (modified) {
+        const confirm = await ask("You have unsaved changes. Quit anyway? (y/n): ");
+        if (confirm.toLowerCase() !== "y") continue;
+      }
+      console.log("Exiting without saving.");
+      rl.close();
+      return;
+    }
+
+    if (command === "save") {
+      if (!modified) {
+        console.log("No changes to save.");
+      } else {
+        writeSyncState(projectRoot, currentState);
+        console.log("✅ Changes saved to .arcten/sync-state.json");
+        console.log("   Run 'arcten sync' to regenerate arcten.tools.ts and sync to dashboard.");
+      }
+      rl.close();
+      return;
+    }
+
+    if (command === "list" || command === "ls") {
+      listClassifications(currentState);
+      continue;
+    }
+
+    if (command === "reset") {
+      currentState = resetClassifications(currentState);
+      modified = true;
+      continue;
+    }
+
+    if (command === "find" || command === "search") {
+      const pattern = parts.slice(1).join(" ").toLowerCase();
+      if (!pattern) {
+        console.log("Usage: find <pattern>");
+        continue;
+      }
+      const matches = Object.entries(currentState.functions)
+        .filter(([name]) => name.toLowerCase().includes(pattern))
+        .map(([name, data]) => `  ${data.classification === "safe" ? "✅" : "⚠️"}  ${name}`);
+      if (matches.length === 0) {
+        console.log(`No tools matching "${pattern}"`);
+      } else {
+        console.log(`Found ${matches.length} tools:`);
+        matches.forEach((m) => console.log(m));
+      }
+      continue;
+    }
+
+    if (command === "safe" || command === "sensitive") {
+      const toolNames = parts.slice(1);
+      if (toolNames.length === 0) {
+        console.log(`Usage: ${command} <tool1> [tool2] ...`);
+        continue;
+      }
+
+      const classification = command as "safe" | "sensitive";
+      let changed = 0;
+
+      for (const toolName of toolNames) {
+        // Find exact match or partial match
+        const exactMatch = Object.keys(currentState.functions).find(
+          (name) => name.toLowerCase() === toolName.toLowerCase()
+        );
+        const partialMatches = Object.keys(currentState.functions).filter(
+          (name) => name.toLowerCase().includes(toolName.toLowerCase())
+        );
+
+        if (exactMatch) {
+          if (currentState.functions[exactMatch].classification !== classification) {
+            currentState.functions[exactMatch].classification = classification;
+            console.log(`  ${classification === "safe" ? "✅" : "⚠️"}  ${exactMatch} → ${classification}`);
+            changed++;
+            modified = true;
+          } else {
+            console.log(`  ⏭️  ${exactMatch} already ${classification}`);
+          }
+        } else if (partialMatches.length === 1) {
+          const match = partialMatches[0];
+          if (currentState.functions[match].classification !== classification) {
+            currentState.functions[match].classification = classification;
+            console.log(`  ${classification === "safe" ? "✅" : "⚠️"}  ${match} → ${classification}`);
+            changed++;
+            modified = true;
+          } else {
+            console.log(`  ⏭️  ${match} already ${classification}`);
+          }
+        } else if (partialMatches.length > 1) {
+          console.log(`  ❓ "${toolName}" matches multiple tools:`);
+          partialMatches.slice(0, 5).forEach((m) => console.log(`      • ${m}`));
+          if (partialMatches.length > 5) {
+            console.log(`      ... and ${partialMatches.length - 5} more`);
+          }
+        } else {
+          console.log(`  ❌ Tool not found: ${toolName}`);
+        }
+      }
+
+      if (changed > 0) {
+        console.log(`\nChanged ${changed} tool(s). Use 'save' to persist changes.`);
+      }
+      continue;
+    }
+
+    console.log(`Unknown command: ${command}`);
+    console.log("Type 'list', 'safe <tool>', 'sensitive <tool>', 'save', or 'quit'");
+  }
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const showList = args.includes("--list") || args.includes("-l");
+  const doReset = args.includes("--reset") || args.includes("-r");
+
+  const projectRoot = findProjectRoot();
+  const state = readSyncState(projectRoot);
+
+  if (!state) {
+    console.error("❌ No sync state found. Run 'arcten init' or 'arcten sync' first.");
+    process.exit(1);
+  }
+
+  if (Object.keys(state.functions).length === 0) {
+    console.error("❌ No tools found in sync state. Run 'arcten sync' to discover tools.");
+    process.exit(1);
+  }
+
+  if (showList) {
+    listClassifications(state);
+    return;
+  }
+
+  if (doReset) {
+    const newState = resetClassifications(state);
+    writeSyncState(projectRoot, newState);
+    console.log("\n✅ Classifications saved to .arcten/sync-state.json");
+    console.log("   Run 'arcten sync' to regenerate arcten.tools.ts and sync to dashboard.");
+    return;
+  }
+
+  // Interactive mode
+  await interactiveClassification(projectRoot, state);
+}
+
+main().catch((error) => {
+  console.error("❌ Error:", error.message);
+  process.exit(1);
+});