@moda-ai/cli 1.1.1 → 1.2.0

package/dist/output.d.ts

@@ -0,0 +1,118 @@
+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";
+export type AgentStatus = 'ok' | 'error';
+export type AgentConfidence = 'high' | 'medium' | 'low' | 'unknown';
+export interface AgentSummary {
+    text: string;
+    confidence: AgentConfidence;
+}
+export interface AgentFinding {
+    id: string;
+    title: string;
+    status?: string;
+    severity?: string;
+    description?: string;
+    evidence_ref_ids?: string[];
+}
+export interface AgentEvidenceRef {
+    id: string;
+    kind: string;
+    label: string;
+    path?: string;
+    line?: number;
+    status?: string;
+}
+export interface AgentRecommendedAction {
+    id: string;
+    title: string;
+    rationale?: string;
+    command?: string;
+    mutability: 'read' | 'write' | 'sync' | 'unknown';
+    requires_approval: boolean;
+}
+export interface AgentNextCommand {
+    command: string;
+    purpose: string;
+    mutability: 'read' | 'write' | 'sync' | 'unknown';
+    requires_approval: boolean;
+}
+export interface AgentArtifact {
+    kind: string;
+    path: string;
+    description?: string;
+}
+export interface AgentError {
+    code: string;
+    message: string;
+    cause?: string;
+    suggested_commands?: string[];
+    blocking: boolean;
+}
+export interface AgentEnvelope {
+    schema_version: typeof AGENT_SCHEMA_VERSION;
+    command: string;
+    status: AgentStatus;
+    generated_at: string;
+    profile?: string;
+    summary: AgentSummary;
+    findings: AgentFinding[];
+    evidence_refs: AgentEvidenceRef[];
+    recommended_actions: AgentRecommendedAction[];
+    next_commands: AgentNextCommand[];
+    artifacts: AgentArtifact[];
+    warnings: string[];
+    errors: AgentError[];
+    data: unknown;
+    meta?: Record<string, unknown>;
+    truncation?: Record<string, unknown>;
+}
+export interface AgentEvent {
+    schema_version: typeof AGENT_EVENT_SCHEMA_VERSION;
+    event: 'started' | 'progress' | 'artifact' | 'approval_required' | 'completed' | 'error';
+    command: string;
+    generated_at: string;
+    status?: AgentStatus;
+    phase?: string;
+    message?: string;
+    elapsed_ms?: number;
+    artifact?: AgentArtifact;
+    result?: AgentEnvelope;
+    error?: AgentError;
+}
+export interface AgentWriteOptions {
+    summary?: string | Partial<AgentSummary>;
+    findings?: AgentFinding[];
+    evidenceRefs?: AgentEvidenceRef[];
+    recommendedActions?: AgentRecommendedAction[];
+    nextCommands?: Array<string | AgentNextCommand>;
+    artifacts?: AgentArtifact[];
+    warnings?: string[];
+    errors?: AgentError[];
+}
+export interface CliOutput {
+    mode: CliOutputMode;
+    quiet: boolean;
+    writeData(data: unknown, options?: {
+        status?: 'success' | 'error';
+        meta?: Record<string, unknown>;
+    } & AgentWriteOptions): void;
+    writeEvent(event: Omit<AgentEvent, 'schema_version' | 'command' | 'generated_at'>): void;
+}
+export declare function outputModeFromFlags(flags: Record<string, string>): CliOutputMode;
+export declare function createCliOutput(options: {
+    command: string;
+    mode: CliOutputMode;
+    quiet?: boolean;
+}): CliOutput;
+export declare function createAgentEnvelope(options: {
+    command: string;
+    status: AgentStatus;
+    data: unknown;
+    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 errorToAgentError(error: unknown): AgentError;
+//# sourceMappingURL=output.d.ts.map

package/dist/output.js

@@ -0,0 +1,228 @@
+export const AGENT_SCHEMA_VERSION = 'moda.agent.v1';
+export const AGENT_EVENT_SCHEMA_VERSION = 'moda.agent_event.v1';
+export function outputModeFromFlags(flags) {
+    if (flags.agent === 'true' && (flags.stream === 'true' || flags.format === 'ndjson'))
+        return 'agent-stream';
+    if (flags.agent === 'true')
+        return 'agent';
+    if (flags.json === 'true')
+        return 'json';
+    return 'human';
+}
+export function createCliOutput(options) {
+    return {
+        mode: options.mode,
+        quiet: options.quiet === true,
+        writeData(data, writeOptions = {}) {
+            if (options.quiet)
+                return;
+            if (options.mode === 'agent' || options.mode === 'agent-stream') {
+                const envelope = createAgentEnvelope({
+                    command: options.command,
+                    status: writeOptions.status === 'error' ? 'error' : 'ok',
+                    data,
+                    meta: writeOptions.meta,
+                    summary: writeOptions.summary,
+                    findings: writeOptions.findings,
+                    evidenceRefs: writeOptions.evidenceRefs,
+                    recommendedActions: writeOptions.recommendedActions,
+                    nextCommands: writeOptions.nextCommands,
+                    artifacts: writeOptions.artifacts,
+                    warnings: writeOptions.warnings,
+                    errors: writeOptions.errors,
+                });
+                if (options.mode === 'agent-stream') {
+                    console.log(JSON.stringify(createAgentEvent(options.command, {
+                        event: envelope.status === 'error' ? 'error' : 'completed',
+                        status: envelope.status,
+                        result: envelope,
+                    })));
+                }
+                else {
+                    console.log(JSON.stringify(envelope));
+                }
+                return;
+            }
+            console.log(JSON.stringify(data, null, 2));
+        },
+        writeEvent(event) {
+            if (options.quiet)
+                return;
+            if (options.mode !== 'agent-stream')
+                return;
+            console.log(JSON.stringify(createAgentEvent(options.command, event)));
+        },
+    };
+}
+export function createAgentEnvelope(options) {
+    const bounded = boundForAgent(options.data);
+    return {
+        schema_version: AGENT_SCHEMA_VERSION,
+        command: options.command,
+        status: options.status,
+        generated_at: new Date().toISOString(),
+        ...(options.profile ? { profile: options.profile } : {}),
+        summary: normalizeSummary(options.summary, options.command, options.status, options.data),
+        findings: options.findings ?? [],
+        evidence_refs: options.evidenceRefs ?? [],
+        recommended_actions: options.recommendedActions ?? [],
+        next_commands: normalizeNextCommands(options.nextCommands ?? []),
+        artifacts: options.artifacts ?? [],
+        warnings: options.warnings ?? inferWarnings(options.data),
+        errors: options.errors ?? [],
+        data: bounded.data,
+        ...(options.meta ? { meta: options.meta } : {}),
+        ...(bounded.truncation ? { truncation: bounded.truncation } : {}),
+    };
+}
+export function createAgentErrorEnvelope(command, error) {
+    return createAgentEnvelope({
+        command,
+        status: 'error',
+        data: null,
+        summary: {
+            text: error.message,
+            confidence: 'high',
+        },
+        errors: [error],
+        nextCommands: (error.suggested_commands ?? []).map((commandText) => ({
+            command: commandText,
+            purpose: 'Suggested recovery command.',
+            mutability: commandText.includes(' sync') || commandText.startsWith('moda sync') ? 'sync' : 'read',
+            requires_approval: commandText.includes(' --yes') || commandText.includes(' sync'),
+        })),
+    });
+}
+export function createAgentEvent(command, event) {
+    return {
+        schema_version: AGENT_EVENT_SCHEMA_VERSION,
+        command,
+        generated_at: new Date().toISOString(),
+        ...event,
+    };
+}
+export function errorToAgentError(error) {
+    if (error instanceof Error) {
+        return {
+            code: error.name === 'CliInputError' ? 'input_error' : 'command_error',
+            message: error.message,
+            cause: 'usage' in error && typeof error.usage === 'string' ? error.usage : undefined,
+            suggested_commands: 'usage' in error && typeof error.usage === 'string'
+                ? extractSuggestedCommands(error.usage)
+                : undefined,
+            blocking: true,
+        };
+    }
+    return {
+        code: 'unknown_error',
+        message: String(error),
+        blocking: true,
+    };
+}
+function normalizeSummary(summary, command, status, data) {
+    if (typeof summary === 'string') {
+        return { text: summary, confidence: 'high' };
+    }
+    if (summary?.text) {
+        return {
+            text: summary.text,
+            confidence: summary.confidence ?? 'high',
+        };
+    }
+    return inferSummary(command, status, data);
+}
+function inferSummary(command, status, data) {
+    const record = asRecord(data);
+    if (status === 'error') {
+        return { text: `${command} failed.`, confidence: 'high' };
+    }
+    const summary = asRecord(record?.summary);
+    if (summary) {
+        const statusValue = typeof summary.status === 'string' ? summary.status : undefined;
+        const fail = typeof summary.fail === 'number' ? summary.fail : undefined;
+        const warning = typeof summary.warning === 'number' ? summary.warning : undefined;
+        if (statusValue && fail !== undefined && warning !== undefined) {
+            return {
+                text: `${command} completed with status ${statusValue}: ${fail} failing checks and ${warning} warnings.`,
+                confidence: 'high',
+            };
+        }
+        const runtimeAgentCount = typeof summary.runtimeAgentCount === 'number'
+            ? summary.runtimeAgentCount
+            : undefined;
+        if (runtimeAgentCount !== undefined) {
+            return {
+                text: `${command} completed. Harness summary includes ${runtimeAgentCount} runtime agent(s).`,
+                confidence: 'high',
+            };
+        }
+    }
+    if (typeof record?.status === 'string') {
+        return { text: `${command} completed with status ${record.status}.`, confidence: 'high' };
+    }
+    return { text: `${command} completed.`, confidence: 'medium' };
+}
+function normalizeNextCommands(commands) {
+    return commands.map((command) => {
+        if (typeof command !== 'string')
+            return command;
+        return {
+            command,
+            purpose: 'Suggested next Moda command.',
+            mutability: inferMutability(command),
+            requires_approval: command.includes(' --yes') || command.includes(' sync'),
+        };
+    });
+}
+function inferMutability(command) {
+    if (/\b(sync|approve|init|install|pull|gen|remove|promote)\b/.test(command)) {
+        if (/\bsync\b/.test(command))
+            return 'sync';
+        return 'write';
+    }
+    return 'read';
+}
+function inferWarnings(data) {
+    const record = asRecord(data);
+    const direct = record?.warnings;
+    if (Array.isArray(direct))
+        return direct.filter((item) => typeof item === 'string');
+    const validation = asRecord(record?.validation);
+    if (Array.isArray(validation?.warnings)) {
+        return validation.warnings.filter((item) => typeof item === 'string');
+    }
+    return [];
+}
+function boundForAgent(data) {
+    const maxBytes = Number(process.env.MODA_AGENT_MAX_OUTPUT_BYTES ?? 200_000);
+    const serialized = JSON.stringify(data);
+    const bytes = Buffer.byteLength(serialized, 'utf8');
+    if (bytes <= maxBytes)
+        return { data };
+    const preview = serialized.slice(0, Math.max(0, maxBytes - 256));
+    return {
+        data: {
+            truncated: true,
+            original_bytes: bytes,
+            max_bytes: maxBytes,
+            preview,
+        },
+        truncation: {
+            data: {
+                original_bytes: bytes,
+                max_bytes: maxBytes,
+                reason: 'agent_output_byte_limit',
+            },
+        },
+    };
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function extractSuggestedCommands(text) {
+    const commands = [...text.matchAll(/`(moda [^`]+)`/g)].map((match) => match[1]);
+    return commands.length > 0 ? commands : undefined;
+}
+//# sourceMappingURL=output.js.map

package/dist/production-intelligence.d.ts

@@ -0,0 +1,134 @@
+import type { CommandContext } from './command-context.js';
+import type { AgentConfidence } from './output.js';
+declare const INVESTIGATION_SCHEMA_VERSION = "production_investigation.v0.1";
+declare const OVERVIEW_SCHEMA_VERSION = "production_overview.v0.1";
+declare const ASK_SCHEMA_VERSION = "production_ask.v0.1";
+type Severity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+type FindingKind = 'tool_failure' | 'loop' | 'frustration' | 'partial_run' | 'prompt_regression' | 'skill_gap' | 'insufficient_data';
+export interface ProductionEvidenceRef {
+    id: string;
+    kind: 'data_api' | 'tool_failure' | 'frustration' | 'loop' | 'run' | 'harness' | 'ask';
+    label: string;
+    endpoint?: string;
+    conversationId?: string;
+    runId?: string;
+    detectionId?: string;
+    toolName?: string;
+    path?: string;
+    line?: number;
+    value?: unknown;
+}
+export interface LikelyLocation {
+    kind: 'tool' | 'prompt' | 'skill' | 'entrypoint' | 'harness' | 'unknown';
+    path?: string;
+    label: string;
+    confidence: AgentConfidence;
+    reason: string;
+}
+export interface ProductionAction {
+    id: string;
+    title: string;
+    rationale: string;
+    command: string;
+    mutability: 'read' | 'write' | 'sync' | 'unknown';
+    requiresApproval: boolean;
+}
+export interface ProductionFinding {
+    id: string;
+    kind: FindingKind;
+    title: string;
+    severity: Severity;
+    confidence: AgentConfidence;
+    impactScore: number;
+    rankReason: string;
+    summary: string;
+    evidenceRefIds: string[];
+    likelyLocations: LikelyLocation[];
+    recommendedActions: ProductionAction[];
+}
+export interface ProductionInvestigation {
+    schemaVersion: typeof INVESTIGATION_SCHEMA_VERSION;
+    generatedAt: string;
+    daysBack: number;
+    scope: {
+        runId?: string;
+        conversationId?: string;
+        toolName?: string;
+        loopId?: string;
+        question?: string;
+    };
+    summary: {
+        text: string;
+        confidence: AgentConfidence;
+    };
+    findings: ProductionFinding[];
+    evidenceRefs: ProductionEvidenceRef[];
+    nextCommands: string[];
+    warnings: string[];
+    sourceStatus: Record<string, 'ok' | 'unavailable'>;
+}
+export interface ProductionOverviewBriefing {
+    schemaVersion: typeof OVERVIEW_SCHEMA_VERSION;
+    generatedAt: string;
+    daysBack: number;
+    status: 'healthy' | 'attention' | 'quiet' | 'unknown';
+    dataFlow: {
+        status: 'flowing' | 'quiet' | 'unknown';
+        conversations: number;
+        lastEvent?: {
+            summary: string;
+            timestamp?: string;
+            conversationId?: string;
+        };
+    };
+    harnessSync: SyncBrief;
+    promptSync: SyncBrief;
+    skillSync: SyncBrief;
+    metrics: Record<string, unknown>;
+    topFinding: ProductionFinding | null;
+    evidenceRefs: ProductionEvidenceRef[];
+    nextCommand: string;
+    rawOverview: unknown;
+}
+interface SyncBrief {
+    status: 'synced' | 'present' | 'missing' | 'unknown';
+    summary: string;
+    path?: string;
+}
+export interface ProductionAskResult {
+    schemaVersion: typeof ASK_SCHEMA_VERSION;
+    generatedAt: string;
+    source: 'cloud' | 'local_fallback';
+    question: string;
+    answer: string;
+    confidence: AgentConfidence;
+    evidenceRefs: ProductionEvidenceRef[];
+    findings: ProductionFinding[];
+    nextCommands: string[];
+    warnings: string[];
+}
+export declare function runProductionCommand(context: CommandContext): Promise<{
+    exitCode: number;
+}>;
+export declare function loadOverviewBriefing(options: {
+    daysBack: number;
+    cwd: string;
+}): Promise<ProductionOverviewBriefing>;
+export declare function investigateProduction(options: {
+    daysBack: number;
+    cwd: string;
+    runId?: string;
+    conversationId?: string;
+    toolName?: string;
+    loopId?: string;
+    question?: string;
+    failureOnly?: boolean;
+}): Promise<ProductionInvestigation>;
+export declare function askModa(options: {
+    question: string;
+    daysBack: number;
+    cwd: string;
+    profile?: string;
+}): Promise<ProductionAskResult>;
+export {};
+//# sourceMappingURL=production-intelligence.d.ts.map