@moda-ai/cli 1.10.2 → 1.12.0

package/dist/init/skill-resolver.js

@@ -0,0 +1,78 @@
+// src/init/skill-resolver.ts — deterministic resolution from detected project
+// context to a bundled integration-skill id.
+//
+// Pure function, zero LLM involvement. The table is ordered; the first
+// matching row wins. Wrapper frameworks beat raw providers: if the Vercel AI
+// SDK or LangChain is present, the wrapper layer gets instrumented, never the
+// underlying openai/anthropic client.
+/** The §2.3 resolution table, encoded as data. Order matters. */
+export const RESOLUTION_TABLE = [
+    { language: 'node', framework: 'vercel-ai-sdk', skillId: 'integration-node-vercel-ai-sdk' },
+    { language: 'node', framework: 'langchain', skillId: 'integration-node-langchain' },
+    { language: 'python', framework: 'langchain', skillId: 'integration-python-langchain' },
+    { language: 'python', framework: 'claude-agent-sdk', skillId: 'integration-python-claude-agent-sdk' },
+    { language: 'node', provider: 'openai', skillId: 'integration-node-openai' },
+    { language: 'node', provider: 'anthropic', skillId: 'integration-node-anthropic' },
+    { language: 'python', provider: 'openai', skillId: 'integration-python-openai' },
+    { language: 'python', provider: 'anthropic', skillId: 'integration-python-anthropic' },
+    { language: 'node', skillId: 'integration-node-generic' },
+    { language: 'python', skillId: 'integration-python-generic' },
+];
+/**
+ * Resolve the detected context to a bundled skill id, or null when no
+ * language was detected (callers fall back to the slim generic guide).
+ */
+export function resolveIntegrationSkillId(context) {
+    const languages = normalizeLanguages(context.languages);
+    const frameworks = normalizeFrameworks(context.frameworkHints);
+    const providers = normalizeProviders(context.providerHints);
+    for (const row of RESOLUTION_TABLE) {
+        if (!languages.has(row.language))
+            continue;
+        if (row.framework && !frameworks.has(row.framework))
+            continue;
+        if (row.provider && !providers.has(row.provider))
+            continue;
+        return row.skillId;
+    }
+    return null;
+}
+function normalizeLanguages(languages) {
+    const result = new Set();
+    for (const language of languages) {
+        const lower = language.toLowerCase();
+        if (lower.includes('node') || lower.includes('typescript') || lower.includes('javascript')) {
+            result.add('node');
+        }
+        if (lower.includes('python'))
+            result.add('python');
+    }
+    return result;
+}
+function normalizeFrameworks(frameworkHints) {
+    const result = new Set();
+    for (const hint of frameworkHints) {
+        const lower = hint.toLowerCase();
+        if (lower.includes('vercel ai sdk') || lower.includes('vercel-ai-sdk') || lower.includes('ai sdk')) {
+            result.add('vercel-ai-sdk');
+        }
+        if (lower.includes('langchain') || lower.includes('langgraph'))
+            result.add('langchain');
+        if (lower.includes('claude agent sdk') || lower.includes('claude-agent-sdk')) {
+            result.add('claude-agent-sdk');
+        }
+    }
+    return result;
+}
+function normalizeProviders(providerHints) {
+    const result = new Set();
+    for (const hint of providerHints) {
+        const lower = hint.toLowerCase();
+        if (lower.includes('openai'))
+            result.add('openai');
+        if (lower.includes('anthropic'))
+            result.add('anthropic');
+    }
+    return result;
+}
+//# sourceMappingURL=skill-resolver.js.map

package/dist/init/tenant.d.ts

@@ -4,6 +4,11 @@ interface BootstrapResult {
     tenantName: string;
     tenantSlug: string;
 }
-export declare function selectTenantAndCreateKey(): Promise<BootstrapResult>;
+export declare function selectTenantAndCreateKey(options?: {
+    tenantId?: string;
+    nonInteractive?: boolean;
+    silent?: boolean;
+    resumeCommand?: string[];
+}): Promise<BootstrapResult>;
 export {};
 //# sourceMappingURL=tenant.d.ts.map

package/dist/init/tenant.js

@@ -2,7 +2,8 @@
 import { select } from '@inquirer/prompts';
 import { authFetch } from '../auth.js';
 import { resolveIngestUrl, saveCliConfig } from '../config.js';
-export async function selectTenantAndCreateKey() {
+import { CliInputError, CliInputRequiredError } from '../errors.js';
+export async function selectTenantAndCreateKey(options = {}) {
     // 1. Fetch CLI context
     const contextRes = await authFetch('/api/cli/context');
     if (!contextRes.ok) {
@@ -10,16 +11,39 @@ export async function selectTenantAndCreateKey() {
         throw new Error(`Failed to fetch context (${contextRes.status}): ${body}`);
     }
     const ctx = (await contextRes.json());
-    console.log(`  Authenticated as ${ctx.user.email}`);
+    if (!options.silent)
+        console.log(`  Authenticated as ${ctx.user.email}`);
     // 2. Select tenant
     if (ctx.tenants.length === 0) {
-        console.error('  No organizations found. Create one at https://moda.dev');
-        process.exit(1);
+        throw new CliInputError('No organizations found. Create one at https://moda.dev', 'Create an organization in Moda, then rerun `moda init`.');
     }
     let tenantId;
-    if (ctx.tenants.length === 1) {
+    if (options.tenantId) {
+        const selected = ctx.tenants.find((tenant) => tenant.id === options.tenantId);
+        if (!selected) {
+            throw new CliInputError(`Tenant '${options.tenantId}' is not available for the authenticated user.`, 'Run `moda init` without --tenant-id in a human terminal, or choose a tenant from the needs_input event.');
+        }
+        tenantId = selected.id;
+        if (!options.silent)
+            console.log(`  Organization: ${selected.name}`);
+    }
+    else if (ctx.tenants.length === 1) {
         tenantId = ctx.tenants[0].id;
-        console.log(`  Organization: ${ctx.tenants[0].name}`);
+        if (!options.silent)
+            console.log(`  Organization: ${ctx.tenants[0].name}`);
+    }
+    else if (options.nonInteractive) {
+        throw new CliInputRequiredError('Multiple Moda organizations are available; choose one and re-run with --tenant-id.', {
+            id: 'init_tenant_selection',
+            question: 'Select organization',
+            kind: 'select',
+            choices: ctx.tenants.map((tenant) => ({
+                value: tenant.id,
+                label: `${tenant.name} (${tenant.role})`,
+                resume_flags: ['--tenant-id', tenant.id],
+            })),
+            resume_command: options.resumeCommand,
+        }, 'Re-run `moda init --tenant-id <tenant_id>`.');
     }
     else {
         tenantId = await select({
@@ -37,9 +61,7 @@ export async function selectTenantAndCreateKey() {
         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);
+        throw new CliInputError('You need admin or owner access to create API keys.', 'Ask your organization owner to upgrade your role.');
     }
     if (!bootstrapRes.ok) {
         const body = await bootstrapRes.text();
@@ -55,8 +77,10 @@ export async function selectTenantAndCreateKey() {
         tenant_id: result.tenantId,
         ingest_url: resolveIngestUrl(),
     });
-    console.log('  API key + tenant saved to ~/.moda/config.json\n');
-    console.log('  (Set MODA_API_KEY / MODA_TENANT_ID to override for scripts/CI.)\n');
+    if (!options.silent) {
+        console.log('  API key + tenant saved to ~/.moda/config.json\n');
+        console.log('  (Set MODA_API_KEY / MODA_TENANT_ID to override for scripts/CI.)\n');
+    }
     return result;
 }
 //# sourceMappingURL=tenant.js.map

package/dist/manifest.d.ts

@@ -0,0 +1,5 @@
+import type { CommandMetadata } from './command-registry.js';
+export declare const MANIFEST_SCHEMA_VERSION = "moda.manifest.v1";
+export declare function buildManifest(commands: CommandMetadata[]): Record<string, unknown>;
+export declare function renderManifestHuman(manifest: Record<string, unknown>): string;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.js

@@ -0,0 +1,111 @@
+import { VERSION } from './config.js';
+export const MANIFEST_SCHEMA_VERSION = 'moda.manifest.v1';
+export function buildManifest(commands) {
+    return {
+        schema_version: MANIFEST_SCHEMA_VERSION,
+        cli_version: VERSION,
+        invocations: [
+            'bunx @moda-ai/cli',
+            'npx -y @moda-ai/cli',
+            'moda',
+        ],
+        global_flags: [
+            '--agent',
+            '--stream',
+            '--json',
+            '--human',
+            '--profile <name>',
+            '--quiet',
+            '--no-telemetry',
+            '--no-update-check',
+            '--json-schemas',
+        ],
+        env: [
+            'MODA_FORMAT',
+            'MODA_AGENT',
+            'MODA_API_KEY',
+            'MODA_TENANT_ID',
+            'MODA_PROFILE',
+            'MODA_BASE_URL',
+            'MODA_HEARTBEAT_MS',
+            'MODA_AGENT_MAX_OUTPUT_BYTES',
+            'MODA_CLI_TELEMETRY',
+            'MODA_CLI_UPDATE_CHECK',
+        ],
+        exit_codes: [
+            { code: 0, name: 'ok', meaning: 'Command completed successfully.' },
+            { code: 1, name: 'error', meaning: 'Command, input, API, network, or unexpected failure.' },
+            { code: 3, name: 'degraded', meaning: 'Reserved for `moda ask` local fallback.' },
+            { code: 4, name: 'auth_required', meaning: 'Run login_command, then resume.' },
+            { code: 5, name: 'input_required', meaning: 'Choose from input_request choices, then resume.' },
+            { code: 130, name: 'cancelled', meaning: 'Interrupted or output consumer closed.' },
+        ],
+        events: [
+            event('started', 'First event for every agent stream.', false),
+            event('progress', 'Progress update while work continues.', false),
+            event('warning', 'Non-fatal warning or skipped action.', false),
+            event('artifact', 'File or artifact produced by a command.', false),
+            event('heartbeat', 'Idle liveness event emitted after MODA_HEARTBEAT_MS without output.', false),
+            event('needs_input', 'Terminal event requesting exit-and-reinvoke input.', true),
+            event('auth_required', 'Terminal event requesting authentication before retry.', true),
+            event('completed', 'Terminal success event.', true),
+            event('error', 'Terminal failure event.', true),
+            event('cancelled', 'Terminal cancellation event.', true),
+            event('approval_required', 'Deprecated; use needs_input.', true, true),
+        ],
+        schemas: [
+            'moda.agent.v1',
+            'moda.agent_event.v1',
+            'moda.intelligence.v1',
+            'production_ask.v0.1',
+        ],
+        commands: commands.map((command) => ({
+            name: command.name,
+            aliases: command.aliases ?? [],
+            summary: command.description,
+            output_modes: command.outputModes,
+            streaming: command.outputModes.includes('agent-stream') || command.outputModes.includes('agent'),
+            examples: command.examples,
+            auth: command.auth,
+            mutability: command.mutability,
+            exit_codes: exitCodesForCommand(command.name),
+        })),
+        concepts: [
+            { term: 'tenant', meaning: 'A Moda organization/workspace that owns data, prompts, skills, and API keys.' },
+            { term: 'profile', meaning: 'A named local CLI configuration under ~/.moda that selects environment, tenant, and secret references.' },
+            { term: 'harness', meaning: 'Moda’s local graph of runtime agents, prompts, tools, identities, and deployments in a codebase.' },
+            { term: 'harness report', meaning: 'A cited analyst artifact under .moda/ that justifies the harness graph before sync.' },
+            { term: 'conversation', meaning: 'A user-agent interaction thread stored in Moda analytics.' },
+            { term: 'trace', meaning: 'Raw OTLP span evidence for one run or conversation, exposed by `moda audit`.' },
+            { term: 'ingest key', meaning: 'A `moda_sk_` API key for SDKs, CI, and Data API calls. Treat it as a secret.' },
+            { term: 'CLI session token', meaning: 'A local browser-auth session token used by CLI auth/bootstrap flows, not by application SDKs.' },
+            { term: 'prompt', meaning: 'A code-first prompt file tracked by `.moda/prompts.yml` and synced to Moda.' },
+            { term: 'skill', meaning: 'A SKILL.md agent instruction file generated by or synced to Moda.' },
+        ],
+    };
+}
+export function renderManifestHuman(manifest) {
+    const commands = Array.isArray(manifest.commands) ? manifest.commands : [];
+    return [
+        `Moda CLI manifest ${manifest.cli_version ?? ''}`,
+        '',
+        'Commands:',
+        ...commands.map((command) => {
+            const row = command;
+            return `  ${row.name ?? 'unknown'} - ${row.summary ?? ''}`;
+        }),
+        '',
+        'Run `moda manifest --json` for the full machine-readable contract.',
+    ].join('\n');
+}
+function event(name, when, terminal, deprecated = false) {
+    return { name, event_version: 1, when, terminal, ...(deprecated ? { deprecated: true } : {}) };
+}
+function exitCodesForCommand(command) {
+    if (command === 'ask')
+        return [0, 1, 3, 4, 5, 130];
+    if (command === 'init' || command === 'harness')
+        return [0, 1, 4, 5, 130];
+    return [0, 1, 4, 130];
+}
+//# sourceMappingURL=manifest.js.map

package/dist/output.d.ts

@@ -1,3 +1,4 @@
+import { type AgentAuthRequest, type AgentInputRequest } from './errors.js';
 export type CliOutputMode = 'human' | 'json' | 'agent' | 'agent-stream';
 export declare const AGENT_SCHEMA_VERSION = "moda.agent.v1";
 export declare const AGENT_EVENT_SCHEMA_VERSION = "moda.agent_event.v1";
@@ -6,12 +7,20 @@ export declare const AGENT_EVENT_SCHEMA_VERSION = "moda.agent_event.v1";
  *   0  ok        — grounded answer from Moda Cloud intelligence.
  *   3  degraded  — answer produced from a local/degraded fallback (lower trust).
  *   1  error     — command/input/unexpected failure (see envelope `errors[]`).
+ *   4  auth      — login or token renewal required before retrying.
+ *   5  input     — non-interactive caller must choose and re-invoke.
+ *   130 cancel   — interrupted or the output consumer closed the pipe.
  * `EXIT_DEGRADED` is intentionally distinct so a caller can tell a degraded
  * answer apart from both success and hard failure without parsing the payload.
  */
 export declare const EXIT_OK = 0;
 export declare const EXIT_ERROR = 1;
 export declare const EXIT_DEGRADED = 3;
+export declare const EXIT_AUTH_REQUIRED = 4;
+export declare const EXIT_INPUT_REQUIRED = 5;
+export declare const EXIT_CANCELLED = 130;
+export declare const AGENT_ERROR_CODES: readonly ["input_error", "api_error", "network_error", "auth_required", "input_required", "cancelled", "command_error", "unknown_error", "cloud_unavailable"];
+export type AgentErrorCode = typeof AGENT_ERROR_CODES[number];
 export type AgentStatus = 'ok' | 'degraded' | 'error';
 export type AgentConfidence = 'high' | 'medium' | 'low' | 'unknown';
 export interface AgentSummary {
@@ -54,10 +63,12 @@ export interface AgentArtifact {
     description?: string;
 }
 export interface AgentError {
-    code: string;
+    code: AgentErrorCode | string;
     message: string;
     cause?: string;
     suggested_commands?: string[];
+    input_request?: AgentInputRequest;
+    auth?: AgentAuthRequest;
     blocking: boolean;
 }
 export interface AgentEnvelope {
@@ -80,9 +91,12 @@ export interface AgentEnvelope {
 }
 export interface AgentEvent {
     schema_version: typeof AGENT_EVENT_SCHEMA_VERSION;
-    event: 'started' | 'progress' | 'artifact' | 'approval_required' | 'completed' | 'error';
+    event: 'started' | 'progress' | 'artifact' | 'approval_required' | 'completed' | 'error' | 'heartbeat' | 'needs_input' | 'auth_required' | 'cancelled' | 'warning';
     command: string;
     generated_at: string;
+    run_id?: string;
+    seq?: number;
+    event_version?: number;
     status?: AgentStatus;
     phase?: string;
     message?: string;
@@ -90,6 +104,8 @@ export interface AgentEvent {
     artifact?: AgentArtifact;
     result?: AgentEnvelope;
     error?: AgentError;
+    input_request?: AgentInputRequest;
+    auth?: AgentAuthRequest;
 }
 export interface AgentWriteOptions {
     summary?: string | Partial<AgentSummary>;
@@ -109,7 +125,29 @@ export interface CliOutput {
         meta?: Record<string, unknown>;
     } & AgentWriteOptions): void;
     writeEvent(event: Omit<AgentEvent, 'schema_version' | 'command' | 'generated_at'>): void;
+    writeError(error: unknown): void;
+    writeCancelled(reason?: string): void;
+    hasTerminalOutput(): boolean;
+    close(): void;
 }
+interface OutputRunState {
+    runId: string;
+    seq: number;
+    started: boolean;
+    terminal: boolean;
+    startedAt: number;
+    lastEventAt: number;
+    heartbeat?: NodeJS.Timeout;
+}
+/**
+ * True once an EPIPE from a closed stdout/stderr consumer has been observed.
+ * The stream error listeners above own this state; expose it so callers can
+ * detect consumer-cancelled runs explicitly instead of sniffing the global
+ * `process.exitCode`.
+ */
+export declare function wasOutputCancelled(): boolean;
+export declare function safeWriteStdout(text: string): boolean;
+export declare function safeWriteStderr(text: string): boolean;
 /** Flag-only resolution (default human). Kept for callers that only have flags. */
 export declare function outputModeFromFlags(flags: Record<string, string>): CliOutputMode;
 /**
@@ -127,6 +165,7 @@ export declare function createCliOutput(options: {
     command: string;
     mode: CliOutputMode;
     quiet?: boolean;
+    runId?: string;
 }): CliOutput;
 export declare function createAgentEnvelope(options: {
     command: string;
@@ -135,7 +174,8 @@ export declare function createAgentEnvelope(options: {
     profile?: string;
     meta?: Record<string, unknown>;
 } & AgentWriteOptions): AgentEnvelope;
-export declare function createAgentErrorEnvelope(command: string, error: AgentError): AgentEnvelope;
-export declare function createAgentEvent(command: string, event: Omit<AgentEvent, 'schema_version' | 'command' | 'generated_at'>): AgentEvent;
+export declare function createAgentErrorEnvelope(command: string, error: AgentError, runId?: string): AgentEnvelope;
+export declare function createAgentEvent(command: string, event: Omit<AgentEvent, 'schema_version' | 'command' | 'generated_at' | 'run_id' | 'seq'>, state?: OutputRunState): AgentEvent;
 export declare function errorToAgentError(error: unknown): AgentError;
+export {};
 //# sourceMappingURL=output.d.ts.map