@moda-ai/cli 1.0.1 → 1.0.2

package/README.md

@@ -7,13 +7,13 @@ Query your conversation analytics from the terminal or connect AI assistants (Cl
 ## Install
 
 ```bash
-npm install -g moda-cli
+npm install -g @moda-ai/cli
 ```
 
 Or use without installing:
 
 ```bash
-npx moda-cli overview
+npx -p @moda-ai/cli moda overview
 ```
 
 ## Setup
@@ -61,7 +61,7 @@ moda frustrations | jq '.frustrations[].primary_cause'
 ### Claude Code
 
 ```bash
-claude mcp add moda -- npx moda-cli
+claude mcp add moda -- npx -y @moda-ai/cli
 ```
 
 Or add manually to your MCP config:
@@ -71,7 +71,7 @@ Or add manually to your MCP config:
   "mcpServers": {
     "moda": {
       "command": "npx",
-      "args": ["-y", "moda-cli"],
+      "args": ["-y", "@moda-ai/cli"],
       "env": {
         "MODA_API_KEY": "moda_sk_your_key_here"
       }
@@ -85,7 +85,7 @@ Or add manually to your MCP config:
 ```json
 {
   "command": "npx",
-  "args": ["-y", "moda-cli"],
+  "args": ["-y", "@moda-ai/cli"],
   "env": {
     "MODA_API_KEY": "moda_sk_your_key_here"
   }

package/dist/auth.d.ts

@@ -0,0 +1,4 @@
+export declare function loadToken(): string | null;
+export declare function login(): Promise<string>;
+export declare function authFetch(path: string, options?: RequestInit): Promise<Response>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.js

@@ -0,0 +1,184 @@
+// src/auth.ts — Browser-based PKCE authentication for moda init
+import { createHash, randomBytes } from 'node:crypto';
+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))
+            return null;
+        const data = JSON.parse(readFileSync(TOKEN_PATH, 'utf8'));
+        if (data.expires_at && Date.now() / 1000 > data.expires_at - 60) {
+            return null; // Expired or about to expire
+        }
+        return data.access_token || null;
+    }
+    catch {
+        return null;
+    }
+}
+function saveToken(accessToken, expiresIn) {
+    mkdirSync(MODA_DIR, { recursive: true });
+    const data = {
+        access_token: accessToken,
+        expires_at: Math.floor(Date.now() / 1000) + expiresIn,
+    };
+    writeFileSync(TOKEN_PATH, JSON.stringify(data, null, 2), { mode: 0o600 });
+    try {
+        chmodSync(TOKEN_PATH, 0o600);
+    }
+    catch {
+        // chmod may fail on some systems, the mode flag above handles it
+    }
+}
+// --- Login Flow ---
+const SUCCESS_HTML = `<!DOCTYPE html>
+<html><body style="font-family:system-ui;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:#fafafa">
+<div style="text-align:center">
+<h2>Authenticated</h2>
+<p>You can close this tab and return to your terminal.</p>
+</div>
+<script>setTimeout(()=>window.close(),2000)</script>
+</body></html>`;
+export async function 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') {
+                res.writeHead(404);
+                res.end('Not found');
+                return;
+            }
+            const code = url.searchParams.get('code');
+            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>`);
+                settled = true;
+                server.close();
+                reject(new Error(`Auth0 error: ${errorDescription || error}`));
+                return;
+            }
+            if (!code) {
+                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.end('<html><body><h2>Error</h2><p>No authorization code received.</p></body></html>');
+                settled = true;
+                server.close();
+                reject(new Error('No authorization code 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);
+            }
+        });
+        // Timeout
+        const timeout = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                server.close();
+                reject(new Error('Authentication timed out. Please try again.'));
+            }
+        }, AUTH_TIMEOUT_MS);
+        server.on('close', () => clearTimeout(timeout));
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                reject(new Error(`Port ${CALLBACK_PORT} is in use. Close the process using it and try again.`));
+            }
+            else {
+                reject(err);
+            }
+        });
+        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');
+            try {
+                const open = (await import('open')).default;
+                await open(authUrl.toString());
+            }
+            catch {
+                console.error(`  Open this URL in your browser:\n  ${authUrl.toString()}`);
+            }
+        });
+        // Clean up on process exit
+        const cleanup = () => {
+            if (!settled) {
+                settled = true;
+                server.close();
+            }
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+    });
+}
+// --- Authenticated Fetch ---
+export async function authFetch(path, options = {}) {
+    const token = loadToken();
+    if (!token) {
+        throw new Error('Not authenticated. Run "moda init" to log in.');
+    }
+    const url = `${MODA_BASE_URL}${path}`;
+    const headers = new Headers(options.headers);
+    headers.set('Authorization', `Bearer ${token}`);
+    if (!headers.has('Content-Type') && options.body) {
+        headers.set('Content-Type', 'application/json');
+    }
+    return fetch(url, { ...options, headers });
+}
+//# sourceMappingURL=auth.js.map

package/dist/cli.js

@@ -57,6 +57,7 @@ function printHelp() {
     console.error(`Usage: moda <command> [options]
 
 Commands:
+  init                             Set up Moda in your project
   overview                         Dashboard overview with KPIs
   clusters                         Browse topic cluster hierarchy
   cluster-conversations <node_id>  List conversations in a cluster
@@ -76,7 +77,14 @@ Common flags:
   --offset=N                       Number of results to skip
   --time-range=RANGE               Time range filter (all|1h|3d|7d|24h|30d|90d)
 
+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
@@ -231,6 +239,13 @@ async function main() {
         printHelp();
         process.exit(command ? 0 : 1);
     }
+    // init does NOT require MODA_API_KEY — that's what it creates
+    if (command === 'init') {
+        const { runInit } = await import('./init/index.js');
+        const initFlags = flagsToArgs(flags);
+        await runInit(initFlags);
+        return;
+    }
     validateConfig();
     await runCommand(command, positional, flags);
 }
@@ -239,7 +254,9 @@ async function main() {
 // 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,4 +1,4 @@
-export declare const VERSION = "1.0.0";
+export declare const VERSION = "1.0.2";
 export declare const MODA_API_KEY: string | undefined;
 export declare const MODA_BASE_URL: string;
 export declare const PORT: number;

package/dist/config.js

@@ -1,5 +1,5 @@
 // src/config.ts
-export const VERSION = '1.0.0';
+export const VERSION = '1.0.2';
 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);

package/dist/init/detect.d.ts

@@ -0,0 +1,9 @@
+export interface ProjectInfo {
+    language: 'typescript' | 'python' | null;
+    packageManager: string | null;
+    llmProviders: string[];
+}
+export declare function detectProject(): Promise<ProjectInfo>;
+export declare function installSDK(project: ProjectInfo): Promise<void>;
+export declare function getInitSnippet(project: ProjectInfo): string;
+//# sourceMappingURL=detect.d.ts.map

package/dist/init/detect.js

@@ -0,0 +1,156 @@
+// src/init/detect.ts — Project detection and SDK installation
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { select } from '@inquirer/prompts';
+const LOCKFILE_TO_PM = {
+    'package-lock.json': 'npm',
+    'yarn.lock': 'yarn',
+    'pnpm-lock.yaml': 'pnpm',
+    'bun.lockb': 'bun',
+    'bun.lock': 'bun',
+    'poetry.lock': 'poetry',
+    'uv.lock': 'uv',
+};
+const INSTALL_COMMANDS = {
+    npm: 'npm install moda-ai',
+    yarn: 'yarn add moda-ai',
+    pnpm: 'pnpm add moda-ai',
+    bun: 'bun add moda-ai',
+    pip: 'pip install moda-ai',
+    poetry: 'poetry add moda-ai',
+    uv: 'uv add moda-ai',
+};
+const LLM_PATTERNS = [
+    { pattern: /from openai|import openai|require\(['"]openai['"]\)/i, name: 'OpenAI' },
+    { pattern: /from anthropic|import.*@anthropic-ai\/sdk|require\(['"]@anthropic-ai\/sdk['"]\)/i, name: 'Anthropic' },
+    { pattern: /from ai |import.*@ai-sdk|require\(['"](ai|@ai-sdk)/i, name: 'Vercel AI SDK' },
+    { pattern: /from langchain|import.*langchain/i, name: 'LangChain' },
+    { pattern: /from claude_agent_sdk|import.*claude.agent/i, name: 'Claude Agent SDK' },
+];
+export async function detectProject() {
+    const cwd = process.cwd();
+    const hasPackageJson = existsSync(join(cwd, 'package.json'));
+    const hasPython = existsSync(join(cwd, 'pyproject.toml')) ||
+        existsSync(join(cwd, 'requirements.txt')) ||
+        existsSync(join(cwd, 'Pipfile'));
+    let language = null;
+    if (hasPackageJson && hasPython) {
+        language = await select({
+            message: 'Both TypeScript and Python detected. Which to configure?',
+            choices: [
+                { name: 'TypeScript / JavaScript', value: 'typescript' },
+                { name: 'Python', value: 'python' },
+            ],
+        });
+    }
+    else if (hasPackageJson) {
+        language = 'typescript';
+    }
+    else if (hasPython) {
+        language = 'python';
+    }
+    // Detect package manager
+    let packageManager = null;
+    if (language === 'typescript') {
+        for (const [lockfile, pm] of Object.entries(LOCKFILE_TO_PM)) {
+            if (existsSync(join(cwd, lockfile))) {
+                packageManager = pm;
+                break;
+            }
+        }
+        if (!packageManager)
+            packageManager = 'npm';
+    }
+    else if (language === 'python') {
+        if (existsSync(join(cwd, 'poetry.lock'))) {
+            packageManager = 'poetry';
+        }
+        else if (existsSync(join(cwd, 'uv.lock'))) {
+            packageManager = 'uv';
+        }
+        else {
+            packageManager = 'pip';
+        }
+    }
+    // Detect LLM providers (shallow scan)
+    const llmProviders = detectLLMProviders(cwd, language);
+    return { language, packageManager, llmProviders };
+}
+function detectLLMProviders(cwd, language) {
+    if (!language)
+        return [];
+    const providers = new Set();
+    const extensions = language === 'typescript' ? ['.ts', '.tsx', '.js', '.jsx', '.mjs'] : ['.py'];
+    const dirs = ['src', 'app', 'lib', '.'];
+    for (const dir of dirs) {
+        const dirPath = join(cwd, dir);
+        if (!existsSync(dirPath))
+            continue;
+        try {
+            const files = readdirSync(dirPath, { withFileTypes: true });
+            for (const file of files) {
+                if (!file.isFile())
+                    continue;
+                if (!extensions.some((ext) => file.name.endsWith(ext)))
+                    continue;
+                try {
+                    const content = readFileSync(join(dirPath, file.name), 'utf8');
+                    for (const { pattern, name } of LLM_PATTERNS) {
+                        if (pattern.test(content)) {
+                            providers.add(name);
+                        }
+                    }
+                }
+                catch {
+                    // Skip unreadable files
+                }
+            }
+        }
+        catch {
+            // Skip unreadable dirs
+        }
+    }
+    return Array.from(providers);
+}
+export async function installSDK(project) {
+    if (!project.packageManager)
+        return;
+    const command = INSTALL_COMMANDS[project.packageManager];
+    if (!command)
+        return;
+    console.log(`  Installing moda-ai (${project.packageManager})...`);
+    try {
+        execSync(command, { cwd: process.cwd(), stdio: 'pipe' });
+        console.log('  Installed moda-ai');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`  Warning: SDK install failed: ${message}`);
+        console.error(`  Run manually: ${command}`);
+    }
+}
+export function getInitSnippet(project) {
+    if (project.language === 'typescript') {
+        return `
+    import { Moda } from 'moda-ai';
+
+    await Moda.init(process.env.MODA_API_KEY!);
+    // Moda.conversationId = 'your-session-id';
+    // ... your LLM calls are auto-instrumented ...
+    await Moda.flush();
+`;
+    }
+    if (project.language === 'python') {
+        return `
+    import moda
+
+    moda.init()  # reads MODA_API_KEY from env
+    # moda.conversation_id = 'your-session-id'
+    # ... your LLM calls are auto-instrumented ...
+    moda.flush()
+`;
+    }
+    return '';
+}
+//# sourceMappingURL=detect.js.map

package/dist/init/index.d.ts

@@ -0,0 +1,2 @@
+export declare function runInit(flags: Record<string, unknown>): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/init/index.js

@@ -0,0 +1,86 @@
+// src/init/index.ts — Full moda init wizard orchestrator
+import { login, loadToken } from '../auth.js';
+import { selectTenantAndCreateKey } from './tenant.js';
+import { detectProject, installSDK, getInitSnippet } from './detect.js';
+import { detectAgents, configureMCP } from './mcp.js';
+import { installRules } from './rules.js';
+export async function runInit(flags) {
+    const yes = flags.yes === true || flags.y === true;
+    const skipSdk = flags.skip_sdk === true;
+    const skipMcp = flags.skip_mcp === true;
+    console.log('\n  Moda — LLM Observability for Agents\n');
+    // Step 1: Authentication
+    console.log('  Step 1/5: Authentication');
+    let token = loadToken();
+    if (!token) {
+        console.log('  Opening browser for login...');
+        token = await login();
+        console.log('  Login successful');
+    }
+    else {
+        console.log('  Already authenticated (cached token)');
+    }
+    // Step 2: Tenant + API Key
+    console.log('\n  Step 2/5: Select Organization');
+    const { apiKey, tenantName } = await selectTenantAndCreateKey();
+    // Step 3: SDK
+    if (!skipSdk) {
+        console.log('\n  Step 3/5: Install SDK');
+        const project = await detectProject();
+        if (project.language) {
+            const parts = [project.language];
+            if (project.packageManager)
+                parts.push(project.packageManager);
+            if (project.llmProviders.length > 0) {
+                parts.push(project.llmProviders.join(', '));
+            }
+            console.log(`  Detected: ${parts.join(' / ')}`);
+            await installSDK(project);
+            const snippet = getInitSnippet(project);
+            if (snippet) {
+                console.log('\n  Add this to your entry file:');
+                console.log(snippet);
+            }
+        }
+        else {
+            console.log('  No project detected, skipping SDK installation');
+            console.log('  Install manually: npm install moda-ai (or pip install moda-ai)');
+        }
+    }
+    else {
+        console.log('\n  Step 3/5: Install SDK (skipped)');
+    }
+    // Step 4: MCP
+    if (!skipMcp) {
+        console.log('\n  Step 4/5: Configure MCP Server');
+        const agents = detectAgents();
+        if (agents.length > 0) {
+            console.log(`  Detected: ${agents.map((a) => a.name).join(', ')}`);
+            const configured = await configureMCP(agents, apiKey, yes);
+            if (configured.length > 0) {
+                console.log(`  Configured ${configured.length} agent(s): ${configured.join(', ')}`);
+            }
+        }
+        else {
+            console.log('  No coding agents detected');
+            console.log('  Manual setup: claude mcp add moda -- npx -y @moda-ai/cli');
+        }
+    }
+    else {
+        console.log('\n  Step 4/5: Configure MCP Server (skipped)');
+    }
+    // Step 5: Rules
+    console.log('\n  Step 5/5: Agent Rules (optional)');
+    const agentNames = detectAgents().map((a) => a.name);
+    if (agentNames.length > 0) {
+        await installRules(agentNames, yes);
+    }
+    else {
+        console.log('  Skipped (no agents detected)');
+    }
+    // Done
+    console.log(`\n  Setup complete for ${tenantName}!`);
+    console.log('  Dashboard: https://app.modaflows.com');
+    console.log('');
+}
+//# sourceMappingURL=index.js.map

package/dist/init/mcp.d.ts

@@ -0,0 +1,8 @@
+export interface DetectedAgent {
+    name: string;
+    configPath: string;
+    configKey: string;
+}
+export declare function detectAgents(): DetectedAgent[];
+export declare function configureMCP(agents: DetectedAgent[], apiKey: string, autoYes?: boolean): Promise<string[]>;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/init/mcp.js

@@ -0,0 +1,110 @@
+// src/init/mcp.ts — MCP server auto-configuration for coding agents
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { execSync } from 'node:child_process';
+import { checkbox } from '@inquirer/prompts';
+function isOnPath(cmd) {
+    try {
+        execSync(`which ${cmd}`, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function detectAgents() {
+    const cwd = process.cwd();
+    const agents = [];
+    // Claude Code
+    if (existsSync(join(cwd, '.claude')) || isOnPath('claude')) {
+        agents.push({
+            name: 'Claude Code',
+            configPath: join(cwd, '.claude', 'settings.local.json'),
+            configKey: 'mcpServers',
+        });
+    }
+    // Cursor
+    if (existsSync(join(cwd, '.cursor'))) {
+        agents.push({
+            name: 'Cursor',
+            configPath: join(cwd, '.cursor', 'mcp.json'),
+            configKey: 'mcpServers',
+        });
+    }
+    // VS Code
+    if (existsSync(join(cwd, '.vscode'))) {
+        agents.push({
+            name: 'VS Code',
+            configPath: join(cwd, '.vscode', 'mcp.json'),
+            configKey: 'servers',
+        });
+    }
+    return agents;
+}
+export async function configureMCP(agents, apiKey, autoYes = false) {
+    if (agents.length === 0)
+        return [];
+    let selected;
+    if (autoYes) {
+        selected = agents;
+    }
+    else {
+        const choices = agents.map((a) => ({
+            name: a.name,
+            value: a,
+            checked: true,
+        }));
+        selected = await checkbox({
+            message: 'Configure MCP server for:',
+            choices,
+        });
+    }
+    const configured = [];
+    for (const agent of selected) {
+        try {
+            writeAgentConfig(agent, apiKey);
+            configured.push(agent.name);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`  Warning: Failed to configure ${agent.name}: ${message}`);
+        }
+    }
+    // Show manual instructions for skipped agents
+    const skipped = agents.filter((a) => !selected.includes(a));
+    if (skipped.length > 0) {
+        console.log('\n  Manual setup for skipped agents:');
+        for (const agent of skipped) {
+            console.log(`    ${agent.name}: Add moda server to ${agent.configPath}`);
+        }
+    }
+    return configured;
+}
+function writeAgentConfig(agent, apiKey) {
+    // Ensure directory exists
+    const dir = dirname(agent.configPath);
+    mkdirSync(dir, { recursive: true });
+    // Read existing config
+    let config = {};
+    if (existsSync(agent.configPath)) {
+        try {
+            config = JSON.parse(readFileSync(agent.configPath, 'utf8'));
+        }
+        catch {
+            config = {};
+        }
+    }
+    // Merge moda server entry
+    const servers = config[agent.configKey] || {};
+    servers['moda'] = {
+        command: 'npx',
+        args: ['-y', '@moda-ai/cli'],
+        env: {
+            MODA_API_KEY: apiKey,
+        },
+    };
+    config[agent.configKey] = servers;
+    // Write back
+    writeFileSync(agent.configPath, JSON.stringify(config, null, 2) + '\n');
+}
+//# sourceMappingURL=mcp.js.map

package/dist/init/rules.d.ts

@@ -0,0 +1,2 @@
+export declare function installRules(detectedAgents: string[], autoYes?: boolean): Promise<void>;
+//# sourceMappingURL=rules.d.ts.map

package/dist/init/rules.js

@@ -0,0 +1,72 @@
+// src/init/rules.ts — Agent rules file installation
+import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { confirm } from '@inquirer/prompts';
+const MODA_RULES_CONTENT = `
+
+## Moda SDK
+
+Moda is integrated in this project for LLM observability. The \`moda-ai\` SDK
+auto-instruments OpenAI and Anthropic calls via OpenTelemetry.
+
+### Initialization
+
+- TypeScript: \`import { Moda } from 'moda-ai'; await Moda.init(process.env.MODA_API_KEY!);\`
+- Python: \`import moda; moda.init()\` (reads MODA_API_KEY from env)
+
+### Conversation Tracking
+
+Set conversation ID before LLM calls to group multi-turn conversations:
+- TypeScript: \`Moda.conversationId = 'session-id';\`
+- Python: \`moda.conversation_id = 'session-id'\`
+
+### Before Exit
+
+Flush pending traces before the process exits:
+- TypeScript: \`await Moda.flush();\`
+- Python: \`moda.flush()\`
+`;
+const AGENT_RULES_FILES = {
+    'Claude Code': 'CLAUDE.md',
+    'Cursor': '.cursor/rules/moda.mdc',
+};
+export async function installRules(detectedAgents, autoYes = false) {
+    const applicable = detectedAgents.filter((a) => a in AGENT_RULES_FILES);
+    if (applicable.length === 0) {
+        console.log('  No supported agents detected for rules files');
+        return;
+    }
+    let shouldInstall = autoYes;
+    if (!shouldInstall) {
+        shouldInstall = await confirm({
+            message: 'Install agent rules for coding assistants?',
+            default: true,
+        });
+    }
+    if (!shouldInstall)
+        return;
+    for (const agent of applicable) {
+        const filePath = join(process.cwd(), AGENT_RULES_FILES[agent]);
+        try {
+            const dir = dirname(filePath);
+            mkdirSync(dir, { recursive: true });
+            if (existsSync(filePath)) {
+                const content = readFileSync(filePath, 'utf8');
+                if (content.includes('## Moda SDK')) {
+                    console.log(`  ${agent}: Moda SDK section already exists in ${AGENT_RULES_FILES[agent]}`);
+                    continue;
+                }
+                appendFileSync(filePath, MODA_RULES_CONTENT);
+            }
+            else {
+                writeFileSync(filePath, MODA_RULES_CONTENT.trimStart());
+            }
+            console.log(`  Added Moda SDK reference to ${AGENT_RULES_FILES[agent]}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`  Warning: Failed to write ${AGENT_RULES_FILES[agent]}: ${message}`);
+        }
+    }
+}
+//# sourceMappingURL=rules.js.map

package/dist/init/tenant.d.ts

@@ -0,0 +1,9 @@
+interface BootstrapResult {
+    apiKey: string;
+    tenantId: string;
+    tenantName: string;
+    tenantSlug: string;
+}
+export declare function selectTenantAndCreateKey(): Promise<BootstrapResult>;
+export {};
+//# sourceMappingURL=tenant.d.ts.map

package/dist/init/tenant.js

@@ -0,0 +1,91 @@
+// src/init/tenant.ts — Tenant selection and API key provisioning
+import { select } from '@inquirer/prompts';
+import { readFileSync, writeFileSync, existsSync, appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { authFetch } from '../auth.js';
+export async function selectTenantAndCreateKey() {
+    // 1. Fetch CLI context
+    const contextRes = await authFetch('/api/cli/context');
+    if (!contextRes.ok) {
+        const body = await contextRes.text();
+        throw new Error(`Failed to fetch context (${contextRes.status}): ${body}`);
+    }
+    const ctx = (await contextRes.json());
+    console.log(`  Authenticated as ${ctx.user.email}`);
+    // 2. Select tenant
+    if (ctx.tenants.length === 0) {
+        console.error('  No organizations found. Create one at https://app.modaflows.com');
+        process.exit(1);
+    }
+    let tenantId;
+    if (ctx.tenants.length === 1) {
+        tenantId = ctx.tenants[0].id;
+        console.log(`  Organization: ${ctx.tenants[0].name}`);
+    }
+    else {
+        tenantId = await select({
+            message: 'Select organization',
+            choices: ctx.tenants.map((t) => ({
+                name: `${t.name} (${t.role})`,
+                value: t.id,
+            })),
+        });
+    }
+    // 3. Create API key via bootstrap endpoint
+    const bootstrapRes = await authFetch('/api/cli/bootstrap', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ tenantId }),
+    });
+    if (bootstrapRes.status === 403) {
+        console.error('  Error: You need admin or owner access to create API keys.');
+        console.error('  Ask your organization owner to upgrade your role.');
+        process.exit(1);
+    }
+    if (!bootstrapRes.ok) {
+        const body = await bootstrapRes.text();
+        throw new Error(`Failed to create API key (${bootstrapRes.status}): ${body}`);
+    }
+    const result = (await bootstrapRes.json());
+    // 4. Write .env
+    writeEnvFile(result.apiKey);
+    // 5. Update .gitignore
+    ensureGitignore();
+    console.log('  API key created and saved to .env');
+    return result;
+}
+function writeEnvFile(apiKey) {
+    const envPath = join(process.cwd(), '.env');
+    const line = `MODA_API_KEY=${apiKey}`;
+    if (existsSync(envPath)) {
+        const content = readFileSync(envPath, 'utf8');
+        if (content.includes('MODA_API_KEY=')) {
+            // Replace existing line
+            const updated = content.replace(/^MODA_API_KEY=.*$/m, line);
+            writeFileSync(envPath, updated);
+        }
+        else {
+            // Append
+            const separator = content.endsWith('\n') ? '' : '\n';
+            appendFileSync(envPath, `${separator}${line}\n`);
+        }
+    }
+    else {
+        writeFileSync(envPath, `${line}\n`);
+    }
+}
+function ensureGitignore() {
+    const gitignorePath = join(process.cwd(), '.gitignore');
+    if (existsSync(gitignorePath)) {
+        const content = readFileSync(gitignorePath, 'utf8');
+        const lines = content.split('\n').map((l) => l.trim());
+        if (!lines.includes('.env')) {
+            const separator = content.endsWith('\n') ? '' : '\n';
+            appendFileSync(gitignorePath, `${separator}.env\n`);
+        }
+    }
+    else {
+        writeFileSync(gitignorePath, '.env\n');
+    }
+}
+//# sourceMappingURL=tenant.js.map

package/dist/schemas.d.ts

@@ -38,18 +38,18 @@ export declare const ConversationsSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
     time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
-    search?: string | undefined;
     cluster_id?: string | undefined;
     user_id?: string | undefined;
     environment?: "all" | "development" | "staging" | "production" | undefined;
 }, {
+    search?: string | undefined;
     time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
-    search?: string | undefined;
     cluster_id?: string | undefined;
     user_id?: string | undefined;
     environment?: "all" | "development" | "staging" | "production" | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "CLI and MCP server for Moda - AI agent analytics and observability",
   "type": "module",
   "main": "dist/index.js",
@@ -52,9 +52,11 @@
     "url": "https://github.com/ModaLabs/moda-cli/issues"
   },
   "dependencies": {
+    "@inquirer/prompts": "^8.4.1",
     "@modelcontextprotocol/sdk": "^1.0.4",
     "cors": "^2.8.5",
     "express": "^4.21.2",
+    "open": "^11.0.0",
     "zod": "^3.24.1"
   },
   "devDependencies": {