@moda-ai/cli 1.1.1 → 1.3.0

package/dist/skills.js

@@ -0,0 +1,468 @@
+// src/skills.ts — `moda skills` command: pull tenant-generated skills locally.
+//
+// The Moda skill-creation pipeline generates per-tenant SKILL.md files
+// server-side (moda-skill-harness) and stores their full text in ClickHouse.
+// `moda skills gen` kicks off server-side skill generation through the ingest
+// worker, which validates the user's Bearer API key before forwarding to the
+// internal harness. `moda skills pull` fetches generated skills via
+// `GET /v1/skills` (authenticated with the same Bearer API key used for
+// snapshots) and writes each into the user's coding-agent skill directory so
+// the agent can use them:
+//
+//   .claude/skills/<skill_id>/SKILL.md   (Claude Code, canonical format)
+//   .cursor/rules/<skill_id>.mdc         (Cursor, when a .cursor dir exists)
+//
+// Skills are managed artifacts. A pull installs the latest server-published
+// generation snapshot, tracked in .moda/skills.yml, and prunes only files that a
+// previous Moda pull wrote.
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmdirSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { basename, dirname, isAbsolute, join, normalize, relative, resolve } from 'node:path';
+import { resolveApiKey, resolveIngestUrl, resolveTenantId } from './config.js';
+import { claudeSkillToCursorRule } from './init/rules.js';
+import { detectAgents } from './init/mcp.js';
+import { CliInputError } from './errors.js';
+const SKILLS_REQUEST_TIMEOUT_MS = 15_000;
+const VALID_STATUSES = new Set(['approved', 'proposed', 'all']);
+const SKILLS_MANIFEST_PATH = join('.moda', 'skills.yml');
+/**
+ * Fetch a tenant's generated skills from the ingest worker. Uses the persisted
+ * API key + ingest URL (`~/.moda/config.json`), mirroring snapshot auth.
+ */
+async function fetchSkills(status) {
+    const apiKey = resolveApiKey();
+    if (!apiKey) {
+        throw new CliInputError('No Moda API key found. Run `moda init` first (or set MODA_API_KEY).');
+    }
+    const ingestUrl = resolveIngestUrl().replace(/\/$/, '');
+    const url = `${ingestUrl}/v1/skills?status=${encodeURIComponent(status)}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), SKILLS_REQUEST_TIMEOUT_MS);
+    let response;
+    try {
+        response = await fetch(url, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Network error: failed to reach ${ingestUrl} (${message})`);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new Error(`Failed to fetch skills (HTTP ${response.status}): ${body.slice(0, 200)}`);
+    }
+    const data = (await response.json());
+    if (!data.success) {
+        throw new Error(data.message || 'Failed to fetch skills');
+    }
+    const skills = Array.isArray(data.skills) ? data.skills : [];
+    const release = data.release && typeof data.release === 'object' ? data.release : null;
+    return {
+        skills,
+        tenantId: data.tenant_id || resolveTenantId() || '',
+        release,
+        releaseKey: releaseKeyFor(release, skills, status),
+        status,
+    };
+}
+/**
+ * Write `content` to `filePath`, creating parent dirs. Returns whether the
+ * file was created, updated (content differed), or left unchanged.
+ */
+function writeIfChanged(filePath, content) {
+    try {
+        mkdirSync(dirname(filePath), { recursive: true });
+        if (existsSync(filePath)) {
+            const current = readFileSync(filePath, 'utf8');
+            if (current === content)
+                return 'unchanged';
+            writeFileSync(filePath, content);
+            return 'updated';
+        }
+        writeFileSync(filePath, content);
+        return 'wrote';
+    }
+    catch {
+        return 'failed';
+    }
+}
+/**
+ * Pull generated skills into the detected coding agents' skill directories.
+ * Exported so `moda init` can run it as a setup step. Best-effort and quiet on
+ * an empty store; never throws for "no skills yet".
+ */
+export async function pullSkills(options = {}) {
+    const status = options.status ?? 'approved';
+    const cwd = options.cwd ?? process.cwd();
+    const log = (msg) => {
+        if (!options.silent)
+            console.log(msg);
+    };
+    const fetched = await fetchSkills(status);
+    const { skills } = fetched;
+    const summary = {
+        total: skills.length,
+        pruned: 0,
+        wrote: 0,
+        updated: 0,
+        unchanged: 0,
+        failed: 0,
+    };
+    if (skills.length === 0) {
+        log('  No skills to pull yet.');
+        return summary;
+    }
+    const previousManifest = readSkillsManifest(cwd);
+    if (previousManifest &&
+        previousManifest.managedPaths.length > 0 &&
+        previousManifest.releaseKey !== fetched.releaseKey) {
+        summary.pruned = pruneManagedSkillPaths(cwd, previousManifest.managedPaths, log);
+    }
+    // Always target Claude Code (canonical SKILL.md). Also write Cursor rules
+    // when the project has a .cursor directory.
+    const agents = detectAgents();
+    const writeCursor = agents.includes('Cursor') || existsSync(join(cwd, '.cursor'));
+    const records = [];
+    for (const skill of skills) {
+        if (!skill.skill_id || !skill.skill_md) {
+            summary.failed++;
+            continue;
+        }
+        // Path-traversal guard: the API response is trusted but defense-in-depth
+        // for a compromised / MITM'd ingest endpoint. `basename` strips any
+        // leading directory components, and the allowlist rejects `..`, `/`,
+        // `\`, null bytes, and anything else outside a plain identifier so the
+        // resolved path cannot escape the per-skill directory.
+        const safeId = basename(skill.skill_id);
+        if (!safeId || !/^[A-Za-z0-9_-]+$/.test(safeId)) {
+            summary.failed++;
+            log(`  skipped invalid skill_id: ${JSON.stringify(skill.skill_id).slice(0, 80)}`);
+            continue;
+        }
+        const claudePath = join(cwd, '.claude', 'skills', safeId, 'SKILL.md');
+        const claudeStatus = writeIfChanged(claudePath, skill.skill_md);
+        const claudeRelativePath = `.claude/skills/${safeId}/SKILL.md`;
+        recordOutcome(summary, claudeStatus, log, claudeRelativePath);
+        const paths = [];
+        if (claudeStatus !== 'failed')
+            paths.push(claudeRelativePath);
+        if (writeCursor) {
+            const cursorPath = join(cwd, '.cursor', 'rules', `${safeId}.mdc`);
+            const cursorStatus = writeIfChanged(cursorPath, claudeSkillToCursorRule(skill.skill_md));
+            const cursorRelativePath = `.cursor/rules/${safeId}.mdc`;
+            recordOutcome(summary, cursorStatus, log, cursorRelativePath);
+            if (cursorStatus !== 'failed')
+                paths.push(cursorRelativePath);
+        }
+        if (paths.length > 0) {
+            records.push({
+                skillId: safeId,
+                contentHash: sha256(skill.skill_md),
+                paths,
+            });
+        }
+    }
+    writeSkillsManifest(cwd, fetched, records);
+    return summary;
+}
+function recordOutcome(summary, status, log, relativePath) {
+    switch (status) {
+        case 'wrote':
+            summary.wrote++;
+            log(`  wrote ${relativePath}`);
+            break;
+        case 'updated':
+            summary.updated++;
+            log(`  updated ${relativePath}`);
+            break;
+        case 'unchanged':
+            summary.unchanged++;
+            break;
+        case 'failed':
+            summary.failed++;
+            log(`  failed ${relativePath}`);
+            break;
+    }
+}
+/**
+ * `moda skills <subcommand>` dispatcher.
+ */
+export async function runSkillsCommand(args) {
+    const sub = args.positional;
+    if (sub === 'gen') {
+        const result = await generateSkills(args.flags);
+        if (args.flags.json === 'true') {
+            console.log(JSON.stringify(result));
+        }
+        else if (result.accepted) {
+            console.log([
+                'accepted: true',
+                result.generation_run_id && `generation_run_id: ${result.generation_run_id}`,
+                result.message && `message: ${result.message}`,
+            ].filter(Boolean).join('\n'));
+        }
+        else {
+            console.log([
+                `processed: ${result.sessions_processed ?? 0}`,
+                `failed: ${result.sessions_failed ?? 0}`,
+                `pending: ${result.sessions_pending ?? 0}`,
+                `pending_found: ${result.pending_sessions_found ?? 0}`,
+                `distilled: ${Number(result.cluster_result?.distilled_skills_generated ?? 0)}`,
+                `indexed: ${Number(result.cluster_result?.skills_indexed ?? 0)}`,
+            ].join('\n'));
+        }
+        return Number(result.sessions_failed ?? 0) > 0 ? 1 : 0;
+    }
+    if (sub !== 'pull') {
+        throw new CliInputError(sub ? `Unknown skills subcommand '${sub}'` : 'A skills subcommand is required', 'Usage: moda skills gen [--source=all|sdk|coding-agent] [--max-sessions=N] [--start-at=ISO] [--end-at=ISO] [--replay] [--reprocess-segments] [--force-reprocess] [--wait] | moda skills pull [--status=approved|proposed|all]');
+    }
+    const status = (args.flags.status ?? 'approved').toLowerCase();
+    if (!VALID_STATUSES.has(status)) {
+        throw new CliInputError(`Invalid --status '${status}'`, `Must be one of: ${[...VALID_STATUSES].join(', ')}`);
+    }
+    const summary = await pullSkills({ status });
+    const parts = [
+        summary.pruned && `${summary.pruned} pruned`,
+        summary.wrote && `${summary.wrote} written`,
+        summary.updated && `${summary.updated} updated`,
+        summary.unchanged && `${summary.unchanged} unchanged`,
+        summary.failed && `${summary.failed} failed`,
+    ].filter(Boolean);
+    if (summary.total > 0) {
+        console.log(`  Done — ${parts.join(', ') || 'no changes'}`);
+    }
+    return summary.failed > 0 ? 1 : 0;
+}
+async function generateSkills(flags) {
+    const apiKey = resolveApiKey();
+    if (!apiKey) {
+        throw new CliInputError('No Moda API key found. Run `moda init` first (or set MODA_API_KEY).');
+    }
+    const tenantId = flags['tenant-id'] || resolveTenantId();
+    const directHarnessUrl = flags['harness-url'] || process.env.MODA_SKILL_HARNESS_URL;
+    if (directHarnessUrl && !tenantId) {
+        throw new CliInputError('No Moda tenant id found. Run `moda init` first (or set MODA_TENANT_ID / --tenant-id).');
+    }
+    const endpoint = directHarnessUrl
+        ? `${directHarnessUrl.replace(/\/+$/, '')}/skills/generate`
+        : `${resolveIngestUrl().replace(/\/+$/, '')}/v1/skills/generate`;
+    const waitForCompletion = flags.wait === 'true' || flags['wait-for-completion'] === 'true';
+    const forceReprocess = flags['force-reprocess'] === 'true';
+    const body = compactObject({
+        tenant_id: tenantId || undefined,
+        max_sessions: parsePositiveInt(flags['max-sessions'], 0),
+        lookback_hours: parsePositiveInt(flags['lookback-hours'], 0),
+        start_at: flags['start-at'] || undefined,
+        end_at: flags['end-at'] || undefined,
+        clustering_run_id: flags['clustering-run-id'] || undefined,
+        run_clustering: flags['no-clustering'] !== 'true',
+        source: normalizeSkillSource(flags.source),
+        clustering_timeout_seconds: parsePositiveInt(flags['clustering-timeout-seconds'], 0),
+        clustering_poll_seconds: parsePositiveInt(flags['clustering-poll-seconds'], 15),
+        max_cluster_pct: parseOptionalFloat(flags['max-cluster-pct']),
+        reprocess_segments: flags['reprocess-segments'] === 'true' || forceReprocess,
+        run_replay: flags.replay === 'true' && flags['no-replay'] !== 'true',
+        max_traces: parsePositiveInt(flags['max-traces'], 0),
+        improve_candidates: flags['improve-candidates'] === 'true',
+        improvement_rounds: parsePositiveInt(flags['improvement-rounds'], 2),
+        force_reprocess: forceReprocess,
+        wait_for_completion: waitForCompletion,
+    });
+    const headers = {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+    };
+    if (tenantId)
+        headers['X-Moda-Tenant-Id'] = tenantId;
+    const response = await fetch(endpoint, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        const text = await response.text().catch(() => '');
+        throw new Error(`Failed to generate skills (HTTP ${response.status}): ${text.slice(0, 200)}`);
+    }
+    return (await response.json());
+}
+function parsePositiveInt(value, fallback) {
+    if (!value)
+        return fallback;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+function parseOptionalFloat(value) {
+    if (!value)
+        return undefined;
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function compactObject(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+}
+function normalizeSkillSource(value) {
+    const normalized = (value || 'all').toLowerCase().replace(/-/g, '_');
+    if (['all', 'sdk', 'coding_agent'].includes(normalized))
+        return normalized;
+    return 'all';
+}
+function releaseKeyFor(release, skills, status) {
+    if (release?.generation_run_id)
+        return `${status}:run:${release.generation_run_id}`;
+    if (Number(release?.generation_version || 0) > 0) {
+        return `${status}:version:${Number(release?.generation_version)}`;
+    }
+    return `${status}:legacy:${sha256(JSON.stringify(skills.map((skill) => ({
+        skill_id: skill.skill_id,
+        hash: sha256(skill.skill_md || ''),
+    })).sort((a, b) => a.skill_id.localeCompare(b.skill_id))))}`;
+}
+function readSkillsManifest(cwd) {
+    const manifestPath = join(cwd, SKILLS_MANIFEST_PATH);
+    if (!existsSync(manifestPath))
+        return null;
+    let text = '';
+    try {
+        text = readFileSync(manifestPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    return {
+        tenantId: readYamlScalar(text, 'tenant_id'),
+        generationRunId: readYamlScalar(text, 'generation_run_id'),
+        generationVersion: Number(readYamlScalar(text, 'generation_version') || 0),
+        releaseKey: readYamlScalar(text, 'release_key'),
+        releasedAt: readYamlScalar(text, 'released_at'),
+        managedPaths: readManagedPaths(text),
+    };
+}
+function writeSkillsManifest(cwd, fetched, records) {
+    const manifestPath = join(cwd, SKILLS_MANIFEST_PATH);
+    const managedPaths = [...new Set(records.flatMap((record) => record.paths))].sort();
+    const release = fetched.release;
+    const lines = [
+        'version: 1',
+        'source: moda',
+        `tenant_id: ${yamlQuote(fetched.tenantId)}`,
+        `release_key: ${yamlQuote(fetched.releaseKey)}`,
+        `status_filter: ${yamlQuote(fetched.status)}`,
+        `generation_run_id: ${yamlQuote(release?.generation_run_id || '')}`,
+        `generation_version: ${Number(release?.generation_version || 0)}`,
+        `released_at: ${yamlQuote(release?.released_at || '')}`,
+        `installed_at: ${yamlQuote(new Date().toISOString())}`,
+        'managed_paths:',
+        ...managedPaths.map((path) => `  - ${yamlQuote(path)}`),
+        'skills:',
+        ...records.flatMap((record) => [
+            `  - skill_id: ${yamlQuote(record.skillId)}`,
+            `    content_hash: ${yamlQuote(record.contentHash)}`,
+            '    paths:',
+            ...record.paths.map((path) => `      - ${yamlQuote(path)}`),
+        ]),
+        '',
+    ];
+    mkdirSync(dirname(manifestPath), { recursive: true });
+    writeFileSync(manifestPath, lines.join('\n'));
+}
+function pruneManagedSkillPaths(cwd, managedPaths, log) {
+    let pruned = 0;
+    for (const rawPath of [...new Set(managedPaths)]) {
+        const safePath = safeManagedRelativePath(rawPath);
+        if (!safePath)
+            continue;
+        const absolutePath = absoluteManagedPath(cwd, safePath);
+        if (!absolutePath || !existsSync(absolutePath))
+            continue;
+        try {
+            unlinkSync(absolutePath);
+            pruned++;
+            log(`  pruned ${safePath}`);
+            pruneEmptyClaudeSkillDir(cwd, safePath);
+        }
+        catch {
+            // Best-effort cleanup. The following write pass can still repair files
+            // that remain writable.
+        }
+    }
+    return pruned;
+}
+function pruneEmptyClaudeSkillDir(cwd, relativePath) {
+    if (!relativePath.startsWith('.claude/skills/') || !relativePath.endsWith('/SKILL.md'))
+        return;
+    const dir = dirname(join(cwd, relativePath));
+    try {
+        if (existsSync(dir) && readdirSync(dir).length === 0) {
+            rmdirSync(dir);
+        }
+    }
+    catch {
+        // Empty-dir pruning is only cosmetic.
+    }
+}
+function absoluteManagedPath(cwd, relativePath) {
+    const abs = resolve(cwd, relativePath);
+    const root = resolve(cwd);
+    const rel = relative(root, abs);
+    if (rel.startsWith('..') || isAbsolute(rel))
+        return null;
+    return abs;
+}
+function safeManagedRelativePath(rawPath) {
+    if (!rawPath || rawPath.includes('\0') || isAbsolute(rawPath))
+        return null;
+    const normalized = normalize(rawPath).replace(/\\/g, '/');
+    if (normalized.startsWith('../') || normalized === '..' || normalized.includes('/../'))
+        return null;
+    const isClaudeSkill = normalized.startsWith('.claude/skills/') && normalized.endsWith('/SKILL.md');
+    const isCursorRule = normalized.startsWith('.cursor/rules/') && normalized.endsWith('.mdc');
+    return isClaudeSkill || isCursorRule ? normalized : null;
+}
+function readYamlScalar(text, key) {
+    const match = text.match(new RegExp(`^${key}:\\s*(.*?)\\s*$`, 'm'));
+    return match ? parseYamlScalar(match[1]) : '';
+}
+function readManagedPaths(text) {
+    const paths = [];
+    let inManagedPaths = false;
+    for (const line of text.split(/\r?\n/)) {
+        if (line.trim() === 'managed_paths:') {
+            inManagedPaths = true;
+            continue;
+        }
+        if (inManagedPaths && line.length > 0 && !line.startsWith(' '))
+            break;
+        if (!inManagedPaths)
+            continue;
+        const match = line.match(/^\s*-\s*(.*?)\s*$/);
+        if (match)
+            paths.push(parseYamlScalar(match[1]));
+    }
+    return paths.filter(Boolean);
+}
+function parseYamlScalar(raw) {
+    const value = raw.trim();
+    if (!value)
+        return '';
+    if (value.startsWith('"')) {
+        try {
+            return String(JSON.parse(value));
+        }
+        catch {
+            return value.replace(/^"|"$/g, '');
+        }
+    }
+    return value.replace(/^'|'$/g, '');
+}
+function yamlQuote(value) {
+    return JSON.stringify(value);
+}
+function sha256(input) {
+    return createHash('sha256').update(input).digest('hex');
+}
+//# sourceMappingURL=skills.js.map

package/dist/sync.d.ts

@@ -0,0 +1,5 @@
+import type { CommandContext } from './command-context.js';
+export declare function runSyncCommand(context: CommandContext): Promise<{
+    exitCode: number;
+}>;
+//# sourceMappingURL=sync.d.ts.map

package/dist/sync.js

@@ -0,0 +1,27 @@
+import { CliInputError } from './errors.js';
+import { runHarnessCommand } from './harness.js';
+import { runPromptsCommand } from './prompts.js';
+export async function runSyncCommand(context) {
+    const resource = context.positionals[0] ?? 'harness';
+    const rest = context.positionals.slice(1);
+    if (resource === 'harness') {
+        return runHarnessCommand({
+            ...context,
+            command: 'harness',
+            positional: 'sync',
+            positionals: ['sync', ...rest],
+        });
+    }
+    if (resource === 'prompts') {
+        await runPromptsCommand(['sync', ...rest], context.flags, {
+            profile: context.profile,
+            env: context.env,
+        });
+        return { exitCode: 0 };
+    }
+    if (resource === 'skills') {
+        throw new CliInputError('`moda sync skills` is not implemented yet.', 'Use `moda skills gen` to ask Moda to generate skills, then `moda skills pull` to install approved skills locally.');
+    }
+    throw new CliInputError(`Unknown sync resource '${resource}'.`, 'Usage: moda sync [harness|prompts] [--dry-run] [--profile=NAME]');
+}
+//# sourceMappingURL=sync.js.map

package/dist/telemetry.d.ts

@@ -0,0 +1,18 @@
+export type TelemetryStatus = 'success' | 'error';
+export type TelemetryErrorType = 'validation_error' | 'api_error' | 'network_error' | 'unknown_error';
+export interface CliUsageTelemetryInput {
+    apiKey: string | undefined;
+    command: string;
+    flags: Record<string, string>;
+    status: TelemetryStatus;
+    errorType?: TelemetryErrorType;
+    exitCode: number;
+    durationMs: number;
+    apiRequestCount: number;
+}
+export declare function stripTelemetryFlag(flags: Record<string, string>): Record<string, string>;
+export declare function isTelemetryDisabled(flags: Record<string, string>): boolean;
+export declare function getInvocationId(): string;
+export declare function sanitizedFlagNames(flags: Record<string, string>): string[];
+export declare function sendCliUsageTelemetry(input: CliUsageTelemetryInput): Promise<void>;
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/telemetry.js

@@ -0,0 +1,63 @@
+import { randomUUID } from 'node:crypto';
+import { VERSION, resolveModaBaseUrl } from './config.js';
+const TELEMETRY_TIMEOUT_MS = 500;
+const INVOCATION_ID = randomUUID();
+const TELEMETRY_FLAG = 'no-telemetry';
+export function stripTelemetryFlag(flags) {
+    const { [TELEMETRY_FLAG]: _drop, ...rest } = flags;
+    return rest;
+}
+export function isTelemetryDisabled(flags) {
+    return (flags[TELEMETRY_FLAG] === 'true' ||
+        process.env.MODA_CLI_TELEMETRY === '0' ||
+        process.env.DO_NOT_TRACK === '1');
+}
+export function getInvocationId() {
+    return INVOCATION_ID;
+}
+export function sanitizedFlagNames(flags) {
+    return Object.keys(stripTelemetryFlag(flags)).sort();
+}
+export async function sendCliUsageTelemetry(input) {
+    if (!input.apiKey || isTelemetryDisabled(input.flags)) {
+        return;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), TELEMETRY_TIMEOUT_MS);
+    // Allow Node's event loop to drain naturally without the timer keeping
+    // the process alive after telemetry resolves.
+    if (typeof timeout.unref === 'function') {
+        timeout.unref();
+    }
+    try {
+        await fetch(`${resolveModaBaseUrl()}/api/v1/data/cli-usage`, {
+            method: 'POST',
+            headers: {
+                'x-api-key': input.apiKey,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                invocation_id: INVOCATION_ID,
+                command: input.command.slice(0, 64),
+                status: input.status,
+                error_type: input.errorType,
+                exit_code: input.exitCode,
+                duration_ms: Math.max(0, Math.round(input.durationMs)),
+                api_request_count: Math.max(0, Math.round(input.apiRequestCount)),
+                cli_version: VERSION,
+                node_version: process.versions.node,
+                platform: process.platform,
+                arch: process.arch,
+                flags_json: { names: sanitizedFlagNames(input.flags) },
+            }),
+            signal: controller.signal,
+        });
+    }
+    catch {
+        // Telemetry must never affect command output or exit behavior.
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+//# sourceMappingURL=telemetry.js.map

package/dist/tui.d.ts

@@ -0,0 +1,40 @@
+import type { DoctorCheckStatus, DoctorReport, StatusPayload } from './doctor.js';
+import type { InitPhaseResult, InitSetupAction } from './init/index.js';
+type TerminalBadge = DoctorCheckStatus | 'info' | 'run';
+export declare function renderDoctorHuman(report: DoctorReport, options?: {
+    color?: boolean;
+    width?: number;
+}): string;
+export declare function renderStatusHuman(status: StatusPayload, options?: {
+    color?: boolean;
+    width?: number;
+}): string;
+export declare function renderInitBanner(): string;
+export declare function renderInitStep(index: number, total: number, title: string, detail?: string): string;
+export declare function renderInitNote(message: string, status?: DoctorCheckStatus): string;
+export declare function renderInitSetupPlan(actions: InitSetupAction[]): string;
+export declare function renderInitComplete(options: {
+    tenantName: string;
+    filesChanged: string[];
+    skipped: InitSetupAction[];
+    phases: InitPhaseResult[];
+}): string;
+export declare function renderHarnessProgress(message: string, status?: TerminalBadge): string;
+export declare function renderHarnessAnalystPreflight(options: {
+    root: string;
+    willRead: readonly string[];
+    willSkip: readonly string[];
+}): string;
+export declare function renderHarnessAnalystLaunch(options: {
+    adapterName: string;
+    command: string;
+    root: string;
+    reportPath: string;
+}): string;
+export declare function renderHarnessAnalystChoice(options: {
+    detected: readonly string[];
+}): string;
+export declare function renderHarnessAnalyzeHumanResult(data: unknown): string;
+export declare function renderOverviewHuman(data: unknown): string;
+export {};
+//# sourceMappingURL=tui.d.ts.map