@moda-ai/cli 1.1.1 → 1.2.0

package/dist/analyst-tui.js

@@ -0,0 +1,314 @@
+export class AnalystTui {
+    state;
+    active = false;
+    closed = false;
+    lastRenderAt = 0;
+    spinnerIndex = 0;
+    constructor(options) {
+        const startedAt = options.startedAt ?? Date.now();
+        this.state = {
+            adapterName: options.adapterName,
+            command: options.command,
+            root: options.root,
+            reportPath: options.reportPath,
+            startedAt,
+            phase: 'launching analyst',
+            sawOutput: false,
+            lastOutputAt: startedAt,
+            eventCount: 0,
+            rateLimitCount: 0,
+            validation: 'pending',
+            artifacts: [],
+            summary: {},
+            timeline: [],
+            toolCounts: new Map(),
+            completed: false,
+        };
+    }
+    start() {
+        if (this.active || this.closed)
+            return;
+        this.active = true;
+        process.stderr.write('\u001b[?1049h\u001b[?25l');
+        this.pushTimeline('Moda', 'Launching read-only analyst.');
+        this.render(true);
+    }
+    recordEvent(event) {
+        if (this.closed)
+            return;
+        this.state.sawOutput = true;
+        this.state.lastOutputAt = Date.now();
+        this.state.eventCount += 1;
+        if (event.kind === 'rate_limit') {
+            this.state.rateLimitCount += 1;
+            this.state.phase = 'rate limit wait';
+        }
+        else if (event.kind === 'tool') {
+            this.state.phase = `using ${event.toolName ?? 'tool'}`;
+            if (event.toolName) {
+                this.state.toolCounts.set(event.toolName, (this.state.toolCounts.get(event.toolName) ?? 0) + 1);
+            }
+        }
+        else if (event.kind === 'command') {
+            this.state.phase = 'running command';
+        }
+        else if (event.kind === 'agent_text') {
+            this.state.phase = inferPhase(event.message);
+        }
+        const label = event.kind === 'rate_limit'
+            ? 'Rate limit'
+            : event.kind === 'tool'
+                ? event.toolName ?? 'Tool'
+                : event.kind === 'command'
+                    ? 'Command'
+                    : this.state.adapterName;
+        this.pushTimeline(label, event.message);
+        this.render();
+    }
+    heartbeat(options) {
+        if (this.closed)
+            return;
+        this.state.sawOutput = options.sawOutput;
+        this.render();
+    }
+    setValidation(status) {
+        if (this.closed)
+            return;
+        this.state.validation = status;
+        this.state.phase = status === 'running'
+            ? 'validating cited report'
+            : status === 'pass'
+                ? 'validation passed'
+                : status === 'fail'
+                    ? 'validation failed'
+                    : this.state.phase;
+        this.pushTimeline('Moda', `Validation ${status}.`);
+        this.render(true);
+    }
+    setSummary(summary) {
+        if (this.closed)
+            return;
+        this.state.summary = { ...this.state.summary, ...summary };
+        this.render(true);
+    }
+    setArtifacts(artifacts) {
+        if (this.closed)
+            return;
+        this.state.artifacts = artifacts;
+        if (artifacts.length > 0)
+            this.pushTimeline('Moda', `Wrote ${artifacts.length} local artifact${artifacts.length === 1 ? '' : 's'}.`);
+        this.render(true);
+    }
+    complete(status) {
+        if (this.closed)
+            return;
+        this.state.completed = true;
+        this.setValidation(status);
+    }
+    stop() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.active) {
+            this.render(true);
+            process.stderr.write('\u001b[?25h\u001b[?1049l');
+        }
+        this.active = false;
+    }
+    pushTimeline(label, message) {
+        const compact = compactWhitespace(message);
+        if (!compact)
+            return;
+        const last = this.state.timeline.at(-1);
+        if (last?.label === label && last.message === compact)
+            return;
+        this.state.timeline.push({
+            time: timeOfDay(new Date()),
+            label,
+            message: compact,
+        });
+        if (this.state.timeline.length > 80)
+            this.state.timeline.splice(0, this.state.timeline.length - 80);
+    }
+    render(force = false) {
+        if (!this.active)
+            return;
+        const now = Date.now();
+        if (!force && now - this.lastRenderAt < 120)
+            return;
+        this.lastRenderAt = now;
+        const frame = renderAnalystTuiFrame(this.state, {
+            color: process.env.NO_COLOR !== '1',
+            columns: process.stderr.columns,
+            rows: process.stderr.rows,
+            now,
+            spinnerFrame: spinner(this.spinnerIndex++),
+        });
+        process.stderr.write(`\u001b[H\u001b[2J${frame}`);
+    }
+}
+export function renderAnalystTuiFrame(state, options = {}) {
+    const color = options.color ?? false;
+    const width = Math.max(72, Math.min(options.columns ?? 96, 128));
+    const rows = Math.max(22, Math.min(options.rows ?? 32, 48));
+    const now = options.now ?? Date.now();
+    const paint = (code, text) => color ? `\u001b[${code}m${text}\u001b[0m` : text;
+    const dim = (text) => paint(90, text);
+    const cyan = (text) => paint(36, text);
+    const green = (text) => paint(32, text);
+    const yellow = (text) => paint(33, text);
+    const red = (text) => paint(31, text);
+    const bold = (text) => paint(1, text);
+    const elapsedSeconds = Math.max(0, Math.round((now - state.startedAt) / 1000));
+    const quietForSeconds = Math.max(0, Math.round((now - state.lastOutputAt) / 1000));
+    const validation = state.validation === 'pass'
+        ? green('pass')
+        : state.validation === 'fail'
+            ? red('fail')
+            : state.validation === 'running'
+                ? yellow('running')
+                : dim('pending');
+    const spinnerText = state.completed ? (state.validation === 'pass' ? green('ok') : red('fail')) : cyan(options.spinnerFrame ?? '|');
+    const timelineRows = Math.max(6, rows - 22);
+    const tools = [...state.toolCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 4)
+        .map(([name, count]) => `${name} ${count}`)
+        .join(', ') || 'none yet';
+    const lines = [];
+    lines.push(`${bold('Moda Analyst')} ${dim('Step 4/7 Harness Discovery')}`);
+    lines.push(rule(width));
+    lines.push(`${spinnerText} ${state.adapterName} ${dim('read-only repository access')}  ${dim(`elapsed ${formatDuration(elapsedSeconds)}`)}  ${dim(state.sawOutput ? `last output ${formatDuration(quietForSeconds)} ago` : 'waiting for first output')}`);
+    lines.push('');
+    lines.push(cyan('Session'));
+    lines.push(keyValue('Phase', state.phase, width));
+    lines.push(keyValue('Command', state.command, width));
+    lines.push(keyValue('Root', state.root, width));
+    lines.push(keyValue('Output', state.reportPath, width));
+    lines.push(keyValue('Boundary', 'Agent can inspect files and print a report. Moda validates, then writes artifacts.', width));
+    lines.push('');
+    lines.push(cyan('Status'));
+    lines.push(`  validation       ${validation}`);
+    lines.push(`  stream events    ${state.eventCount}`);
+    lines.push(`  rate limits      ${state.rateLimitCount}`);
+    lines.push(`  tools            ${tools}`);
+    lines.push('');
+    lines.push(cyan('Evidence'));
+    lines.push(`  runtime agents   ${metric(state.summary.runtimeAgentCount)}`);
+    lines.push(`  agent families   ${metric(state.summary.agentFamilyCount)}`);
+    lines.push(`  artifacts        ${metric(state.summary.artifactCount)}`);
+    lines.push(`  providers        ${metric(state.summary.modelProviderCount)}`);
+    lines.push(`  claims/citations ${metricPair(state.summary.claimCount, state.summary.citationCount)}`);
+    lines.push('');
+    lines.push(cyan('Timeline'));
+    const timeline = state.timeline.slice(-timelineRows);
+    if (timeline.length === 0) {
+        lines.push(`  ${dim('Waiting for analyst output...')}`);
+    }
+    else {
+        for (const item of timeline) {
+            const prefix = `  ${dim(item.time)} ${item.label.padEnd(11).slice(0, 11)} `;
+            lines.push(...wrapWithPrefix(prefix, item.message, width));
+        }
+    }
+    if (state.artifacts.length > 0) {
+        lines.push('');
+        lines.push(cyan('Artifacts'));
+        for (const artifact of state.artifacts.slice(0, 5))
+            lines.push(`  ${artifact}`);
+    }
+    lines.push('');
+    lines.push(dim('Ctrl+C aborts  |  --no-tui shows raw stream  |  --agent --stream emits NDJSON for agents'));
+    return fitToScreen(lines, rows, width).join('\n');
+}
+export function shouldUseAnalystTui(flags, outputMode) {
+    if (outputMode !== 'human')
+        return false;
+    if (flags['no-tui'] === 'true' || process.env.MODA_NO_TUI === '1')
+        return false;
+    if (process.env.TERM === 'dumb')
+        return false;
+    if (flags.tui === 'true')
+        return process.stderr.isTTY === true;
+    return process.stderr.isTTY === true && process.env.CI !== 'true';
+}
+function inferPhase(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes('report') && (lower.includes('json') || lower.includes('final')))
+        return 'producing cited report';
+    if (lower.includes('citation') || lower.includes('line number') || lower.includes('evidence'))
+        return 'verifying citations';
+    if (lower.includes('read') || lower.includes('file'))
+        return 'reading source evidence';
+    if (lower.includes('repository') || lower.includes('structure') || lower.includes('map'))
+        return 'mapping repository';
+    if (lower.includes('agent') || lower.includes('harness'))
+        return 'classifying harness';
+    return 'investigating repo';
+}
+function keyValue(label, value, width) {
+    const prefix = `  ${label.padEnd(10)} `;
+    return wrapWithPrefix(prefix, value, width).join('\n');
+}
+function wrapWithPrefix(prefix, text, width) {
+    const available = Math.max(16, width - visibleLength(prefix));
+    const words = compactWhitespace(text).split(' ');
+    const lines = [];
+    let current = '';
+    for (const word of words) {
+        const next = current ? `${current} ${word}` : word;
+        if (visibleLength(next) > available && current) {
+            lines.push(`${prefix}${current}`);
+            current = word;
+        }
+        else {
+            current = next;
+        }
+    }
+    if (current)
+        lines.push(`${prefix}${current}`);
+    return lines.length > 0 ? lines : [prefix.trimEnd()];
+}
+function fitToScreen(lines, rows, width) {
+    return lines
+        .slice(0, rows)
+        .map((line) => trimVisible(line, width));
+}
+function trimVisible(value, width) {
+    if (visibleLength(value) <= width)
+        return value;
+    const stripped = stripAnsi(value);
+    return stripped.length > width ? `${stripped.slice(0, Math.max(0, width - 3))}...` : stripped;
+}
+function rule(width) {
+    return '-'.repeat(width);
+}
+function metric(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? String(value) : 'pending';
+}
+function metricPair(left, right) {
+    return `${metric(left)} / ${metric(right)}`;
+}
+function formatDuration(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remaining = seconds % 60;
+    return `${minutes}m ${remaining}s`;
+}
+function timeOfDay(date) {
+    return date.toTimeString().slice(0, 8);
+}
+function spinner(index) {
+    return ['|', '/', '-', '\\'][index % 4] ?? '|';
+}
+function compactWhitespace(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function visibleLength(value) {
+    return stripAnsi(value).length;
+}
+function stripAnsi(value) {
+    return value.replace(/\u001b\[[0-9;?]*[A-Za-z]/g, '');
+}
+//# sourceMappingURL=analyst-tui.js.map

package/dist/api-client.d.ts

@@ -1,7 +1,11 @@
+import type { ProfileIOOptions } from './profiles.js';
 export declare class ApiError extends Error {
     readonly statusCode: number;
     readonly responseBody: string;
     constructor(message: string, statusCode: number, responseBody: string);
 }
 export declare function callDataAPI(endpoint: string): Promise<unknown>;
+export declare function callControlAPI(endpoint: string, options?: RequestInit, profileOptions?: ProfileIOOptions): Promise<unknown>;
+export declare function getApiRequestCount(): number;
+export declare function resetApiRequestCount(): void;
 //# sourceMappingURL=api-client.d.ts.map

package/dist/api-client.js

@@ -1,8 +1,9 @@
 // src/api-client.ts
-import { MODA_API_KEY, MODA_BASE_URL } from './config.js';
+import { resolveApiKey, resolveModaBaseUrl } from './config.js';
 const REQUEST_TIMEOUT_MS = 30_000;
 const MAX_RETRIES = 3;
 const INITIAL_BACKOFF_MS = 500;
+let apiRequestCount = 0;
 export class ApiError extends Error {
     statusCode;
     responseBody;
@@ -17,7 +18,15 @@ function isRetryable(status) {
     return status === 429 || status >= 500;
 }
 export async function callDataAPI(endpoint) {
-    const url = `${MODA_BASE_URL}/api/v1/data${endpoint}`;
+    apiRequestCount++;
+    const url = `${resolveModaBaseUrl()}/api/v1/data${endpoint}`;
+    return callModaAPI(url, { method: 'GET' });
+}
+export async function callControlAPI(endpoint, options = {}, profileOptions = {}) {
+    const url = `${resolveModaBaseUrl(profileOptions)}/api${endpoint}`;
+    return callModaAPI(url, options, profileOptions);
+}
+async function callModaAPI(url, options, profileOptions = {}) {
     let lastError;
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
         if (attempt > 0) {
@@ -28,9 +37,11 @@ export async function callDataAPI(endpoint) {
         const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
         try {
             const response = await fetch(url, {
+                ...options,
                 headers: {
-                    'x-api-key': MODA_API_KEY,
+                    'x-api-key': resolveApiKey(profileOptions) ?? '',
                     'Content-Type': 'application/json',
+                    ...(options.headers ?? {}),
                 },
                 signal: controller.signal,
             });
@@ -64,4 +75,10 @@ export async function callDataAPI(endpoint) {
     }
     throw lastError ?? new Error('Request failed after retries');
 }
+export function getApiRequestCount() {
+    return apiRequestCount;
+}
+export function resetApiRequestCount() {
+    apiRequestCount = 0;
+}
 //# sourceMappingURL=api-client.js.map

package/dist/auth.d.ts

@@ -1,4 +1,23 @@
-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>;
+import { type ProfileIOOptions } from './profiles.js';
+export interface StoredAuth {
+    access_token: string;
+    expires_at: number;
+    profile?: string;
+    token_type?: 'bearer';
+}
+export interface AuthSessionOptions extends ProfileIOOptions {
+    includeExpired?: boolean;
+}
+export declare function isAuthSessionValid(data: StoredAuth | null, now?: number): data is StoredAuth;
+export declare function loadToken(options?: AuthSessionOptions): string | null;
+export declare function loadAuthSession(options?: AuthSessionOptions): StoredAuth | null;
+export declare function saveAuthSession(accessToken: string, expiresIn: number, options?: ProfileIOOptions): StoredAuth;
+export declare function clearAuthSession(options?: ProfileIOOptions): void;
+export interface LoginOptions {
+    callbackPort?: number;
+    timeoutMs?: number;
+    openUrl?: (url: string) => Promise<void>;
+}
+export declare function login(screen?: 'login' | 'signup', options?: LoginOptions): Promise<string>;
+export declare function authFetch(path: string, options?: RequestInit, authOptions?: AuthSessionOptions): Promise<Response>;
 //# sourceMappingURL=auth.d.ts.map