@moda-ai/cli 1.0.4 → 1.1.0

package/.env.example

@@ -1,8 +1,8 @@
 # Moda API Key (required)
-# Get this from https://app.modaflows.com/settings
+# Get this from https://moda.dev/settings
 MODA_API_KEY=moda_sk_...
 
 # Moda Backend URL (optional)
-# Defaults to production: https://modaflows.com
+# Defaults to production: https://moda.dev
 # For local development, override with:
 # MODA_BASE_URL=http://localhost:3001

package/README.md

@@ -1,8 +1,8 @@
 # moda-cli
 
-CLI and MCP server for [Moda](https://modaflows.com) -- AI agent analytics and observability.
+CLI for [Moda](https://moda.dev) -- AI agent analytics and observability.
 
-Query your conversation analytics from the terminal or connect AI assistants (Claude Code, Cursor, etc.) to your Moda data via the Model Context Protocol.
+Query your conversation analytics from the terminal.
 
 ## Install
 
@@ -18,13 +18,21 @@ npx -p @moda-ai/cli moda overview
 
 ## Setup
 
-Get your API key from [modaflows.com/settings](https://modaflows.com/settings), then:
+Run the wizard to authenticate, pick an org, and provision an API key:
+
+```bash
+moda init
+```
+
+Or set the key manually:
 
 ```bash
 export MODA_API_KEY="moda_sk_..."
 ```
 
-## CLI Usage
+Get your API key from [moda.dev/settings](https://moda.dev/settings).
+
+## Usage
 
 ```bash
 moda overview                                    # Dashboard overview
@@ -44,9 +52,20 @@ moda context <conversation_id> --msg-index=5     # Center on message 5
 
 moda frustrations                                # User frustration detections
 moda frustrations --days-back=14 --limit=20
+moda frustrations --include-window --window=1    # Attach 3-message slice per row
 
 moda tool-failures                               # Tool failure overview
 moda tool-failure-detail <tool_name>             # Per-tool failure detail
+moda tool-failure-detail <tool_name> --include-window --window=1
+
+# Agent runs runtime (workflows = recurring class, run = one execution)
+moda workflows --time-range=7d                   # Recurring workflow catalog with health
+moda runs                                        # Last 7d of workflow executions
+moda runs --time-range=24h --outcome=partial     # Last 24h, partial completions only
+moda runs --class-id=cron:helpscout-triage-hourly # Scoped to one workflow class
+moda run <run_id>                                # One execution + its side-effect receipts
+moda loops                                       # Currently-active loop detections
+moda loop <detection_id>                         # One loop detail (signature + blast radius)
 ```
 
 All commands output JSON. Pipe to `jq` for filtering:
@@ -54,70 +73,53 @@ All commands output JSON. Pipe to `jq` for filtering:
 ```bash
 moda overview | jq '.frustrations'
 moda frustrations | jq '.frustrations[].primary_cause'
+moda runs --outcome=partial | jq '.runs[] | {job_id, intent_summary, outcome_reason}'
+moda loops | jq '.loops | sort_by(-.cycle_visits) | .[0:5] | .[].loop_signature_human'
+moda workflows | jq '.workflows | sort_by(.health) | .[] | select(.health < 0.8)'
 ```
 
-## MCP Server
-
-### Claude Code
+## Anchors and message windows
 
-```bash
-claude mcp add moda -- npx -y @moda-ai/cli
-```
-
-Or add manually to your MCP config:
+Rows returned by `moda frustrations` and `moda tool-failure-detail` carry
+a top-level `anchor` block naming the exact turn the event fired on:
 
 ```json
-{
-  "mcpServers": {
-    "moda": {
-      "command": "npx",
-      "args": ["-y", "@moda-ai/cli"],
-      "env": {
-        "MODA_API_KEY": "moda_sk_your_key_here"
-      }
-    }
-  }
-}
+// frustrations
+{ "kind": "frustration",  "conversation_id": "...", "msg_index": 12,
+  "signal": "exasperation", "quote_preview": "...", "all_turns": [...],
+  "no_anchor": false }
+
+// tool-failure-detail examples
+{ "kind": "tool_failure",  "conversation_id": "...", "msg_index": 7,
+  "tool_name": "search", "tool_use_id": "...",
+  "error_subtype": "SEARCH_NO_RESULTS", "no_anchor": false }
 ```
 
-### Other MCP Clients (Cursor, etc.)
-
-```json
-{
-  "command": "npx",
-  "args": ["-y", "@moda-ai/cli"],
-  "env": {
-    "MODA_API_KEY": "moda_sk_your_key_here"
-  }
-}
-```
+`msg_index` is the 0-indexed turn where the breakage happened. For
+frustrations it's derived from `key_turns[0]` (the same turn the API centers
+the embedded window on), falling back to `user_quotes[0].turn` when
+`key_turns` is empty. `no_anchor: true` means no anchor could be derived for
+that row.
 
-### Available MCP Tools
+Both commands accept two flags to inline a message window per row:
 
-| Tool | Description |
-|------|-------------|
-| `moda_get_overview` | Dashboard overview with KPIs, top clusters, recent activity |
-| `moda_get_clusters` | Browse topic cluster hierarchy |
-| `moda_get_cluster_conversations` | List conversations in a specific cluster |
-| `moda_search_conversations` | Search and filter conversations |
-| `moda_get_conversation_context` | Get windowed conversation context (max 5 messages) |
-| `moda_get_frustrations` | User frustration detections with evidence |
-| `moda_get_tool_failures` | Tool failure overview |
-| `moda_get_tool_failure_detail` | Per-tool failure detail with examples |
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--include-window` | off | Attach a `window` field with the message slice centered on the anchor |
+| `--window=N` | `1` | Half-width (1–5). `--window=1` ⇒ 3 messages total (anchor ± 1) |
 
 ## Environment Variables
 
 | Variable | Required | Default | Description |
 |----------|----------|---------|-------------|
 | `MODA_API_KEY` | Yes | -- | Your Moda API key (`moda_sk_...`) |
-| `MODA_BASE_URL` | No | `https://modaflows.com` | Base URL for the Data API |
+| `MODA_BASE_URL` | No | `https://moda.dev` | Base URL for the Data API |
 
 ## Documentation
 
-- [CLI Reference](https://docs.modaflows.com/data-api/cli)
-- [MCP Server Setup](https://docs.modaflows.com/data-api/mcp)
-- [Data API Overview](https://docs.modaflows.com/data-api/overview)
-- [Quickstart](https://docs.modaflows.com/quickstart)
+- [CLI Reference](https://docs.moda.dev/data-api/cli)
+- [Data API Overview](https://docs.moda.dev/data-api/overview)
+- [Quickstart](https://docs.moda.dev/quickstart)
 
 ## License
 

package/dist/auth.js

@@ -1,24 +1,13 @@
-// src/auth.ts — Browser-based PKCE authentication for moda init
-import { createHash, randomBytes } from 'node:crypto';
+// src/auth.ts — Browser-based authentication for moda init via frontend
 import { createServer } from 'node:http';
 import { readFileSync, writeFileSync, mkdirSync, chmodSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { MODA_BASE_URL } from './config.js';
-const AUTH0_DOMAIN = 'dev-6kukcoznniv30wau.us.auth0.com';
-const AUTH0_CLIENT_ID = 'JuqWjslalOwI9TXLeU2KkF0NTZab3qgC';
-const AUTH0_AUDIENCE = 'https://moda-api';
 const CALLBACK_PORT = 8432;
 const AUTH_TIMEOUT_MS = 120_000;
 const MODA_DIR = join(homedir(), '.moda');
 const TOKEN_PATH = join(MODA_DIR, 'auth.json');
-// --- PKCE ---
-function generateVerifier() {
-    return randomBytes(32).toString('base64url');
-}
-function generateChallenge(verifier) {
-    return createHash('sha256').update(verifier).digest('base64url');
-}
 export function loadToken() {
     try {
         if (!existsSync(TOKEN_PATH))
@@ -56,71 +45,64 @@ const SUCCESS_HTML = `<!DOCTYPE html>
 </div>
 <script>setTimeout(()=>window.close(),2000)</script>
 </body></html>`;
+// Page served at /callback that extracts token from URL fragment and
+// forwards it to /callback-token as query params (fragments never reach the server).
+const FRAGMENT_EXTRACTOR_HTML = `<!DOCTYPE html>
+<html><body>
+<script>
+var h = window.location.hash.substring(1);
+if (h) {
+  window.location.replace('/callback-token?' + h);
+} else {
+  document.body.innerText = 'No token received.';
+}
+</script>
+</body></html>`;
 export async function login(screen = 'login') {
-    const verifier = generateVerifier();
-    const challenge = generateChallenge(verifier);
     return new Promise((resolve, reject) => {
         let settled = false;
         const server = createServer(async (req, res) => {
             if (settled)
                 return;
             const url = new URL(req.url || '/', `http://localhost:${CALLBACK_PORT}`);
-            if (url.pathname !== '/callback') {
+            // Serve fragment extractor at /callback — the frontend redirects here
+            // with token in the URL fragment (#token=...) which never reaches the server.
+            // This page extracts it client-side and forwards to /callback-token as query params.
+            if (url.pathname === '/callback') {
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(FRAGMENT_EXTRACTOR_HTML);
+                return;
+            }
+            if (url.pathname !== '/callback-token') {
                 res.writeHead(404);
                 res.end('Not found');
                 return;
             }
-            const code = url.searchParams.get('code');
+            const token = url.searchParams.get('token');
+            const expiresIn = url.searchParams.get('expires_in');
             const error = url.searchParams.get('error');
-            const errorDescription = url.searchParams.get('error_description');
             if (error) {
                 res.writeHead(400, { 'Content-Type': 'text/html' });
-                res.end(`<html><body><h2>Error</h2><p>${errorDescription || error}</p></body></html>`);
+                res.end(`<html><body><h2>Error</h2><p>${error}</p></body></html>`);
                 settled = true;
                 server.close();
-                reject(new Error(`Auth0 error: ${errorDescription || error}`));
+                reject(new Error(`Authentication error: ${error}`));
                 return;
             }
-            if (!code) {
+            if (!token) {
                 res.writeHead(400, { 'Content-Type': 'text/html' });
-                res.end('<html><body><h2>Error</h2><p>No authorization code received.</p></body></html>');
+                res.end('<html><body><h2>Error</h2><p>No token received.</p></body></html>');
                 settled = true;
                 server.close();
-                reject(new Error('No authorization code received'));
+                reject(new Error('No token received'));
                 return;
             }
-            // Exchange code for tokens
-            try {
-                const tokenResponse = await fetch(`https://${AUTH0_DOMAIN}/oauth/token`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        grant_type: 'authorization_code',
-                        client_id: AUTH0_CLIENT_ID,
-                        code,
-                        redirect_uri: `http://localhost:${CALLBACK_PORT}/callback`,
-                        code_verifier: verifier,
-                    }),
-                });
-                if (!tokenResponse.ok) {
-                    const errBody = await tokenResponse.text();
-                    throw new Error(`Token exchange failed (${tokenResponse.status}): ${errBody}`);
-                }
-                const tokens = (await tokenResponse.json());
-                saveToken(tokens.access_token, tokens.expires_in);
-                res.writeHead(200, { 'Content-Type': 'text/html' });
-                res.end(SUCCESS_HTML);
-                settled = true;
-                server.close();
-                resolve(tokens.access_token);
-            }
-            catch (err) {
-                res.writeHead(500, { 'Content-Type': 'text/html' });
-                res.end('<html><body><h2>Error</h2><p>Token exchange failed.</p></body></html>');
-                settled = true;
-                server.close();
-                reject(err);
-            }
+            saveToken(token, parseInt(expiresIn || '86400', 10));
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(SUCCESS_HTML);
+            settled = true;
+            server.close();
+            resolve(token);
         });
         // Timeout
         const timeout = setTimeout(() => {
@@ -140,23 +122,13 @@ export async function login(screen = 'login') {
             }
         });
         server.listen(CALLBACK_PORT, async () => {
-            const authUrl = new URL(`https://${AUTH0_DOMAIN}/authorize`);
-            authUrl.searchParams.set('response_type', 'code');
-            authUrl.searchParams.set('client_id', AUTH0_CLIENT_ID);
-            authUrl.searchParams.set('redirect_uri', `http://localhost:${CALLBACK_PORT}/callback`);
-            authUrl.searchParams.set('audience', AUTH0_AUDIENCE);
-            authUrl.searchParams.set('scope', 'openid profile email');
-            authUrl.searchParams.set('code_challenge', challenge);
-            authUrl.searchParams.set('code_challenge_method', 'S256');
-            if (screen === 'signup') {
-                authUrl.searchParams.set('screen_hint', 'signup');
-            }
+            const authUrl = `${MODA_BASE_URL}/auth/cli?port=${CALLBACK_PORT}&screen=${screen}`;
             try {
                 const open = (await import('open')).default;
-                await open(authUrl.toString());
+                await open(authUrl);
             }
             catch {
-                console.error(`  Open this URL in your browser:\n  ${authUrl.toString()}`);
+                console.error(`  Open this URL in your browser:\n  ${authUrl}`);
             }
         });
         // Clean up on process exit

package/dist/cli.d.ts

@@ -6,5 +6,6 @@ interface ParsedArgs {
 }
 export declare function parseArgs(argv: string[]): ParsedArgs;
 export declare function flagsToArgs(flags: Record<string, string>, positionalKey?: string, positionalValue?: string): Record<string, unknown>;
+export declare function runCommand(command: string, positional: string | undefined, flags: Record<string, string>): Promise<void>;
 export {};
 //# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -2,7 +2,8 @@
 import { z } from 'zod';
 import { validateConfig, VERSION } from './config.js';
 import { callDataAPI, ApiError } from './api-client.js';
-import { OverviewSchema, ClustersSchema, ClusterConversationsSchema, ConversationsSchema, ContextSchema, FrustrationsSchema, ToolFailuresSchema, ToolFailureDetailSchema, } from './schemas.js';
+import { OverviewSchema, ClustersSchema, ClusterConversationsSchema, ConversationsSchema, ContextSchema, FrustrationsSchema, ToolFailuresSchema, ToolFailureDetailSchema, WorkflowsSchema, RunsSchema, RunDetailSchema, LoopsSchema, LoopDetailSchema, } from './schemas.js';
+import { withFrustrationAnchors, withToolFailureAnchors, embeddedWindowSize, asRecord, asString, asNumber } from './transforms.js';
 export function parseArgs(argv) {
     const args = argv.slice(2);
     const command = args[0] || '';
@@ -67,6 +68,13 @@ Commands:
   tool-failures                    Get tool failure overview
   tool-failure-detail <tool_name>  Get per-tool failure detail
 
+  Agent runs runtime:
+  workflows                        Recurring workflow catalog (per-class 30d health)
+  runs                             List workflow executions with classified outcomes
+  run <run_id>                     Get single execution + side-effect receipts
+  loops                            Currently-active loop detections
+  loop <detection_id>              Single loop detail
+
 Options:
   --help                           Show this help message
   --version                        Show version number
@@ -77,25 +85,74 @@ Common flags:
   --offset=N                       Number of results to skip
   --time-range=RANGE               Time range filter (all|1h|3d|7d|24h|30d|90d)
 
+Runs flags:
+  --outcome=OUTCOME                Filter by outcome (running|succeeded|partial|failed|loop|abandoned|unknown)
+  --class-id=ID                    Filter to a single workflow class (e.g. cron:helpscout-triage-hourly)
+  --user-id=ID                     Filter to a single user
+
 Init flags:
   --yes                            Accept all defaults (non-interactive)
-  --skip-sdk                       Skip SDK installation
-  --skip-mcp                       Skip MCP server configuration
 
 Examples:
   moda init
-  moda init --yes
-  moda overview
   moda overview --days-back=30
   moda clusters --time-range=7d
   moda conversations --search="error" --limit=5
   moda frustrations --days-back=14 --limit=20
-  moda context <conversation_id> --window=3`);
+  moda context <conversation_id> --window=3
+  moda workflows --time-range=7d
+  moda runs --time-range=24h --outcome=partial
+  moda runs --class-id=cron:helpscout-triage-hourly --limit=20
+  moda run 12345678-1234-1234-1234-1234567890ab
+  moda loops --limit=10
+  moda loop 12345678-1234-1234-1234-1234567890ab`);
 }
 // --- Command Handlers ---
-// Each handler replicates the URL construction from src/handlers.ts
-// but outputs JSON directly instead of wrapping in MCP envelope.
-async function runCommand(command, positional, flags) {
+async function attachWindows(rows, windowSize) {
+    return Promise.all(rows.map(async (row) => {
+        const anchor = asRecord(row.anchor);
+        if (!anchor || anchor.no_anchor === true) {
+            return { ...row, window: null };
+        }
+        const msg_index = asNumber(anchor.msg_index);
+        if (msg_index === null) {
+            return { ...row, window: null };
+        }
+        const conv_id = asString(anchor.conversation_id) ?? '';
+        if (!conv_id) {
+            return { ...row, window: null };
+        }
+        const conversation = asRecord(row.conversation);
+        // embedded window may be wider than requested (backend default = 2); reuse anything ≥ requested
+        const embedded = conversation ? embeddedWindowSize(conversation) : null;
+        if (conversation && embedded !== null && embedded >= windowSize) {
+            return { ...row, window: conversation };
+        }
+        try {
+            const query = new URLSearchParams();
+            query.set('msg_index', msg_index.toString());
+            query.set('window', windowSize.toString());
+            const data = await callDataAPI(`/conversations/${conv_id}/context?${query.toString()}`);
+            return { ...row, window: data };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { ...row, window: { error: message } };
+        }
+    }));
+}
+async function printWithOptionalWindows(enriched, listKey, includeWindow, windowSize) {
+    if (!includeWindow) {
+        console.log(JSON.stringify(enriched, null, 2));
+        return;
+    }
+    const list = Array.isArray(enriched[listKey])
+        ? enriched[listKey]
+        : [];
+    const withWindows = await attachWindows(list, windowSize);
+    console.log(JSON.stringify({ ...enriched, [listKey]: withWindows }, null, 2));
+}
+export async function runCommand(command, positional, flags) {
     switch (command) {
         case 'overview': {
             const args = flagsToArgs(flags);
@@ -189,7 +246,7 @@ async function runCommand(command, positional, flags) {
                 query.set('offset', params.offset.toString());
             const queryString = query.toString() ? `?${query.toString()}` : '';
             const data = await callDataAPI(`/frustrations${queryString}`);
-            console.log(JSON.stringify(data, null, 2));
+            await printWithOptionalWindows(withFrustrationAnchors(data), 'frustrations', params.include_window === true, params.window ?? 1);
             break;
         }
         case 'tool-failures': {
@@ -219,6 +276,76 @@ async function runCommand(command, positional, flags) {
                 query.set('offset', params.offset.toString());
             const queryString = query.toString() ? `?${query.toString()}` : '';
             const data = await callDataAPI(`/tool-failures/${params.tool_name}${queryString}`);
+            await printWithOptionalWindows(withToolFailureAnchors(data), 'examples', params.include_window === true, params.window ?? 1);
+            break;
+        }
+        // ─── Workflows + Runs ──────────────────────────────────────
+        case 'workflows': {
+            const args = flagsToArgs(flags);
+            const params = WorkflowsSchema.parse(args);
+            const query = new URLSearchParams();
+            if (params.time_range)
+                query.set('time_range', params.time_range);
+            if (params.user_id)
+                query.set('user_id', params.user_id);
+            const queryString = query.toString() ? `?${query.toString()}` : '';
+            const data = await callDataAPI(`/workflows${queryString}`);
+            console.log(JSON.stringify(data, null, 2));
+            break;
+        }
+        case 'runs': {
+            const args = flagsToArgs(flags);
+            const params = RunsSchema.parse(args);
+            const query = new URLSearchParams();
+            if (params.time_range)
+                query.set('time_range', params.time_range);
+            if (params.outcome)
+                query.set('outcome', params.outcome);
+            if (params.class_id)
+                query.set('class_id', params.class_id);
+            if (params.user_id)
+                query.set('user_id', params.user_id);
+            if (params.limit)
+                query.set('limit', params.limit.toString());
+            if (params.offset !== undefined)
+                query.set('offset', params.offset.toString());
+            const queryString = query.toString() ? `?${query.toString()}` : '';
+            const data = await callDataAPI(`/runs${queryString}`);
+            console.log(JSON.stringify(data, null, 2));
+            break;
+        }
+        case 'run': {
+            if (!positional) {
+                console.error('Error: <run_id> is required');
+                console.error('Usage: moda run <run_id>');
+                process.exit(1);
+            }
+            const args = flagsToArgs(flags, 'run_id', positional);
+            const params = RunDetailSchema.parse(args);
+            const data = await callDataAPI(`/runs/${params.run_id}`);
+            console.log(JSON.stringify(data, null, 2));
+            break;
+        }
+        case 'loops': {
+            const args = flagsToArgs(flags);
+            const params = LoopsSchema.parse(args);
+            const query = new URLSearchParams();
+            if (params.limit)
+                query.set('limit', params.limit.toString());
+            const queryString = query.toString() ? `?${query.toString()}` : '';
+            const data = await callDataAPI(`/loops/active${queryString}`);
+            console.log(JSON.stringify(data, null, 2));
+            break;
+        }
+        case 'loop': {
+            if (!positional) {
+                console.error('Error: <detection_id> is required');
+                console.error('Usage: moda loop <detection_id>');
+                process.exit(1);
+            }
+            const args = flagsToArgs(flags, 'detection_id', positional);
+            const params = LoopDetailSchema.parse(args);
+            const data = await callDataAPI(`/loops/${params.detection_id}`);
             console.log(JSON.stringify(data, null, 2));
             break;
         }
@@ -250,11 +377,10 @@ async function main() {
     await runCommand(command, positional, flags);
 }
 // Only run main() when this file is executed directly (not when imported as a module).
-// In ESM, import.meta.url is the file URL of the current module; process.argv[1] is
-// the path of the entry-point script. Comparing them lets tests import parseArgs /
-// flagsToArgs without triggering the CLI bootstrap.
 import { fileURLToPath } from 'url';
-const isMain = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+import { realpathSync } from 'fs';
+const isMain = process.argv[1] &&
+    fileURLToPath(import.meta.url) === realpathSync(process.argv[1]);
 if (isMain) {
     main().catch((error) => {
         if (error instanceof z.ZodError) {

package/dist/config.d.ts

@@ -1,6 +1,5 @@
-export declare const VERSION = "1.0.0";
+export declare const VERSION = "1.0.4";
 export declare const MODA_API_KEY: string | undefined;
 export declare const MODA_BASE_URL: string;
-export declare const PORT: number;
 export declare function validateConfig(): void;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -1,12 +1,11 @@
 // src/config.ts
-export const VERSION = '1.0.0';
+export const VERSION = '1.0.4';
 export const MODA_API_KEY = process.env.MODA_API_KEY;
-export const MODA_BASE_URL = process.env.MODA_BASE_URL || 'https://modaflows.com';
-export const PORT = parseInt(process.env.PORT || '3003', 10);
+export const MODA_BASE_URL = process.env.MODA_BASE_URL || 'https://moda.dev';
 export function validateConfig() {
     if (!MODA_API_KEY) {
         console.error('Error: MODA_API_KEY environment variable is required');
-        console.error('Get your API key from https://modaflows.com/settings');
+        console.error('Get your API key from https://moda.dev/settings');
         process.exit(1);
     }
 }

package/dist/init/detect.d.ts

@@ -4,6 +4,6 @@ export interface ProjectInfo {
     llmProviders: string[];
 }
 export declare function detectProject(): Promise<ProjectInfo>;
-export declare function installSDK(project: ProjectInfo): Promise<void>;
+export declare function installSDK(project: ProjectInfo): Promise<boolean>;
 export declare function getInitSnippet(project: ProjectInfo): string;
 //# sourceMappingURL=detect.d.ts.map

package/dist/init/detect.js

@@ -2,7 +2,7 @@
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { execSync } from 'node:child_process';
-import { select } from '@inquirer/prompts';
+import { select, confirm } from '@inquirer/prompts';
 const LOCKFILE_TO_PM = {
     'package-lock.json': 'npm',
     'yarn.lock': 'yarn',
@@ -59,8 +59,21 @@ export async function detectProject() {
                 break;
             }
         }
-        if (!packageManager)
-            packageManager = 'npm';
+        // No lockfile — detect which package manager is actually installed
+        if (!packageManager) {
+            for (const pm of ['bun', 'pnpm', 'yarn', 'npm']) {
+                try {
+                    execSync(`${pm} --version`, { stdio: 'pipe' });
+                    packageManager = pm;
+                    break;
+                }
+                catch {
+                    // not installed
+                }
+            }
+            if (!packageManager)
+                packageManager = 'npm';
+        }
     }
     else if (language === 'python') {
         if (existsSync(join(cwd, 'poetry.lock'))) {
@@ -115,19 +128,29 @@ function detectLLMProviders(cwd, language) {
 }
 export async function installSDK(project) {
     if (!project.packageManager)
-        return;
+        return false;
     const command = INSTALL_COMMANDS[project.packageManager];
     if (!command)
-        return;
+        return false;
+    const shouldInstall = await confirm({
+        message: `Install moda-ai SDK? (${command})`,
+        default: true,
+    });
+    if (!shouldInstall) {
+        console.log(`  Skipped. Run manually: ${command}`);
+        return false;
+    }
     console.log(`  Installing moda-ai (${project.packageManager})...`);
     try {
         execSync(command, { cwd: process.cwd(), stdio: 'pipe' });
         console.log('  Installed moda-ai');
+        return true;
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         console.error(`  Warning: SDK install failed: ${message}`);
         console.error(`  Run manually: ${command}`);
+        return false;
     }
 }
 export function getInitSnippet(project) {