jobarbiter 0.3.1 → 0.3.2

package/dist/lib/observe.js

@@ -1,112 +1,42 @@
 /**
  * JobArbiter Observer — Hook installer for coding agent CLIs
  *
- * Detects installed coding agents, installs observation hooks that
- * extract proficiency signals from session transcripts.
+ * Installs observation hooks that extract proficiency signals from
+ * session transcripts. Uses detect-tools.ts for agent detection.
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { execSync } from "node:child_process";
-// ── Agent Detection ────────────────────────────────────────────────────
-const AGENT_DEFINITIONS = [
-    {
-        id: "claude-code",
-        name: "Claude Code",
-        configDir: join(homedir(), ".claude"),
-        hookFormat: "claude",
-        detectBin: "claude",
-    },
-    {
-        id: "cursor",
-        name: "Cursor",
-        configDir: join(homedir(), ".cursor"),
-        hookFormat: "cursor",
-        detectBin: null, // Cursor is an app, not a CLI
-        detectDir: join(homedir(), ".cursor"),
-    },
-    {
-        id: "opencode",
-        name: "OpenCode",
-        configDir: join(homedir(), ".config", "opencode"),
-        hookFormat: "opencode",
-        detectBin: "opencode",
-    },
-    {
-        id: "codex",
-        name: "Codex CLI",
-        configDir: join(homedir(), ".codex"),
-        hookFormat: "codex",
-        detectBin: "codex",
-    },
-    {
-        id: "gemini",
-        name: "Gemini CLI",
-        configDir: join(homedir(), ".gemini"),
-        hookFormat: "gemini",
-        detectBin: "gemini",
-    },
-];
-function binExists(name) {
-    try {
-        execSync(`which ${name}`, { stdio: "ignore" });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
+import { getObservableTools } from "./detect-tools.js";
+// ── Agent Config Directories ───────────────────────────────────────────
+const AGENT_CONFIG_DIRS = {
+    "claude-code": join(homedir(), ".claude"),
+    "cursor": join(homedir(), ".cursor"),
+    "opencode": join(homedir(), ".config", "opencode"),
+    "codex": join(homedir(), ".codex"),
+    "gemini": join(homedir(), ".gemini"),
+};
+const AGENT_HOOK_FORMATS = {
+    "claude-code": "claude",
+    "cursor": "cursor",
+    "opencode": "opencode",
+    "codex": "codex",
+    "gemini": "gemini",
+};
+/**
+ * Detect agents that support observation.
+ * Uses the shared detect-tools module for detection.
+ */
 export function detectAgents() {
-    return AGENT_DEFINITIONS.map((def) => {
-        const installed = (def.detectBin && binExists(def.detectBin)) ||
-            existsSync(def.configDir);
-        return {
-            id: def.id,
-            name: def.name,
-            configDir: def.configDir,
-            hookFormat: def.hookFormat,
-            installed: !!installed,
-            hookInstalled: installed ? isHookInstalled(def.id, def.configDir, def.hookFormat) : false,
-        };
-    });
-}
-// ── Hook Detection ─────────────────────────────────────────────────────
-function isHookInstalled(agentId, configDir, format) {
-    try {
-        switch (format) {
-            case "claude":
-            case "cursor": {
-                const hookFile = join(configDir, "hooks.json");
-                if (!existsSync(hookFile))
-                    return false;
-                const content = readFileSync(hookFile, "utf-8");
-                return content.includes("jobarbiter");
-            }
-            case "opencode": {
-                const pluginDir = join(configDir, "plugins");
-                return existsSync(join(pluginDir, "jobarbiter-observer.ts"));
-            }
-            case "codex": {
-                const configFile = join(configDir, "config.toml");
-                if (!existsSync(configFile))
-                    return false;
-                const content = readFileSync(configFile, "utf-8");
-                return content.includes("jobarbiter");
-            }
-            case "gemini": {
-                const settingsFile = join(configDir, "settings.json");
-                if (!existsSync(settingsFile))
-                    return false;
-                const content = readFileSync(settingsFile, "utf-8");
-                return content.includes("jobarbiter");
-            }
-            default:
-                return false;
-        }
-    }
-    catch {
-        return false;
-    }
+    const observableTools = getObservableTools();
+    return observableTools.map((tool) => ({
+        id: tool.id,
+        name: tool.name,
+        configDir: AGENT_CONFIG_DIRS[tool.id] || tool.configDir || "",
+        hookFormat: AGENT_HOOK_FORMATS[tool.id] || "claude",
+        installed: tool.installed,
+        hookInstalled: tool.observerActive,
+    }));
 }
 // ── Observer Data Directory ────────────────────────────────────────────
 const OBSERVER_DIR = join(homedir(), ".config", "jobarbiter", "observer");
@@ -519,6 +449,54 @@ function installGeminiHook(configDir, scriptPath) {
     writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + "\n");
 }
 // ── Public API ─────────────────────────────────────────────────────────
+// ── Agent Name Mapping ─────────────────────────────────────────────────
+const AGENT_NAMES = {
+    "claude-code": "Claude Code",
+    "cursor": "Cursor",
+    "opencode": "OpenCode",
+    "codex": "Codex CLI",
+    "gemini": "Gemini CLI",
+};
+/**
+ * Check if observer hook is installed for an agent.
+ */
+function isHookInstalled(agentId, configDir, format) {
+    try {
+        switch (format) {
+            case "claude":
+            case "cursor": {
+                const hookFile = join(configDir, "hooks.json");
+                if (!existsSync(hookFile))
+                    return false;
+                const content = readFileSync(hookFile, "utf-8");
+                return content.includes("jobarbiter");
+            }
+            case "opencode": {
+                const pluginDir = join(configDir, "plugins");
+                return existsSync(join(pluginDir, "jobarbiter-observer.js"));
+            }
+            case "codex": {
+                const configFile = join(configDir, "config.toml");
+                if (!existsSync(configFile))
+                    return false;
+                const content = readFileSync(configFile, "utf-8");
+                return content.includes("jobarbiter");
+            }
+            case "gemini": {
+                const settingsFile = join(configDir, "settings.json");
+                if (!existsSync(settingsFile))
+                    return false;
+                const content = readFileSync(settingsFile, "utf-8");
+                return content.includes("jobarbiter");
+            }
+            default:
+                return false;
+        }
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Install observer hooks for the specified agents.
  * Returns a summary of what was installed.
@@ -531,39 +509,41 @@ export function installObservers(agentIds) {
         errors: [],
     };
     for (const agentId of agentIds) {
-        const def = AGENT_DEFINITIONS.find((d) => d.id === agentId);
-        if (!def) {
+        const configDir = AGENT_CONFIG_DIRS[agentId];
+        const hookFormat = AGENT_HOOK_FORMATS[agentId];
+        const agentName = AGENT_NAMES[agentId] || agentId;
+        if (!configDir || !hookFormat) {
             result.errors.push({ agent: agentId, error: "Unknown agent" });
             continue;
         }
         // Check if already installed
-        if (isHookInstalled(def.id, def.configDir, def.hookFormat)) {
-            result.skipped.push(def.name);
+        if (isHookInstalled(agentId, configDir, hookFormat)) {
+            result.skipped.push(agentName);
             continue;
         }
         try {
-            switch (def.hookFormat) {
+            switch (hookFormat) {
                 case "claude":
-                    installClaudeCodeHook(def.configDir, scriptPath);
+                    installClaudeCodeHook(configDir, scriptPath);
                     break;
                 case "cursor":
-                    installCursorHook(def.configDir, scriptPath);
+                    installCursorHook(configDir, scriptPath);
                     break;
                 case "opencode":
-                    installOpenCodeHook(def.configDir, scriptPath);
+                    installOpenCodeHook(configDir, scriptPath);
                     break;
                 case "codex":
-                    installCodexHook(def.configDir, scriptPath);
+                    installCodexHook(configDir, scriptPath);
                     break;
                 case "gemini":
-                    installGeminiHook(def.configDir, scriptPath);
+                    installGeminiHook(configDir, scriptPath);
                     break;
             }
-            result.installed.push(def.name);
+            result.installed.push(agentName);
         }
         catch (err) {
             result.errors.push({
-                agent: def.name,
+                agent: agentName,
                 error: err instanceof Error ? err.message : String(err),
             });
         }
@@ -576,16 +556,18 @@ export function installObservers(agentIds) {
 export function removeObservers(agentIds) {
     const result = { removed: [], notFound: [] };
     for (const agentId of agentIds) {
-        const def = AGENT_DEFINITIONS.find((d) => d.id === agentId);
-        if (!def) {
+        const configDir = AGENT_CONFIG_DIRS[agentId];
+        const hookFormat = AGENT_HOOK_FORMATS[agentId];
+        const agentName = AGENT_NAMES[agentId] || agentId;
+        if (!configDir || !hookFormat) {
             result.notFound.push(agentId);
             continue;
         }
         try {
-            switch (def.hookFormat) {
+            switch (hookFormat) {
                 case "claude":
                 case "cursor": {
-                    const hookFile = join(def.configDir, "hooks.json");
+                    const hookFile = join(configDir, "hooks.json");
                     if (existsSync(hookFile)) {
                         const config = JSON.parse(readFileSync(hookFile, "utf-8"));
                         for (const [key, hooks] of Object.entries(config.hooks || {})) {
@@ -594,26 +576,26 @@ export function removeObservers(agentIds) {
                             }
                         }
                         writeFileSync(hookFile, JSON.stringify(config, null, 2) + "\n");
-                        result.removed.push(def.name);
+                        result.removed.push(agentName);
                     }
                     else {
-                        result.notFound.push(def.name);
+                        result.notFound.push(agentName);
                     }
                     break;
                 }
                 case "opencode": {
-                    const pluginFile = join(def.configDir, "plugins", "jobarbiter-observer.js");
+                    const pluginFile = join(configDir, "plugins", "jobarbiter-observer.js");
                     if (existsSync(pluginFile)) {
                         unlinkSync(pluginFile);
-                        result.removed.push(def.name);
+                        result.removed.push(agentName);
                     }
                     else {
-                        result.notFound.push(def.name);
+                        result.notFound.push(agentName);
                     }
                     break;
                 }
                 case "codex": {
-                    const configFile = join(def.configDir, "config.toml");
+                    const configFile = join(configDir, "config.toml");
                     if (existsSync(configFile)) {
                         let content = readFileSync(configFile, "utf-8");
                         content = content
@@ -621,15 +603,15 @@ export function removeObservers(agentIds) {
                             .filter((line) => !line.includes("jobarbiter"))
                             .join("\n");
                         writeFileSync(configFile, content);
-                        result.removed.push(def.name);
+                        result.removed.push(agentName);
                     }
                     else {
-                        result.notFound.push(def.name);
+                        result.notFound.push(agentName);
                     }
                     break;
                 }
                 case "gemini": {
-                    const settingsFile = join(def.configDir, "settings.json");
+                    const settingsFile = join(configDir, "settings.json");
                     if (existsSync(settingsFile)) {
                         const settings = JSON.parse(readFileSync(settingsFile, "utf-8"));
                         for (const [key, hookGroups] of Object.entries(settings.hooks || {})) {
@@ -638,17 +620,17 @@ export function removeObservers(agentIds) {
                             }
                         }
                         writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + "\n");
-                        result.removed.push(def.name);
+                        result.removed.push(agentName);
                     }
                     else {
-                        result.notFound.push(def.name);
+                        result.notFound.push(agentName);
                     }
                     break;
                 }
             }
         }
         catch {
-            result.notFound.push(def.name);
+            result.notFound.push(agentName);
         }
     }
     return result;

package/dist/lib/onboard.js

@@ -10,7 +10,8 @@
 import * as readline from "node:readline";
 import { loadConfig, saveConfig, getConfigPath } from "./config.js";
 import { apiUnauthenticated, api, ApiError } from "./api.js";
-import { detectAgents, installObservers } from "./observe.js";
+import { installObservers } from "./observe.js";
+import { detectAllTools, formatToolDisplay, } from "./detect-tools.js";
 // ── ANSI Colors ────────────────────────────────────────────────────────
 const colors = {
     reset: "\x1b[0m",
@@ -164,7 +165,9 @@ async function selectUserType(prompt) {
 }
 // ── Email & Verification ───────────────────────────────────────────────
 async function handleEmailVerification(prompt, baseUrl, userType) {
-    const totalSteps = userType === "worker" ? 5 : 6;
+    // Workers: 1) Account, 2) Tool Detection, 3) Domains, 4) GitHub, 5) LinkedIn, 6) Done
+    // Employers: 1) Account, 2) (skip verification), 3) Company, 4) Domain, 5) What You Need, 6) Done
+    const totalSteps = 6;
     console.log(`\n${sym.email} ${c.bold(`Step 1/${totalSteps} — Create Your Account`)}\n`);
     // Get email
     let email;
@@ -240,14 +243,12 @@ async function runWorkerFlow(prompt, state) {
         baseUrl: state.baseUrl,
         userType: "worker",
     };
-    // Step 2: Profile Setup (tools + domains)
-    console.log(`${sym.tools} ${c.bold("Step 2/6 — Your AI Stack")}\n`);
-    console.log(`What AI tools do you use? ${c.dim("(comma-separated)")}`);
-    console.log(c.dim("Examples: Claude Code, Cursor, OpenClaw, ChatGPT, Copilot, Midjourney\n"));
-    const toolsInput = await prompt.question(`${sym.arrow} `);
-    const tools = toolsInput.split(",").map(s => s.trim()).filter(Boolean);
-    state.tools = tools;
-    console.log(`\nWhat domains do you work in? ${c.dim("(comma-separated)")}`);
+    // Step 2: Auto-detect AI Tools
+    const detectedToolsResult = await runToolDetectionStep(prompt, config);
+    state.tools = detectedToolsResult.tools;
+    // Step 3: Domains
+    console.log(`${sym.target} ${c.bold("Step 3/6 — Your Domains")}\n`);
+    console.log(`What domains do you work in? ${c.dim("(comma-separated)")}`);
     console.log(c.dim("Examples: full-stack dev, data engineering, trading, content creation\n"));
     const domainsInput = await prompt.question(`${sym.arrow} `);
     const domains = domainsInput.split(",").map(s => s.trim()).filter(Boolean);
@@ -258,7 +259,7 @@ async function runWorkerFlow(prompt, state) {
         await api(config, "POST", "/v1/profile", {
             domains,
             tools: {
-                primary: tools,
+                primary: state.tools,
             },
         });
         console.log(`${sym.check} Profile saved\n`);
@@ -266,8 +267,6 @@ async function runWorkerFlow(prompt, state) {
     catch (err) {
         console.log(`${sym.warning} ${c.warning("Could not save profile details — you can update later with 'jobarbiter profile create'")}\n`);
     }
-    // Step 3: Install Coding Agent Observers
-    await runObserverStep(prompt, state, 3, 6);
     // Step 4: Connect GitHub (optional)
     console.log(`${sym.link} ${c.bold("Step 4/6 — Connect GitHub")} ${c.dim("(optional)")}\n`);
     console.log(`Connecting your GitHub lets us analyze your AI-assisted work patterns.`);
@@ -313,81 +312,116 @@ async function runWorkerFlow(prompt, state) {
     // Step 6: Done!
     showWorkerCompletion(state);
 }
-// ── Observer Installation Step ─────────────────────────────────────────
-async function runObserverStep(prompt, state, stepNum, totalSteps) {
-    console.log(`🔍 ${c.bold(`Step ${stepNum}/${totalSteps} — Coding Agent Observers`)}\n`);
-    console.log(c.dim("Scanning for coding agents...\n"));
-    const agents = detectAgents();
-    const detected = agents.filter((a) => a.installed);
-    const notDetected = agents.filter((a) => !a.installed);
-    // Show results
-    if (detected.length === 0) {
-        console.log(`  ${c.dim("No coding agents detected on this system.")}\n`);
-        console.log(c.dim("  You can install observers later with 'jobarbiter observe install'.\n"));
-        return;
-    }
-    console.log(`  Found on your system:`);
-    for (const agent of detected) {
-        if (agent.hookInstalled) {
-            console.log(`    ${sym.check} ${agent.name}  ${c.dim("(observer already installed)")}`);
+// ── Tool Detection Step ────────────────────────────────────────────────
+async function runToolDetectionStep(prompt, config) {
+    console.log(`🔍 ${c.bold("Step 2/6 — Detecting AI Tools")}\n`);
+    console.log(c.dim("  Scanning your machine...\n"));
+    const allTools = detectAllTools();
+    const installed = allTools.filter((t) => t.installed);
+    const notInstalled = allTools.filter((t) => !t.installed && t.category === "coding-agent");
+    // Group by category
+    const codingAgents = installed.filter((t) => t.category === "coding-agent");
+    const chatTools = installed.filter((t) => t.category === "chat");
+    const orchestration = installed.filter((t) => t.category === "orchestration");
+    const apiProviders = installed.filter((t) => t.category === "api-provider");
+    // Display found tools
+    if (installed.length === 0) {
+        console.log(`  ${c.dim("No AI tools detected on this system.")}\n`);
+        console.log(c.dim("  You can add tools later with 'jobarbiter observe install'.\n"));
+        return { tools: [] };
+    }
+    console.log(`  ${c.bold("Found:")}`);
+    // Show coding agents with observer status
+    for (const tool of codingAgents) {
+        const display = formatToolDisplay(tool);
+        if (tool.observerAvailable) {
+            if (tool.observerActive) {
+                console.log(`    ${sym.check} ${display} ${c.dim("(observer active)")}`);
+            }
+            else {
+                console.log(`    ${sym.check} ${display} ${c.success("(observer available)")}`);
+            }
         }
         else {
-            console.log(`    ${c.success("✓")} ${agent.name}`);
+            console.log(`    ${sym.check} ${display} ${c.dim("(detected)")}`);
         }
     }
-    for (const agent of notDetected) {
-        console.log(`    ${c.dim("⬚")} ${agent.name}  ${c.dim("(not found)")}`);
-    }
-    // Filter to agents that need installation
-    const needsInstall = detected.filter((a) => !a.hookInstalled);
-    if (needsInstall.length === 0) {
-        console.log(`\n  ${c.dim("All detected agents already have observers installed.")}\n`);
-        return;
-    }
-    console.log(`\n  JobArbiter observes your coding sessions to build your`);
-    console.log(`  proficiency profile. ${c.bold("No code or prompts leave your machine")} —`);
-    console.log(`  only aggregate scores (tool usage, session counts, token volume).\n`);
-    console.log(c.dim(`  Data stored locally: ~/.config/jobarbiter/observer/observations.json`));
-    console.log(c.dim(`  Review anytime: jobarbiter observe status\n`));
-    const installAll = await prompt.confirm(`  Install observers for all ${needsInstall.length} detected agent${needsInstall.length > 1 ? "s" : ""}?`);
-    let toInstall;
-    if (installAll) {
-        toInstall = needsInstall.map((a) => a.id);
+    // Show other tools
+    for (const tool of chatTools) {
+        console.log(`    ${sym.check} ${formatToolDisplay(tool)} ${c.dim("(detected)")}`);
     }
-    else {
-        // Let user select individually
-        console.log(`\n  Select which agents to observe:\n`);
-        const selections = {};
-        for (const agent of needsInstall) {
-            selections[agent.id] = await prompt.confirm(`    ${agent.name}?`, true);
+    for (const tool of orchestration) {
+        console.log(`    ${sym.check} ${formatToolDisplay(tool)} ${c.dim("(detected)")}`);
+    }
+    for (const tool of apiProviders) {
+        console.log(`    ${sym.check} ${tool.name} ${c.dim("configured")}`);
+    }
+    // Show not-detected coding agents
+    if (notInstalled.length > 0) {
+        console.log(`\n  ${c.dim("Not detected (install to track):")}`);
+        for (const tool of notInstalled.slice(0, 5)) {
+            console.log(`    ${c.dim("⬚")} ${tool.name}`);
         }
-        toInstall = Object.entries(selections)
-            .filter(([, v]) => v)
-            .map(([k]) => k);
-        if (toInstall.length === 0) {
-            console.log(`\n  ${c.dim("No observers installed. You can add them later with 'jobarbiter observe install'.")}\n`);
-            return;
+        if (notInstalled.length > 5) {
+            console.log(`    ${c.dim(`... and ${notInstalled.length - 5} more`)}`);
         }
     }
-    // Install
-    console.log(c.dim("\n  Installing observers..."));
-    const result = installObservers(toInstall);
-    for (const name of result.installed) {
-        console.log(`    ${sym.check} ${name}`);
-    }
-    for (const name of result.skipped) {
-        console.log(`    ${c.dim("—")} ${name} ${c.dim("(already installed)")}`);
+    // Collect tool names for profile
+    const toolNames = installed.map((t) => t.name);
+    // Observer installation for coding agents
+    const needsObserver = codingAgents.filter((t) => t.observerAvailable && !t.observerActive);
+    if (needsObserver.length > 0) {
+        console.log(`\n  ${c.bold("Observers")}`);
+        console.log(`  JobArbiter observes your coding sessions to build your`);
+        console.log(`  proficiency profile. ${c.bold("No code or prompts leave your machine")} —`);
+        console.log(`  only aggregate scores (tool usage, session counts, token volume).\n`);
+        console.log(c.dim(`  Data stored locally: ~/.config/jobarbiter/observer/observations.json`));
+        console.log(c.dim(`  Review anytime: jobarbiter observe status\n`));
+        const observerNames = needsObserver.map((t) => t.name).join(", ");
+        const installAll = await prompt.confirm(`  Install observers for detected tools? (${observerNames})`);
+        if (installAll) {
+            const toInstall = needsObserver.map((t) => t.id);
+            console.log(c.dim("\n  Installing observers..."));
+            const result = installObservers(toInstall);
+            for (const name of result.installed) {
+                console.log(`    ${sym.check} ${name}`);
+            }
+            for (const name of result.skipped) {
+                console.log(`    ${c.dim("—")} ${name} ${c.dim("(already installed)")}`);
+            }
+            for (const { agent, error: errMsg } of result.errors) {
+                console.log(`    ${sym.cross} ${agent}: ${c.error(errMsg)}`);
+            }
+            if (result.installed.length > 0) {
+                console.log(`\n  ${sym.check} ${c.success(`${result.installed.length} observer${result.installed.length > 1 ? "s" : ""} installed!`)}`);
+                console.log(c.dim(`  Your proficiency profile will start building automatically.\n`));
+            }
+        }
+        else {
+            console.log(c.dim("\n  Skipped — you can install observers later with 'jobarbiter observe install'.\n"));
+        }
     }
-    for (const { agent, error: errMsg } of result.errors) {
-        console.log(`    ${sym.cross} ${agent}: ${c.error(errMsg)}`);
+    else if (codingAgents.length > 0) {
+        const hasActiveObservers = codingAgents.some((t) => t.observerActive);
+        if (hasActiveObservers) {
+            console.log(`\n  ${c.dim("All detected agents already have observers installed.")}\n`);
+        }
+        else {
+            console.log();
+        }
     }
-    if (result.installed.length > 0) {
-        console.log(`\n  ${sym.check} ${c.success(`${result.installed.length} observer${result.installed.length > 1 ? "s" : ""} installed!`)}`);
-        console.log(c.dim(`  Your proficiency profile will start building automatically.\n`));
+    // "Did we miss anything?" prompt
+    console.log(`  ${c.dim("Did we miss anything?")}`);
+    const additionalTools = await prompt.question(`  Other AI tools you use ${c.dim("(comma-separated, or press Enter)")}: `);
+    if (additionalTools.trim()) {
+        const additional = additionalTools.split(",").map((s) => s.trim()).filter(Boolean);
+        toolNames.push(...additional);
+        console.log(`  ${sym.check} Added: ${additional.join(", ")}\n`);
     }
     else {
         console.log();
     }
+    return { tools: toolNames };
 }
 function showWorkerCompletion(state) {
     console.log(`${sym.done} ${c.bold("Step 6/6 — You're In!")}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jobarbiter",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "CLI for JobArbiter — the first AI Proficiency Marketplace",
   "type": "module",
   "bin": {

package/src/index.ts

@@ -6,6 +6,7 @@ import { api, apiUnauthenticated, ApiError } from "./lib/api.js";
 import { output, outputList, success, error, setJsonMode } from "./lib/output.js";
 import { runOnboardWizard } from "./lib/onboard.js";
 import { detectAgents, installObservers, removeObservers, getObservationStatus } from "./lib/observe.js";
+import { getObservableTools, formatToolDisplay } from "./lib/detect-tools.js";
 
 const program = new Command();