@moda-ai/cli 1.0.4 → 1.0.5

package/dist/init/mcp.js

@@ -1,8 +1,7 @@
-// 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';
+// src/init/mcp.ts — Coding agent detection
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { execSync } from 'node:child_process';
-import { checkbox } from '@inquirer/prompts';
 function isOnPath(cmd) {
     try {
         execSync(`which ${cmd}`, { stdio: 'pipe' });
@@ -17,94 +16,12 @@ export function detectAgents() {
     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',
-        });
+        agents.push('Claude Code');
     }
     // 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',
-        });
+        agents.push('Cursor');
     }
     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

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

package/dist/init/rules.js

@@ -1,72 +1,165 @@
-// src/init/rules.ts — Agent rules file installation
-import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+// src/init/rules.ts — Install Moda agent skills into the user's project.
+//
+// Each entry in SKILLS is a directory under <package>/skills/ that contains a
+// SKILL.md (Claude Code format). At install time we copy each skill into every
+// detected coding agent, translating frontmatter where the agent expects a
+// different shape (e.g. Cursor's .mdc rules).
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 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',
+// --- Package path resolution ---
+//
+// Resolved relative to this module's URL so it works whether we're running
+// from src/ in dev or from the published dist/ inside node_modules.
+const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const SKILLS_SOURCE_DIR = join(PACKAGE_ROOT, 'skills');
+const SKILLS = [
+    {
+        id: 'integrate-moda',
+        label: 'integrate-moda — instrument this project with the Moda SDK',
+    },
+    {
+        id: 'moda-cli',
+        label: 'moda-cli — let coding agents query Moda analytics via the CLI',
+    },
+];
+const ADAPTERS = {
+    'Claude Code': {
+        name: 'Claude Code',
+        targetFor: (skillId) => ({
+            dir: join('.claude', 'skills', skillId),
+            filename: 'SKILL.md',
+        }),
+        transform: (content) => content,
+    },
+    'Cursor': {
+        name: 'Cursor',
+        targetFor: (skillId) => ({
+            dir: join('.cursor', 'rules'),
+            filename: `${skillId}.mdc`,
+        }),
+        transform: claudeSkillToCursorRule,
+    },
 };
-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');
+// --- Frontmatter translation ---
+//
+// Cursor's .mdc rules use a different frontmatter shape:
+//   ---
+//   description: "..."
+//   alwaysApply: false
+//   ---
+// The body markdown is identical, so we strip the Claude frontmatter, lift
+// the description out of it, and emit Cursor's variant.
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+const DESCRIPTION_RE = /^description:\s*(.+?)\s*$/m;
+function claudeSkillToCursorRule(skillContent) {
+    const match = FRONTMATTER_RE.exec(skillContent);
+    if (!match) {
+        // Body without frontmatter — pass through untouched rather than guess.
+        return skillContent;
+    }
+    const [, frontmatter, body] = match;
+    const descMatch = DESCRIPTION_RE.exec(frontmatter);
+    const description = descMatch?.[1].trim() ?? '';
+    // JSON.stringify gives us a YAML-safe double-quoted string with proper
+    // escaping for any quotes or backslashes inside the description.
+    const cursorFrontmatter = `---\n` +
+        `description: ${JSON.stringify(description)}\n` +
+        `alwaysApply: false\n` +
+        `---\n`;
+    return `${cursorFrontmatter}\n${body.replace(/^\s+/, '')}`;
+}
+// --- I/O helpers ---
+function loadSkillSource(skillId) {
+    const path = join(SKILLS_SOURCE_DIR, skillId, 'SKILL.md');
+    if (!existsSync(path)) {
+        throw new Error(`Skill source missing: ${path}`);
+    }
+    return readFileSync(path, 'utf8');
+}
+function installSkillForAgent(skill, adapter, content) {
+    const { dir, filename } = adapter.targetFor(skill.id);
+    const dirPath = join(process.cwd(), dir);
+    const filePath = join(dirPath, filename);
+    const relativePath = join(dir, filename);
+    try {
+        mkdirSync(dirPath, { recursive: true });
+        if (existsSync(filePath)) {
+            return { agent: adapter.name, relativePath, status: 'exists' };
+        }
+        writeFileSync(filePath, adapter.transform(content));
+        return { agent: adapter.name, relativePath, status: 'wrote' };
+    }
+    catch (err) {
+        return {
+            agent: adapter.name,
+            relativePath,
+            status: 'failed',
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+// --- Public entry point ---
+export async function installRules(detectedAgents) {
+    const adapters = detectedAgents
+        .map((a) => ADAPTERS[a])
+        .filter((a) => a !== undefined);
+    if (adapters.length === 0) {
+        console.log('  No supported coding agents detected');
         return;
     }
-    let shouldInstall = autoYes;
+    const agentList = adapters.map((a) => a.name).join(', ');
+    const skillList = SKILLS.map((s) => `\n    • ${s.label}`).join('');
+    const shouldInstall = await confirm({
+        message: `Install Moda skills for ${agentList}?${skillList}\n  Continue?`,
+        default: true,
+    });
     if (!shouldInstall) {
-        shouldInstall = await confirm({
-            message: 'Install agent rules for coding assistants?',
-            default: true,
-        });
-    }
-    if (!shouldInstall)
+        console.log('  Skipped');
         return;
-    for (const agent of applicable) {
-        const filePath = join(process.cwd(), AGENT_RULES_FILES[agent]);
+    }
+    let wrote = 0;
+    let skipped = 0;
+    let failed = 0;
+    for (const skill of SKILLS) {
+        let content;
         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]}`);
+            content = loadSkillSource(skill.id);
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            console.error(`  Warning: Failed to write ${AGENT_RULES_FILES[agent]}: ${message}`);
+            console.error(`  Warning: ${message}`);
+            failed += adapters.length;
+            continue;
         }
+        for (const adapter of adapters) {
+            const outcome = installSkillForAgent(skill, adapter, content);
+            switch (outcome.status) {
+                case 'wrote':
+                    console.log(`  ${outcome.agent}: wrote ${outcome.relativePath}`);
+                    wrote++;
+                    break;
+                case 'exists':
+                    console.log(`  ${outcome.agent}: ${outcome.relativePath} already exists — skipping`);
+                    skipped++;
+                    break;
+                case 'failed':
+                    console.error(`  ${outcome.agent}: failed to write ${outcome.relativePath} — ${outcome.error}`);
+                    failed++;
+                    break;
+            }
+        }
+    }
+    const summary = [
+        wrote && `${wrote} written`,
+        skipped && `${skipped} already present`,
+        failed && `${failed} failed`,
+    ]
+        .filter(Boolean)
+        .join(', ');
+    if (summary) {
+        console.log(`  Done — ${summary}`);
     }
 }
 //# sourceMappingURL=rules.js.map

package/dist/init/tenant.js

@@ -1,7 +1,5 @@
 // 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
@@ -47,45 +45,9 @@ export async function selectTenantAndCreateKey() {
         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');
+    console.log('  API key created.\n');
+    console.log(`  Add this to your environment variables:\n`);
+    console.log(`    MODA_API_KEY=${result.apiKey}\n`);
     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

@@ -106,4 +106,63 @@ export declare const ToolFailureDetailSchema: z.ZodObject<{
     offset?: number | undefined;
     subtype?: string | undefined;
 }>;
+/** moda workflows — recurring workflow catalog (read from agent_job_classes). */
+export declare const WorkflowsSchema: z.ZodObject<{
+    time_range: z.ZodOptional<z.ZodDefault<z.ZodEnum<["all", "1h", "3d", "7d", "24h", "30d", "90d"]>>>;
+    user_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
+    user_id?: string | undefined;
+}, {
+    time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
+    user_id?: string | undefined;
+}>;
+/** moda runs — list workflow executions with classified outcomes. */
+export declare const RunsSchema: z.ZodObject<{
+    time_range: z.ZodOptional<z.ZodDefault<z.ZodEnum<["all", "1h", "3d", "7d", "24h", "30d", "90d"]>>>;
+    outcome: z.ZodOptional<z.ZodEnum<["running", "succeeded", "partial", "failed", "loop", "abandoned", "unknown"]>>;
+    /** Filter to one workflow class id (e.g. cron:helpscout-triage-hourly). */
+    class_id: z.ZodOptional<z.ZodString>;
+    user_id: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    user_id?: string | undefined;
+    outcome?: "running" | "succeeded" | "partial" | "failed" | "loop" | "abandoned" | "unknown" | undefined;
+    class_id?: string | undefined;
+}, {
+    time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    user_id?: string | undefined;
+    outcome?: "running" | "succeeded" | "partial" | "failed" | "loop" | "abandoned" | "unknown" | undefined;
+    class_id?: string | undefined;
+}>;
+/** moda run <runId> — single execution detail with side-effect receipts. */
+export declare const RunDetailSchema: z.ZodObject<{
+    run_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    run_id: string;
+}, {
+    run_id: string;
+}>;
+/** moda loops — currently active loop detections. */
+export declare const LoopsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+}, {
+    limit?: number | undefined;
+}>;
+/** moda loop <detectionId> — single loop detection detail. */
+export declare const LoopDetailSchema: z.ZodObject<{
+    detection_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    detection_id: string;
+}, {
+    detection_id: string;
+}>;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.js

@@ -45,4 +45,39 @@ export const ToolFailureDetailSchema = z.object({
     limit: z.number().min(1).max(20).default(5).optional(),
     offset: z.number().min(0).default(0).optional(),
 });
+// ─── Workflows + Runs (agent runs runtime) ──────────────────
+//
+// Naming model:
+//   workflow = the recurring class definition (e.g. cron:helpscout-triage-hourly)
+//   run      = one execution of a workflow
+// `moda workflows` lists the catalog; `moda runs` lists executions.
+const RUN_OUTCOMES = ['running', 'succeeded', 'partial', 'failed', 'loop', 'abandoned', 'unknown'];
+const TIME_RANGES = ['all', '1h', '3d', '7d', '24h', '30d', '90d'];
+/** moda workflows — recurring workflow catalog (read from agent_job_classes). */
+export const WorkflowsSchema = z.object({
+    time_range: z.enum(TIME_RANGES).default('all').optional(),
+    user_id: z.string().optional(),
+});
+/** moda runs — list workflow executions with classified outcomes. */
+export const RunsSchema = z.object({
+    time_range: z.enum(TIME_RANGES).default('7d').optional(),
+    outcome: z.enum(RUN_OUTCOMES).optional(),
+    /** Filter to one workflow class id (e.g. cron:helpscout-triage-hourly). */
+    class_id: z.string().optional(),
+    user_id: z.string().optional(),
+    limit: z.number().min(1).max(100).default(50).optional(),
+    offset: z.number().min(0).default(0).optional(),
+});
+/** moda run <runId> — single execution detail with side-effect receipts. */
+export const RunDetailSchema = z.object({
+    run_id: z.string().uuid({ message: 'run_id must be a UUID' }),
+});
+/** moda loops — currently active loop detections. */
+export const LoopsSchema = z.object({
+    limit: z.number().min(1).max(200).default(25).optional(),
+});
+/** moda loop <detectionId> — single loop detection detail. */
+export const LoopDetailSchema = z.object({
+    detection_id: z.string().uuid({ message: 'detection_id must be a UUID' }),
+});
 //# sourceMappingURL=schemas.js.map

package/package.json

@@ -1,21 +1,19 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.0.4",
-  "description": "CLI and MCP server for Moda - AI agent analytics and observability",
+  "version": "1.0.5",
+  "description": "CLI for Moda - AI agent analytics and observability",
   "type": "module",
-  "main": "dist/index.js",
   "bin": {
     "cli": "./dist/cli.js",
-    "moda": "./dist/cli.js",
-    "moda-mcp": "./dist/index.js"
+    "moda": "./dist/cli.js"
   },
   "files": [
     "dist/**/*.js",
     "dist/**/*.d.ts",
     "!dist/__tests__",
+    "skills/**/SKILL.md",
     "README.md",
-    ".env.example",
-    "mcp-config.example.json"
+    ".env.example"
   ],
   "publishConfig": {
     "access": "public"
@@ -24,13 +22,10 @@
     "build": "tsc",
     "prepublishOnly": "tsc",
     "dev": "tsc --watch",
-    "start": "node dist/index.js",
-    "start:http": "node dist/http-server.js",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:ci": "vitest run",
-    "test:watch": "vitest",
-    "test:e2e": "npm run build && vitest run e2e"
+    "test:watch": "vitest"
   },
   "repository": {
     "type": "git",
@@ -40,7 +35,6 @@
     "moda",
     "llm",
     "observability",
-    "mcp",
     "cli",
     "analytics",
     "ai-agents"
@@ -53,15 +47,10 @@
   },
   "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": {
-    "@types/cors": "^2.8.19",
-    "@types/express": "^5.0.6",
     "@types/node": "^22.10.5",
     "typescript": "^5.7.2",
     "vitest": "^3.0.0"

package/skills/integrate-moda/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: integrate-moda
+description: Integrate the Moda SDK into this project for LLM observability. Use when the user asks to add Moda, set up observability, or instrument LLM calls.
+---
+
+# Integrate Moda SDK
+
+Moda auto-instruments LLM calls (OpenAI, Anthropic) via OpenTelemetry.
+After `Moda.init()`, all LLM calls are captured automatically — no wrappers needed.
+
+## Steps
+
+1. Install the SDK: `npm install moda-ai` (or bun/yarn/pnpm equivalent)
+2. Ensure `MODA_API_KEY` is set in the environment
+3. Initialize once at app startup, before any LLM client is created:
+
+```typescript
+import { Moda } from 'moda-ai';
+await Moda.init(process.env.MODA_API_KEY!);
+```
+
+Python: `import moda; moda.init()`
+
+4. Set conversation ID before LLM calls to group multi-turn conversations.
+   Without this, each call appears as a separate conversation in the dashboard.
+
+```typescript
+Moda.conversationId = sessionId;
+Moda.userId = userId; // optional but recommended
+```
+
+For concurrent requests, use scoped context:
+```typescript
+import { withConversationId } from 'moda-ai';
+await withConversationId(sessionId, async () => {
+  await openai.chat.completions.create({ ... });
+});
+```
+
+Python: `moda.conversation_id = session_id` or `with moda.set_conversation_id(session_id):`
+
+5. Flush pending traces before process exit: `await Moda.flush();`
+
+## Vercel AI SDK
+
+When using the `ai` package, auto-instrumentation does not cover it. Pass telemetry config:
+```typescript
+const result = await generateText({
+  model: openai('gpt-4o'),
+  prompt: 'Hello',
+  experimental_telemetry: Moda.getVercelAITelemetry(),
+});
+```
+
+## Rules
+
+- Initialize Moda before creating any LLM client instances
+- Place `Moda.init()` in the app entry point, not in individual route handlers
+- Set `conversationId` per request/session, not globally
+- Use `withConversationId` in server environments handling concurrent requests
+- Call `Moda.flush()` in graceful shutdown handlers and before `process.exit()`
+- Do not wrap LLM calls — auto-instrumentation handles OpenAI and Anthropic automatically
+- Do not import or configure OpenTelemetry manually — Moda manages its own provider