@moda-ai/cli 1.22.0 → 1.22.2

package/dist/init/mcp.d.ts

@@ -1,2 +0,0 @@
-export declare function detectAgents(): string[];
-//# sourceMappingURL=mcp.d.ts.map

package/dist/init/mcp.js

@@ -1,27 +0,0 @@
-// src/init/mcp.ts — Coding agent detection
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { execSync } from 'node:child_process';
-function isOnPath(cmd) {
-    try {
-        execSync(`which ${cmd}`, { stdio: 'pipe' });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function detectAgents() {
-    const cwd = process.cwd();
-    const agents = [];
-    // Claude Code
-    if (existsSync(join(cwd, '.claude')) || isOnPath('claude')) {
-        agents.push('Claude Code');
-    }
-    // Cursor
-    if (existsSync(join(cwd, '.cursor'))) {
-        agents.push('Cursor');
-    }
-    return agents;
-}
-//# sourceMappingURL=mcp.js.map

package/dist/init/progress-board.d.ts

@@ -1,80 +0,0 @@
-export type ProgressLaneStatus = 'running' | 'done' | 'warning' | 'failed';
-export interface ProgressLane {
-    id: string;
-    title: string;
-    status: ProgressLaneStatus;
-    /** Latest one-line detail while running; frozen summary note when terminal. */
-    detail?: string;
-    /** Duration expectation appended to long-running lanes, e.g. "usually 2-4 min". */
-    expectation?: string;
-    startedAt: number;
-    finishedAt?: number;
-}
-export interface ProgressBoardFrameOptions {
-    now?: number;
-    spinnerFrame?: string;
-    color?: boolean;
-    /** Max visible line width; longer lines are truncated so in-place rewrites never wrap. */
-    width?: number;
-}
-/**
- * Pure frame renderer (unit-testable without a TTY): one line per lane, in
- * insertion order. Running lanes show spinner, title, elapsed, latest detail,
- * and the "(usually X min)" expectation; terminal lanes freeze to a glyph,
- * title, and their summary note.
- */
-export declare function renderProgressBoardFrame(lanes: readonly ProgressLane[], options?: ProgressBoardFrameOptions): string[];
-export interface InitProgressBoardOptions {
-    stream?: NodeJS.WriteStream;
-    /** Overrides TTY detection (in-place rendering); defaults to stream.isTTY with TERM=dumb treated as non-TTY. */
-    isTTY?: boolean;
-    color?: boolean;
-    now?: () => number;
-    renderIntervalMs?: number;
-    fallbackIntervalMs?: number;
-}
-/**
- * Stateful board driver. TTY mode repaints on a ~150ms interval (unref'd so it
- * never holds the process open); non-TTY mode prints plain lines on lane
- * start/terminal transitions and throttles intermediate updates to one line
- * per lane per 10s.
- */
-export declare class InitProgressBoard {
-    private readonly stream;
-    private readonly tty;
-    private readonly color;
-    private readonly now;
-    private readonly renderIntervalMs;
-    private readonly fallbackIntervalMs;
-    private readonly laneList;
-    private readonly lanesById;
-    private readonly lastFallbackPrint;
-    private timer;
-    private renderedLines;
-    private spinnerIndex;
-    private stopped;
-    constructor(options?: InitProgressBoardOptions);
-    get lanes(): readonly ProgressLane[];
-    startLane(id: string, title: string, options?: {
-        detail?: string;
-        expectation?: string;
-    }): void;
-    update(id: string, detail: string): void;
-    complete(id: string, note?: string): void;
-    warn(id: string, note?: string): void;
-    fail(id: string, note?: string): void;
-    /** Freeze the final frame (TTY) and release the repaint timer. Idempotent. */
-    stop(): void;
-    /**
-     * Terminal transitions are refinable: finishing an already-terminal lane
-     * updates its glyph/note (keeping the first finish time for elapsed), so a
-     * lane frozen early (e.g. "analysis finished on Moda; finalizing after
-     * setup") can be corrected once the final outcome is known. Exact duplicate
-     * finishes stay no-ops; `update()` still applies to running lanes only.
-     */
-    private finish;
-    private ensureTimer;
-    private render;
-    private writeLine;
-}
-//# sourceMappingURL=progress-board.d.ts.map

package/dist/init/progress-board.js

@@ -1,225 +0,0 @@
-// src/init/progress-board.ts. Multi-lane live progress board for moda init
-// Step 4 (Set up), where several activities run at once (hosted harness
-// analysis, fast local tasks, the SDK integration agent).
-//
-// Hand-rolled, no dependencies, stderr only. On a TTY the lane block is
-// rewritten in place with cursor-up ANSI, throttled to ~150ms; completed lanes
-// freeze to a check line so the board never grows unbounded. Non-TTY human
-// mode falls back to plain progress lines at most every 10s per lane.
-// Agent/json modes never construct a board (init emits NDJSON progress events
-// instead). Color gating follows tui.ts conventions (NO_COLOR / TERM=dumb
-// respected); spinner and duration helpers follow analyst-tui.ts.
-import { stripAnsi } from '../markdown-terminal.js';
-const SPINNER_FRAMES = ['◐', '◓', '◑', '◒'];
-const GLYPHS = {
-    done: '✓',
-    warning: '!',
-    failed: '✗',
-};
-const GLYPH_COLORS = {
-    done: 32,
-    warning: 33,
-    failed: 31,
-};
-/** Same one-line cap as ask-stream's tool cards. */
-const DETAIL_MAX = 100;
-const RENDER_INTERVAL_MS = 150;
-const NON_TTY_LANE_INTERVAL_MS = 10_000;
-/**
- * Pure frame renderer (unit-testable without a TTY): one line per lane, in
- * insertion order. Running lanes show spinner, title, elapsed, latest detail,
- * and the "(usually X min)" expectation; terminal lanes freeze to a glyph,
- * title, and their summary note.
- */
-export function renderProgressBoardFrame(lanes, options = {}) {
-    const now = options.now ?? Date.now();
-    const color = options.color ?? false;
-    const width = Math.max(48, Math.min(options.width ?? 120, 200));
-    const paint = (code, text) => color ? `\u001b[${code}m${text}\u001b[0m` : text;
-    const titleWidth = Math.min(32, lanes.reduce((max, lane) => Math.max(max, lane.title.length), 0));
-    return lanes.map((lane) => {
-        const title = lane.title.padEnd(titleWidth);
-        if (lane.status === 'running') {
-            const elapsed = formatDuration(Math.max(0, Math.round((now - lane.startedAt) / 1000)));
-            const detail = lane.detail ? `   ${oneLine(lane.detail)}` : '';
-            const expectation = lane.expectation ? ` ${paint(90, `(${lane.expectation})`)}` : '';
-            const glyph = paint(36, options.spinnerFrame ?? SPINNER_FRAMES[0]);
-            return truncateVisible(`  ${glyph} ${title}  ${paint(90, elapsed.padStart(6))}${detail}${expectation}`, width);
-        }
-        const glyph = paint(GLYPH_COLORS[lane.status], GLYPHS[lane.status]);
-        const note = lane.detail
-            ? oneLine(lane.detail)
-            : formatDuration(Math.max(0, Math.round(((lane.finishedAt ?? now) - lane.startedAt) / 1000)));
-        return truncateVisible(`  ${glyph} ${title}  ${note}`, width);
-    });
-}
-/**
- * Stateful board driver. TTY mode repaints on a ~150ms interval (unref'd so it
- * never holds the process open); non-TTY mode prints plain lines on lane
- * start/terminal transitions and throttles intermediate updates to one line
- * per lane per 10s.
- */
-export class InitProgressBoard {
-    stream;
-    tty;
-    color;
-    now;
-    renderIntervalMs;
-    fallbackIntervalMs;
-    laneList = [];
-    lanesById = new Map();
-    lastFallbackPrint = new Map();
-    timer;
-    renderedLines = 0;
-    spinnerIndex = 0;
-    stopped = false;
-    constructor(options = {}) {
-        this.stream = options.stream ?? process.stderr;
-        const dumbTerm = process.env.TERM === 'dumb';
-        this.tty = options.isTTY ?? (this.stream.isTTY === true && !dumbTerm);
-        // NO_COLOR disables color when set to any value, per no-color.org.
-        this.color = options.color ?? (this.tty && process.env.NO_COLOR === undefined);
-        this.now = options.now ?? Date.now;
-        this.renderIntervalMs = options.renderIntervalMs ?? RENDER_INTERVAL_MS;
-        this.fallbackIntervalMs = options.fallbackIntervalMs ?? NON_TTY_LANE_INTERVAL_MS;
-    }
-    get lanes() {
-        return this.laneList;
-    }
-    startLane(id, title, options = {}) {
-        if (this.stopped || this.lanesById.has(id))
-            return;
-        const lane = {
-            id,
-            title,
-            status: 'running',
-            detail: options.detail,
-            expectation: options.expectation,
-            startedAt: this.now(),
-        };
-        this.laneList.push(lane);
-        this.lanesById.set(id, lane);
-        if (this.tty) {
-            this.ensureTimer();
-            this.render();
-        }
-        else {
-            this.lastFallbackPrint.set(id, this.now());
-            this.writeLine(`  ${title}: ${lane.detail ? oneLine(lane.detail) : 'started'}${lane.expectation ? ` (${lane.expectation})` : ''}`);
-        }
-    }
-    update(id, detail) {
-        const lane = this.lanesById.get(id);
-        if (!lane || this.stopped || lane.status !== 'running')
-            return;
-        lane.detail = detail;
-        if (this.tty)
-            return; // interval repaints
-        const last = this.lastFallbackPrint.get(id) ?? 0;
-        if (this.now() - last < this.fallbackIntervalMs)
-            return;
-        this.lastFallbackPrint.set(id, this.now());
-        const elapsed = formatDuration(Math.max(0, Math.round((this.now() - lane.startedAt) / 1000)));
-        this.writeLine(`  ${lane.title}: ${oneLine(detail)} (${elapsed} elapsed)`);
-    }
-    complete(id, note) {
-        this.finish(id, 'done', note);
-    }
-    warn(id, note) {
-        this.finish(id, 'warning', note);
-    }
-    fail(id, note) {
-        this.finish(id, 'failed', note);
-    }
-    /** Freeze the final frame (TTY) and release the repaint timer. Idempotent. */
-    stop() {
-        if (this.stopped)
-            return;
-        this.stopped = true;
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = undefined;
-        }
-        if (this.tty && this.laneList.length > 0)
-            this.render();
-    }
-    /**
-     * Terminal transitions are refinable: finishing an already-terminal lane
-     * updates its glyph/note (keeping the first finish time for elapsed), so a
-     * lane frozen early (e.g. "analysis finished on Moda; finalizing after
-     * setup") can be corrected once the final outcome is known. Exact duplicate
-     * finishes stay no-ops; `update()` still applies to running lanes only.
-     */
-    finish(id, status, note) {
-        const lane = this.lanesById.get(id);
-        if (!lane || this.stopped)
-            return;
-        if (lane.status !== 'running' && lane.status === status && lane.detail === note)
-            return;
-        lane.status = status;
-        lane.detail = note;
-        lane.finishedAt ??= this.now();
-        if (this.tty) {
-            this.render();
-            return;
-        }
-        const label = status === 'done' ? 'done' : status === 'warning' ? 'warning' : 'failed';
-        this.writeLine(`  ${lane.title}: ${label}${note ? ` (${oneLine(note)})` : ''}`);
-    }
-    ensureTimer() {
-        if (this.timer || !this.tty)
-            return;
-        this.timer = setInterval(() => this.render(), this.renderIntervalMs);
-        // Never keep the process alive just to animate a spinner.
-        this.timer.unref?.();
-    }
-    render() {
-        if (!this.tty || this.laneList.length === 0)
-            return;
-        const lines = renderProgressBoardFrame(this.laneList, {
-            now: this.now(),
-            spinnerFrame: SPINNER_FRAMES[this.spinnerIndex++ % SPINNER_FRAMES.length],
-            color: this.color,
-            width: this.stream.columns ?? 120,
-        });
-        const up = this.renderedLines > 0 ? `\u001b[${this.renderedLines}A` : '';
-        this.stream.write(`${up}${lines.map((line) => `\u001b[2K${line}`).join('\n')}\n`);
-        this.renderedLines = lines.length;
-    }
-    writeLine(line) {
-        this.stream.write(`${line}\n`);
-    }
-}
-/**
- * One-line convention shared with ask-stream tool cards: strip escapes,
- * collapse whitespace, cap ~100 chars. Lane details carry backend/agent
- * controlled text (hosted progress messages, tool inputs like file paths and
- * shell commands), so ANSI/OSC escapes and remaining C0 controls must be
- * removed before the text reaches the terminal; an embedded escape would
- * otherwise corrupt the in-place cursor-up rewrite or inject control output.
- */
-function oneLine(text) {
-    const collapsed = stripAnsi(text)
-        .replace(/[\u0000-\u001f\u007f]+/g, ' ')
-        .replace(/\s+/g, ' ')
-        .trim();
-    return collapsed.length > DETAIL_MAX ? `${collapsed.slice(0, DETAIL_MAX - 1)}…` : collapsed;
-}
-/** Same shape as analyst-tui.ts formatDuration. */
-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 truncateVisible(value, width) {
-    if (visibleLength(value) <= width)
-        return value;
-    const stripped = stripAnsi(value);
-    return `${stripped.slice(0, Math.max(0, width - 3))}...`;
-}
-function visibleLength(value) {
-    return stripAnsi(value).length;
-}
-//# sourceMappingURL=progress-board.js.map

package/dist/init/rules.d.ts

@@ -1,6 +0,0 @@
-export declare function claudeSkillToCursorRule(skillContent: string): string;
-export declare function installRules(detectedAgents: string[], options?: {
-    yes?: boolean;
-    silent?: boolean;
-}): Promise<void>;
-//# sourceMappingURL=rules.d.ts.map

package/dist/init/rules.js

@@ -1,171 +0,0 @@
-// 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';
-// --- 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: '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,
-    },
-};
-// --- 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;
-export 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, options = {}) {
-    const adapters = detectedAgents
-        .map((a) => ADAPTERS[a])
-        .filter((a) => a !== undefined);
-    if (adapters.length === 0) {
-        if (!options.silent)
-            console.log('  No supported coding agents detected');
-        return;
-    }
-    const agentList = adapters.map((a) => a.name).join(', ');
-    const skillList = SKILLS.map((s) => `\n    • ${s.label}`).join('');
-    const shouldInstall = options.yes
-        ? true
-        : await confirm({
-            message: `Install Moda skills for ${agentList}?${skillList}\n  Continue?`,
-            default: true,
-        });
-    if (!shouldInstall) {
-        if (!options.silent)
-            console.log('  Skipped');
-        return;
-    }
-    let wrote = 0;
-    let skipped = 0;
-    let failed = 0;
-    for (const skill of SKILLS) {
-        let content;
-        try {
-            content = loadSkillSource(skill.id);
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`  Warning: ${message}`);
-            failed += adapters.length;
-            continue;
-        }
-        for (const adapter of adapters) {
-            const outcome = installSkillForAgent(skill, adapter, content);
-            switch (outcome.status) {
-                case 'wrote':
-                    if (!options.silent)
-                        console.log(`  ${outcome.agent}: wrote ${outcome.relativePath}`);
-                    wrote++;
-                    break;
-                case 'exists':
-                    if (!options.silent) {
-                        console.log(`  ${outcome.agent}: ${outcome.relativePath} already exists — skipping`);
-                    }
-                    skipped++;
-                    break;
-                case 'failed':
-                    if (!options.silent) {
-                        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) {
-        if (!options.silent)
-            console.log(`  Done — ${summary}`);
-    }
-}
-//# sourceMappingURL=rules.js.map

package/dist/init/sdk-catalog.d.ts

@@ -1,10 +0,0 @@
-import { type BundledSkillIndex } from '../skills-bundled.js';
-export interface MaterializedSdkCatalog {
-    dir: string;
-    relativeDir: string;
-    index: BundledSkillIndex;
-}
-export declare function materializeSdkCatalog(cwd: string, runId: string): MaterializedSdkCatalog;
-export declare function cleanupSdkCatalog(dir: string): void;
-export declare function renderCatalogListing(index: BundledSkillIndex): string;
-//# sourceMappingURL=sdk-catalog.d.ts.map

package/dist/init/sdk-catalog.js

@@ -1,80 +0,0 @@
-// src/init/sdk-catalog.ts — Ephemeral, run-scoped materialization of the
-// complete bundled SDK integration-skill catalog for a coding agent to browse.
-import { copyFileSync, existsSync, mkdirSync, readdirSync, rmSync, statSync, } from 'node:fs';
-import { join, relative, resolve } from 'node:path';
-import { bundledSkillsDir, readBundledIndex, } from '../skills-bundled.js';
-export function materializeSdkCatalog(cwd, runId) {
-    if (!/^[a-z0-9-]+$/.test(runId)) {
-        throw new Error(`Invalid SDK catalog run id: ${JSON.stringify(runId).slice(0, 80)}`);
-    }
-    const sourceDir = bundledSkillsDir();
-    const indexPath = join(sourceDir, 'index.json');
-    if (!existsSync(sourceDir) || !existsSync(indexPath)) {
-        throw missingBundleError(sourceDir);
-    }
-    const index = readBundledIndex();
-    if (!index) {
-        throw missingBundleError(sourceDir);
-    }
-    const dir = join(cwd, '.moda', 'tmp', `sdk-catalog-${runId}`);
-    cleanupSdkCatalog(dir);
-    copyDirectoryRecursive(sourceDir, dir);
-    return {
-        dir,
-        relativeDir: relative(cwd, dir).replace(/\\/g, '/'),
-        index,
-    };
-}
-export function cleanupSdkCatalog(dir) {
-    const normalized = resolve(dir).replace(/\\/g, '/');
-    if (!normalized.includes('.moda/tmp/sdk-catalog-'))
-        return;
-    try {
-        rmSync(dir, { recursive: true, force: true });
-    }
-    catch {
-        // Catalog cleanup is best-effort and must never mask the integration result.
-    }
-}
-export function renderCatalogListing(index) {
-    return index.skills.map((skill) => {
-        const targets = [`language: ${skill.targets.language}`];
-        if (skill.targets.frameworks.length > 0) {
-            targets.push(`frameworks: ${skill.targets.frameworks.join(',')}`);
-        }
-        if (skill.targets.providers.length > 0) {
-            targets.push(`providers: ${skill.targets.providers.join(',')}`);
-        }
-        return `- ${skill.id} — ${skill.summary} [${targets.join('; ')}]`;
-    }).join('\n');
-}
-function copyDirectoryRecursive(sourceDir, targetDir) {
-    mkdirSync(targetDir, { recursive: true });
-    for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
-        const source = join(sourceDir, entry.name);
-        const target = join(targetDir, entry.name);
-        if (entry.isDirectory()) {
-            copyDirectoryRecursive(source, target);
-        }
-        else if (entry.isFile()) {
-            copyFileSync(source, target);
-        }
-    }
-}
-function missingBundleError(sourceDir) {
-    let detail = 'is absent';
-    try {
-        if (existsSync(sourceDir) && !statSync(sourceDir).isDirectory()) {
-            detail = 'is not a directory';
-        }
-        else if (existsSync(sourceDir)) {
-            detail = 'has no readable index.json';
-        }
-    }
-    catch {
-        detail = 'is not readable';
-    }
-    return new Error(`Bundled SDK skill catalog ${detail} at ${sourceDir}. ` +
-        'Set MODA_BUNDLED_SKILLS_DIR to a built bundle, or run the integration-skill bundle build in a dev tree.');
-}
-//# sourceMappingURL=sdk-catalog.js.map

package/dist/init/sdk-guide.d.ts

@@ -1,19 +0,0 @@
-export declare const SDK_GUIDE_PATH = ".moda/SDK_INTEGRATION.md";
-type RuntimeSummary = {
-    runtimeAgents: number;
-    agentFamilies: number;
-    frameworks: string[];
-    providers: string[];
-    runtimeAgentNames: string[];
-};
-/**
- * Write the human/agent-readable fallback guide (.moda/SDK_INTEGRATION.md).
- * Used when automatic SDK integration did not complete successfully.
- */
-export declare function writeSdkIntegrationGuide(cwd?: string): string;
-export declare function renderSdkIntegrationGuideContent(): string;
-/** Read optional harness discovery context from `.moda/harness.json`. */
-export declare function readRuntimeSummary(cwd: string): RuntimeSummary;
-export declare function renderRuntimeSummaryBlock(summary: RuntimeSummary): string;
-export {};
-//# sourceMappingURL=sdk-guide.d.ts.map