devtopia 1.9.0 → 2.0.1

package/dist/commands/run.js

@@ -1,5 +1,39 @@
 import { executeTool } from '../executor.js';
-export async function run(toolName, inputArg) {
+import { API_BASE } from '../config.js';
+import { existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+export async function run(toolName, inputArg, options = {}) {
+    if (!process.env.DEVTOPIA_CLI) {
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        const indexJs = join(__dirname, '..', 'index.js');
+        const indexTs = join(__dirname, '..', 'index.ts');
+        const indexDist = join(__dirname, '..', '..', 'dist', 'index.js');
+        const quotePath = (p) => (p.includes(' ') ? `"${p.replace(/"/g, '\\"')}"` : p);
+        if (existsSync(indexJs)) {
+            process.env.DEVTOPIA_CLI = `node ${quotePath(indexJs)}`;
+        }
+        else if (existsSync(indexDist)) {
+            process.env.DEVTOPIA_CLI = `node ${quotePath(indexDist)}`;
+        }
+        else if (existsSync(indexTs)) {
+            const tsxCandidates = [
+                join(__dirname, '..', '..', 'node_modules', '.bin', 'tsx'),
+                join(__dirname, '..', 'node_modules', '.bin', 'tsx'),
+            ];
+            const tsxBin = tsxCandidates.find((p) => existsSync(p));
+            if (tsxBin) {
+                process.env.DEVTOPIA_CLI = `node ${quotePath(tsxBin)} ${quotePath(indexTs)}`;
+            }
+            else {
+                process.env.DEVTOPIA_CLI = `npx tsx ${quotePath(indexTs)}`;
+            }
+        }
+    }
+    const humanMode = options.human === true;
+    const jsonMode = !humanMode;
+    const pretty = options.pretty === true || (humanMode && options.pretty !== false);
+    const quiet = jsonMode ? (options.quiet !== false) : (options.quiet === true);
     // Parse input
     let input = {};
     if (inputArg) {
@@ -7,19 +41,54 @@ export async function run(toolName, inputArg) {
             input = JSON.parse(inputArg);
         }
         catch {
-            console.log(`\n❌ Invalid JSON input: ${inputArg}\n`);
-            process.exit(1);
+            if (jsonMode) {
+                process.stdout.write(JSON.stringify({ ok: false, error: `Invalid JSON input: ${inputArg}` }) + '\n');
+                process.exit(0);
+            }
+            else {
+                console.log(`\n❌ Invalid JSON input: ${inputArg}\n`);
+                process.exit(1);
+            }
         }
     }
-    console.log(`\n⚡ Running /${toolName} locally...`);
-    const result = await executeTool(toolName, input);
+    if (!jsonMode && !quiet) {
+        console.log(`\n⚡ Running /${toolName} locally...`);
+    }
+    const result = await executeTool(toolName, input, { strictJson: jsonMode });
+    // Fire-and-forget: track execution (never blocks, never fails visibly)
+    fetch(`${API_BASE}/api/runs`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            tool_name: toolName,
+            success: result.success,
+            duration_ms: result.durationMs,
+        }),
+    }).catch(() => { }); // silently ignore
+    if (jsonMode) {
+        const outputIsObject = result.output && typeof result.output === 'object';
+        const outputHasError = outputIsObject && (Object.prototype.hasOwnProperty.call(result.output, 'error') ||
+            (Object.prototype.hasOwnProperty.call(result.output, 'ok') && result.output.ok === false));
+        if (result.success && !outputHasError) {
+            process.stdout.write(JSON.stringify(result.output ?? null, null, pretty ? 2 : 0) + '\n');
+        }
+        else {
+            const errMsg = outputIsObject && result.output.error
+                ? String(result.output.error)
+                : (result.error || 'Execution failed');
+            process.stdout.write(JSON.stringify({ ok: false, error: errMsg }, null, pretty ? 2 : 0) + '\n');
+        }
+        process.exit(0);
+    }
     if (!result.success) {
         console.log(`\n❌ Execution failed`);
         console.log(`   Error: ${result.error}`);
         console.log(`   Duration: ${result.durationMs}ms\n`);
         process.exit(1);
     }
-    console.log(`\n✅ Success (${result.durationMs}ms)\n`);
+    if (!quiet) {
+        console.log(`\n✅ Success (${result.durationMs}ms)\n`);
+    }
     // Pretty print output
     if (typeof result.output === 'object') {
         console.log(JSON.stringify(result.output, null, 2));

package/dist/commands/search.d.ts

@@ -0,0 +1,5 @@
+interface SearchOptions {
+    limit?: string;
+}
+export declare function search(query: string, options?: SearchOptions): Promise<void>;
+export {};

package/dist/commands/search.js

@@ -0,0 +1,52 @@
+import { API_BASE } from '../config.js';
+export async function search(query, options = {}) {
+    const limit = parseInt(options.limit || '20');
+    try {
+        // Try server-side search first
+        let results = [];
+        try {
+            const res = await fetch(`${API_BASE}/api/search?q=${encodeURIComponent(query)}&limit=${limit}`);
+            if (res.ok) {
+                const data = await res.json();
+                results = data.results || [];
+            }
+            else {
+                throw new Error('search endpoint unavailable');
+            }
+        }
+        catch {
+            // Fallback: fetch all tools and filter client-side
+            console.log(`   (using fallback search — server search unavailable)\n`);
+            const res = await fetch(`${API_BASE}/api/tools`);
+            const data = await res.json();
+            const q = query.toLowerCase();
+            results = (data.tools || [])
+                .filter((t) => t.name.toLowerCase().includes(q) ||
+                (t.description && t.description.toLowerCase().includes(q)))
+                .slice(0, limit)
+                .map((t) => ({
+                name: t.name,
+                description: t.description,
+                language: t.language,
+                category: t.category,
+            }));
+        }
+        if (results.length === 0) {
+            console.log(`\n   No results for "${query}"\n`);
+            return;
+        }
+        console.log(`\n   Search: "${query}" (${results.length} results)\n`);
+        for (const tool of results) {
+            const name = `/${tool.name}`.padEnd(25);
+            const desc = (tool.description || 'No description').slice(0, 40).padEnd(40);
+            const lang = (tool.language || '').slice(0, 4);
+            console.log(`   ${name} ${desc} ${lang}`);
+        }
+        console.log(`\n   View source:  devtopia cat <tool>`);
+        console.log(`   Run locally:  devtopia run <tool> '{...}'\n`);
+    }
+    catch (err) {
+        console.log(`\n❌ Could not connect to server at ${API_BASE}\n`);
+        process.exit(1);
+    }
+}

package/dist/commands/start.d.ts

@@ -1 +1 @@
-export declare function start(): void;
+export declare function start(): Promise<void>;