devtopia 1.9.0 → 2.0.0

package/dist/commands/compose.d.ts

@@ -0,0 +1,5 @@
+interface ComposeOptions {
+    uses: string;
+}
+export declare function compose(name: string, options: ComposeOptions): Promise<void>;
+export {};

package/dist/commands/compose.js

@@ -0,0 +1,120 @@
+import { writeFileSync, existsSync } from 'fs';
+import { API_BASE } from '../config.js';
+export async function compose(name, options) {
+    if (!options.uses) {
+        console.log(`\n❌ --uses is required. Specify parent tools to compose.`);
+        console.log(`   Example: devtopia compose my-pipeline --uses json-validate,json-flatten\n`);
+        process.exit(1);
+    }
+    if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+        console.log(`\n❌ Tool name must be lowercase, alphanumeric with hyphens.\n`);
+        process.exit(1);
+    }
+    const parentNames = options.uses.split(',').map(s => s.trim()).filter(Boolean);
+    if (parentNames.length === 0) {
+        console.log(`\n❌ No parent tools specified.\n`);
+        process.exit(1);
+    }
+    // Verify each parent tool exists and fetch descriptions
+    console.log(`\n   Verifying parent tools...`);
+    const parents = [];
+    for (const parentName of parentNames) {
+        try {
+            const res = await fetch(`${API_BASE}/api/tools/${parentName}`);
+            if (!res.ok) {
+                console.log(`   ❌ Tool "${parentName}" not found in registry.`);
+                process.exit(1);
+            }
+            const tool = await res.json();
+            parents.push({ name: tool.name, description: tool.description || 'No description' });
+            console.log(`   ✓ ${tool.name} — ${(tool.description || '').slice(0, 50)}`);
+        }
+        catch {
+            console.log(`   ❌ Could not verify "${parentName}" — server unreachable.`);
+            process.exit(1);
+        }
+    }
+    // Generate scaffold JS
+    const stepsCode = parents.map((p, i) => {
+        const varName = p.name.replace(/-/g, '_');
+        return `  // Step ${i + 1}: ${p.description}
+  const ${varName}_result = devtopiaRun('${p.name}', { /* TODO: pass input */ });`;
+    }).join('\n\n');
+    const jsSource = `/**
+ * ${name} - [TODO: describe what this pipeline does]
+ * Builds on: ${parentNames.join(', ')} (via devtopia-runtime)
+ *
+${parents.map(p => ` * Composes ${p.name}: ${p.description}`).join('\n')}
+ *
+ * @param {Object} params
+ * @returns {Object} Pipeline result
+ */
+
+const { devtopiaRun } = require('./devtopia-runtime');
+const input = JSON.parse(process.argv[2] || '{}');
+
+// TODO: validate required input fields
+// if (!input.someField) {
+//   console.log(JSON.stringify({ error: 'Missing required field: someField' }));
+//   process.exit(1);
+// }
+
+try {
+${stepsCode}
+
+  // TODO: combine results and produce final output
+  console.log(JSON.stringify({
+    success: true,
+    // result: ...,
+    steps: ${JSON.stringify(parentNames)},
+  }));
+} catch (error) {
+  console.log(JSON.stringify({ error: error.message }));
+  process.exit(1);
+}
+`;
+    const mdSource = `# ${name}
+
+[TODO: describe what this pipeline does]
+
+## Composes
+
+${parents.map(p => `- \`${p.name}\` — ${p.description}`).join('\n')}
+
+## Usage
+
+\`\`\`bash
+devtopia run ${name} '{"TODO": "add input"}'
+\`\`\`
+
+## Input
+
+[TODO: document input fields]
+
+## Output
+
+\`\`\`json
+{
+  "success": true,
+  "steps": ${JSON.stringify(parentNames)}
+}
+\`\`\`
+`;
+    // Write files
+    const jsPath = `./${name}.js`;
+    const mdPath = `./${name}.md`;
+    if (existsSync(jsPath)) {
+        console.log(`\n⚠️  ${jsPath} already exists. Not overwriting.\n`);
+        process.exit(1);
+    }
+    writeFileSync(jsPath, jsSource);
+    writeFileSync(mdPath, mdSource);
+    console.log(`\n✅ Scaffold generated!`);
+    console.log(`\n   Files created:`);
+    console.log(`   ${jsPath}  — Tool source (edit the TODOs)`);
+    console.log(`   ${mdPath}  — README (edit the TODOs)`);
+    console.log(`\n   Next steps:`);
+    console.log(`   1. Edit ${jsPath} — fill in the TODOs with your logic`);
+    console.log(`   2. Test: devtopia run ${name} '{"test": "input"}'`);
+    console.log(`   3. Submit: devtopia submit ${name} ./${name}.js --builds-on ${parentNames.join(',')}\n`);
+}

package/dist/commands/docs.js

@@ -785,7 +785,7 @@ Available documentation:
   devtopia docs tool-format    → Tool structure and format specification
   devtopia docs faq            → Frequently asked questions
 
-These docs match the GitHub repository: https://github.com/Devtopia/Devtopia
+These docs match the GitHub repository: https://github.com/DevtopiaHub/Devtopia
 
 For the full onboarding experience, run: devtopia start
 `);

package/dist/commands/run.d.ts

@@ -1 +1,6 @@
-export declare function run(toolName: string, inputArg?: string): Promise<void>;
+interface RunOptions {
+    json?: boolean;
+    quiet?: boolean;
+}
+export declare function run(toolName: string, inputArg?: string, options?: RunOptions): Promise<void>;
+export {};

package/dist/commands/run.js

@@ -1,5 +1,21 @@
 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 quotePath = (p) => (p.includes(' ') ? `"${p.replace(/"/g, '\\"')}"` : p);
+        if (existsSync(indexJs)) {
+            process.env.DEVTOPIA_CLI = `node ${quotePath(indexJs)}`;
+        }
+        else if (existsSync(indexTs)) {
+            process.env.DEVTOPIA_CLI = `npx tsx ${quotePath(indexTs)}`;
+        }
+    }
     // Parse input
     let input = {};
     if (inputArg) {
@@ -7,19 +23,54 @@ export async function run(toolName, inputArg) {
             input = JSON.parse(inputArg);
         }
         catch {
-            console.log(`\n❌ Invalid JSON input: ${inputArg}\n`);
-            process.exit(1);
+            if (options.json) {
+                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);
+            }
+        }
+    }
+    if (!options.json && !options.quiet) {
+        console.log(`\n⚡ Running /${toolName} locally...`);
+    }
+    const result = await executeTool(toolName, input, { strictJson: options.json });
+    // 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 (options.json) {
+        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) + '\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 }) + '\n');
+        }
+        process.exit(0);
     }
-    console.log(`\n⚡ Running /${toolName} locally...`);
-    const result = await executeTool(toolName, input);
     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 (!options.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>;