@moda-ai/cli 1.0.1 → 1.0.3

package/dist/__tests__/schemas.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schemas.test.d.ts.map

package/dist/__tests__/schemas.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { OverviewSchema, ClustersSchema, ClusterConversationsSchema, ConversationsSchema, ContextSchema, FrustrationsSchema, ToolFailuresSchema, ToolFailureDetailSchema, } from '../schemas.js';
+describe('OverviewSchema', () => {
+    it('accepts valid days_back', () => {
+        expect(OverviewSchema.parse({ days_back: 30 })).toEqual({ days_back: 30 });
+    });
+    it('accepts empty object with defaults', () => {
+        expect(OverviewSchema.parse({})).toEqual({});
+    });
+    it('rejects days_back > 90', () => {
+        expect(() => OverviewSchema.parse({ days_back: 91 })).toThrow();
+    });
+    it('rejects days_back < 1', () => {
+        expect(() => OverviewSchema.parse({ days_back: 0 })).toThrow();
+    });
+});
+describe('ClustersSchema', () => {
+    it('accepts all backend time_range values', () => {
+        for (const val of ['all', '1h', '3d', '7d', '24h', '30d', '90d']) {
+            expect(ClustersSchema.parse({ time_range: val }).time_range).toBe(val);
+        }
+    });
+    it('rejects invalid time_range', () => {
+        expect(() => ClustersSchema.parse({ time_range: '2d' })).toThrow();
+    });
+});
+describe('ConversationsSchema', () => {
+    it('accepts 3d time_range (previously missing)', () => {
+        expect(ConversationsSchema.parse({ time_range: '3d' }).time_range).toBe('3d');
+    });
+    it('accepts all valid time_range values', () => {
+        for (const val of ['all', '1h', '3d', '24h', '7d', '30d', '90d']) {
+            expect(ConversationsSchema.parse({ time_range: val }).time_range).toBe(val);
+        }
+    });
+});
+describe('FrustrationsSchema', () => {
+    it('accepts limit up to 20', () => {
+        expect(FrustrationsSchema.parse({ limit: 20 }).limit).toBe(20);
+    });
+    it('rejects limit > 20 (previously allowed 100)', () => {
+        expect(() => FrustrationsSchema.parse({ limit: 21 })).toThrow();
+    });
+});
+describe('ToolFailureDetailSchema', () => {
+    it('accepts limit up to 20', () => {
+        expect(ToolFailureDetailSchema.parse({ tool_name: 'search', limit: 20 }).limit).toBe(20);
+    });
+    it('rejects limit > 20 (previously allowed 100)', () => {
+        expect(() => ToolFailureDetailSchema.parse({ tool_name: 'search', limit: 21 })).toThrow();
+    });
+    it('requires tool_name', () => {
+        expect(() => ToolFailureDetailSchema.parse({})).toThrow();
+    });
+});
+describe('ClusterConversationsSchema', () => {
+    it('requires node_id', () => {
+        expect(() => ClusterConversationsSchema.parse({})).toThrow();
+    });
+    it('accepts valid input', () => {
+        const result = ClusterConversationsSchema.parse({ node_id: 'cluster-1', limit: 10, offset: 0 });
+        expect(result.node_id).toBe('cluster-1');
+    });
+});
+describe('ContextSchema', () => {
+    it('requires conversation_id', () => {
+        expect(() => ContextSchema.parse({})).toThrow();
+    });
+    it('accepts msg_index of 0', () => {
+        expect(ContextSchema.parse({ conversation_id: 'conv-1', msg_index: 0 }).msg_index).toBe(0);
+    });
+    it('rejects window > 5', () => {
+        expect(() => ContextSchema.parse({ conversation_id: 'conv-1', window: 6 })).toThrow();
+    });
+});
+describe('ToolFailuresSchema', () => {
+    it('accepts valid days_back', () => {
+        expect(ToolFailuresSchema.parse({ days_back: 14 }).days_back).toBe(14);
+    });
+});
+//# sourceMappingURL=schemas.test.js.map

package/dist/auth.d.ts

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

package/dist/auth.js

@@ -0,0 +1,187 @@
+// 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(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') {
+                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');
+            if (screen === 'signup') {
+                authUrl.searchParams.set('screen_hint', 'signup');
+            }
+            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);
 }

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,94 @@
+// src/init/index.ts — Full moda init wizard orchestrator
+import { select } from '@inquirer/prompts';
+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) {
+        const action = await select({
+            message: 'Get started',
+            choices: [
+                { name: 'Sign up', value: 'signup' },
+                { name: 'Login', value: 'login' },
+            ],
+        });
+        console.log(`  Opening browser to ${action === 'signup' ? 'sign up' : 'log in'}...`);
+        token = await login(action);
+        console.log('  Authentication 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