@moda-ai/cli 1.1.1 → 1.3.0

package/dist/init/index.d.ts

@@ -1,2 +1,31 @@
-export declare function runInit(flags: Record<string, unknown>): Promise<void>;
+export interface InitResult {
+    apiKey: string;
+    tenantName: string;
+    phases: InitPhaseResult[];
+    setupPlan: InitSetupAction[];
+}
+export interface InitPhaseResult {
+    id: 'welcome' | 'auth' | 'workspace' | 'harness' | 'plan' | 'apply' | 'validate';
+    title: string;
+    status: 'completed' | 'skipped' | 'warning';
+    details?: string;
+}
+export interface InitSetupAction {
+    category: 'sdk' | 'harness' | 'hooks' | 'prompts' | 'skills' | 'ci-cd' | 'validation';
+    title: string;
+    status: 'planned' | 'applied' | 'skipped' | 'manual';
+    approved: boolean;
+    files: string[];
+    command?: string;
+    reason?: string;
+}
+export interface InitProgressEvent {
+    phase: InitPhaseResult['id'];
+    message: string;
+    status?: InitPhaseResult['status'];
+}
+export interface InitRunOptions {
+    onEvent?: (event: InitProgressEvent) => void;
+}
+export declare function runInit(flags: Record<string, unknown>, options?: InitRunOptions): Promise<InitResult>;
 //# sourceMappingURL=index.d.ts.map

package/dist/init/index.js

@@ -1,16 +1,55 @@
 // src/init/index.ts — Full moda init wizard orchestrator
-import { select } from '@inquirer/prompts';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { confirm, select } from '@inquirer/prompts';
 import { login, loadToken } from '../auth.js';
 import { selectTenantAndCreateKey } from './tenant.js';
 import { detectAgents } from './mcp.js';
 import { installRules } from './rules.js';
-export async function runInit(flags) {
-    const yes = flags.yes === true || flags.y === true;
-    console.log('\n  Moda — LLM Observability for Agents\n');
-    // Step 1: Authentication
-    console.log('  Step 1/3: Authentication');
+import { initPrompts } from '../prompts.js';
+import { pullSkills } from '../skills.js';
+// Coding-agent capture is temporarily disabled — see the hooks phase below.
+// import { runHooksInstall } from '../workspace.js';
+import { SDK_GUIDE_PATH, writeSdkIntegrationGuide } from './sdk-guide.js';
+import { createCommandContext } from '../command-context.js';
+import { CliInputError } from '../errors.js';
+import { runHarnessCommand } from '../harness.js';
+import { runDoctorCommand } from '../doctor.js';
+import { renderInitBanner, renderInitComplete, renderInitNote, renderInitSetupPlan, renderInitStep, } from '../tui.js';
+export async function runInit(flags, options = {}) {
+    const explicitYes = flags.yes === true ||
+        flags.yes === 'true' ||
+        flags.y === true ||
+        flags.y === 'true';
+    const json = flags.json === true || flags.json === 'true';
+    const agent = flags.agent === true || flags.agent === 'true';
+    const human = !json && !agent;
+    const yes = explicitYes || json || agent;
+    const phases = [];
+    const log = (message) => {
+        if (human)
+            console.log(message);
+    };
+    // `warn` is only used by the temporarily-disabled hooks phase below; keep the
+    // underscore-prefixed binding so re-enabling it is a rename away.
+    const _warn = (message) => {
+        if (human)
+            console.error(message);
+    };
+    const emit = (phase, message, status) => {
+        options.onEvent?.({ phase, message, status });
+    };
+    log(renderInitBanner());
+    log(renderInitStep(1, 7, 'Welcome', 'No environment variable files are written. File changes are listed before completion.'));
+    emit('welcome', 'Onboarding this project as a Moda agent harness.', 'completed');
+    phases.push({ id: 'welcome', title: 'Welcome', status: 'completed' });
+    // Step 2: Authentication
+    log(renderInitStep(2, 7, 'Authentication'));
     let token = loadToken();
     if (!token) {
+        if (json || agent) {
+            throw new CliInputError('Browser authentication is required before non-interactive init can continue.', 'Run `moda init` in a human terminal first, or provide an existing cached auth session.');
+        }
         let action = 'login';
         if (!yes) {
             action = await select({
@@ -21,32 +60,359 @@ export async function runInit(flags) {
                 ],
             });
         }
-        console.log(`  Opening browser to ${action === 'signup' ? 'sign up' : 'log in'}...`);
+        log(renderInitNote(`Opening browser to ${action === 'signup' ? 'sign up' : 'log in'}...`, 'warning'));
+        emit('auth', `Opening browser to ${action}.`);
         token = await login(action);
-        console.log('  Authentication successful');
+        log(renderInitNote('Authentication successful'));
     }
     else {
-        console.log('  Already authenticated (cached token)');
+        log(renderInitNote('Already authenticated (cached token)'));
+    }
+    emit('auth', 'Authentication complete.', 'completed');
+    phases.push({ id: 'auth', title: 'Authentication', status: 'completed' });
+    // Step 3: Tenant + API Key
+    log(renderInitStep(3, 7, 'Workspace & Profile'));
+    emit('workspace', 'Selecting workspace and creating API key.');
+    const { apiKey, tenantName } = await selectTenantAndCreateKey();
+    log(renderInitNote(`Active workspace: ${tenantName}`));
+    emit('workspace', `Active workspace: ${tenantName}`, 'completed');
+    phases.push({ id: 'workspace', title: 'Workspace & Profile', status: 'completed', details: tenantName });
+    // Step 4: Harness analyst report.
+    log(renderInitStep(4, 7, 'Harness Discovery', 'Moda Analyst investigates the harness and writes cited local artifacts.'));
+    emit('harness', 'Running Moda Analyst harness discovery.');
+    const harnessResult = await runHarnessCommand(createCommandContext({
+        command: 'harness',
+        positional: 'analyze',
+        positionals: ['analyze'],
+        flags: commandFlags({
+            summary: true,
+            yes,
+            json: json || agent,
+            agent,
+            analyst: stringFlag(flags.analyst) ?? 'auto',
+            quiet: true,
+            progress: true,
+            'no-telemetry': true,
+        }),
+    }));
+    if (harnessResult.exitCode !== 0) {
+        throw new CliInputError('Moda Analyst produced a harness report that did not pass validation.', 'Review .moda/harness-report-validation.json, then rerun `moda init --analyst=claude|cursor|codex` or `moda harness analyze --analyst=local-scan --summary`.');
     }
-    // Step 2: Tenant + API Key
-    console.log('\n  Step 2/3: Select Organization');
-    const { tenantName } = await selectTenantAndCreateKey();
-    // Step 3: Install SDK integration guide for coding agents
-    console.log('\n  Step 3/3: Install SDK Guide');
+    log(renderInitNote('Wrote or verified .moda/harness-report.json, .moda/harness.json, and .moda/HARNESS.md'));
+    if (human)
+        printHarnessDetectionSummary();
+    emit('harness', 'Harness discovery complete.', 'completed');
+    phases.push({ id: 'harness', title: 'Harness Discovery', status: 'completed' });
+    // Step 5: Setup plan
+    log(renderInitStep(5, 7, 'Setup Plan', 'Every write/sync action is explicit before it is applied.'));
+    const setupPlan = buildSetupPlan({
+        // Coding-agent capture is temporarily disabled; never prompt for or install trace hooks.
+        // installHooks: await shouldIngestCodingAgentTraces(flags, yes),
+        installHooks: false,
+        installSdkGuide: await shouldCreateSdkGuide(flags, yes),
+        configureCiCd: await shouldConfigureCiCd(flags, yes),
+    });
+    log(renderInitSetupPlan(setupPlan));
+    emit('plan', 'Setup plan ready.', 'completed');
+    phases.push({ id: 'plan', title: 'Setup Plan', status: 'completed' });
+    // Step 6: Apply approved setup changes.
+    log(renderInitStep(6, 7, 'Apply Approved Changes'));
+    emit('apply', 'Applying approved setup changes.');
+    // Coding-agent capture is temporarily disabled; the hooks phase never runs.
+    // const ingestCodingAgentTraces = setupPlan.find((action) => action.category === 'hooks')?.approved === true;
+    const ingestCodingAgentTraces = false;
+    // if (ingestCodingAgentTraces) {
+    //   try {
+    //     await runHooksInstall({
+    //       command: 'hooks',
+    //       positional: 'install',
+    //       positionals: ['install'],
+    //       flags: { agent: 'all', ...(human ? {} : { json: 'true' }) },
+    //     });
+    //   } catch (err) {
+    //     const message = err instanceof Error ? err.message : String(err);
+    //     warn(renderInitNote(`hook/telemetry install failed: ${message}`, 'warning'));
+    //     warn('  Run `moda hooks install --agent=all` manually to enable traces.');
+    //   }
+    // } else {
+    //   log(renderInitNote('Skipped coding-agent trace ingestion', 'skipped'));
+    // }
     const agents = detectAgents();
     if (agents.length > 0) {
-        console.log(`  Detected: ${agents.join(', ')}`);
-        await installRules(agents);
+        log(renderInitNote(`Detected coding agents: ${agents.join(', ')}`));
+        await installRules(agents, { yes, silent: !human });
+        // Pull any skills the pipeline has already generated for this tenant into
+        // the local agent skill dirs. Best-effort: a brand-new tenant has none yet,
+        // and a transient ingest/network error must not fail setup.
+        try {
+            const pulled = await pullSkills({ silent: true });
+            if (pulled.wrote + pulled.updated > 0) {
+                log(renderInitNote(`Pulled ${pulled.wrote + pulled.updated} learned skill(s) into agent skills`));
+            }
+        }
+        catch {
+            // Silent: skills are additive; never block init on them.
+        }
+    }
+    else {
+        log(renderInitNote('No coding agents detected, skipping', 'skipped'));
+    }
+    await initPrompts({ silent: true });
+    log(renderInitNote('Created or verified .moda/prompts.yml'));
+    const installSdkGuide = setupPlan.find((action) => action.category === 'sdk')?.approved === true;
+    if (installSdkGuide) {
+        const guidePath = writeSdkIntegrationGuide();
+        log(renderInitNote(`Wrote ${guidePath}`));
+        markApplied(setupPlan, 'sdk');
     }
     else {
-        console.log('  No coding agents detected, skipping');
+        log(renderInitNote('Skipped SDK integration guide', 'skipped'));
+        markApplied(setupPlan, 'sdk', 'User skipped SDK integration guide.');
+    }
+    const configureCiCd = setupPlan.find((action) => action.category === 'ci-cd')?.approved === true;
+    if (configureCiCd) {
+        const workflowPath = writeCiCdWorkflow();
+        log(renderInitNote(`Wrote ${workflowPath}`));
+        markApplied(setupPlan, 'ci-cd');
     }
+    log(renderInitNote('Reusing approved Step 4 harness report; no second analyst run needed'));
+    markApplied(setupPlan, 'harness');
+    markApplied(setupPlan, 'hooks', ingestCodingAgentTraces ? undefined : 'Coding-agent trace capture is temporarily unavailable.');
+    markApplied(setupPlan, 'prompts');
+    markApplied(setupPlan, 'skills');
+    emit('apply', 'Approved changes applied.', 'completed');
+    phases.push({ id: 'apply', title: 'Apply Approved Changes', status: 'completed' });
+    log(renderInitStep(7, 7, 'Validate', 'Running local doctor checks so the setup leaves a clear state.'));
+    emit('validate', 'Running local Moda doctor diagnostics.');
+    await runDoctorCommand(createCommandContext({
+        command: 'doctor',
+        positional: undefined,
+        positionals: [],
+        flags: commandFlags({
+            json: true,
+            quiet: true,
+            offline: true,
+            'no-telemetry': true,
+        }),
+    }));
+    markApplied(setupPlan, 'validation');
+    log(renderInitNote('Local validation checks completed'));
+    emit('validate', 'Local validation checks complete.', 'completed');
+    phases.push({ id: 'validate', title: 'Validate', status: 'completed' });
     // Done
-    console.log(`\n  Setup complete for ${tenantName}!\n`);
-    console.log('  Now paste this into your coding agent to integrate Moda:\n');
-    console.log('    Integrate the Moda SDK into this project. Follow the Moda SDK');
-    console.log('    integration guide in the project rules.\n');
-    console.log('  Dashboard: https://moda.dev');
-    console.log('');
+    log(renderInitComplete({
+        tenantName,
+        filesChanged: changedFiles(setupPlan),
+        skipped: setupPlan.filter((item) => item.status === 'skipped' || item.status === 'manual'),
+        phases,
+    }));
+    return { apiKey, tenantName, phases, setupPlan };
+}
+function buildSetupPlan(options) {
+    return [
+        {
+            category: 'harness',
+            title: 'Analyze harness and write cited Moda report',
+            status: 'planned',
+            approved: true,
+            files: [
+                '.moda/harness-report.json',
+                '.moda/harness-report-validation.json',
+                '.moda/HARNESS_REPORT.md',
+                '.moda/harness.json',
+                '.moda/HARNESS.md',
+            ],
+            command: 'moda harness analyze --analyst=auto --summary',
+        },
+        {
+            category: 'hooks',
+            title: 'Install coding-agent trace hooks',
+            status: options.installHooks ? 'planned' : 'skipped',
+            approved: options.installHooks,
+            files: ['~/.claude/settings.json', '~/.codex/hooks.json', '~/.cursor/hooks.json'],
+            command: 'moda hooks install --agent=all',
+            reason: options.installHooks ? undefined : 'Coding-agent trace capture is temporarily unavailable.',
+        },
+        {
+            category: 'prompts',
+            title: 'Initialize prompt registry manifest',
+            status: 'planned',
+            approved: true,
+            files: ['.moda/prompts.yml'],
+            command: 'moda prompts init',
+        },
+        {
+            category: 'skills',
+            title: 'Pull approved Moda skills when available',
+            status: 'planned',
+            approved: true,
+            files: ['.claude/skills', '.cursor/rules'],
+            command: 'moda skills pull',
+        },
+        {
+            category: 'sdk',
+            title: 'Write SDK integration guide',
+            status: options.installSdkGuide ? 'planned' : 'manual',
+            approved: options.installSdkGuide,
+            files: [SDK_GUIDE_PATH],
+            command: 'open .moda/SDK_INTEGRATION.md',
+            reason: options.installSdkGuide
+                ? 'Guide only; package installs and source edits remain human-approved/manual.'
+                : 'SDK package installation and code instrumentation stay human-approved/manual.',
+        },
+        {
+            category: 'ci-cd',
+            title: 'CI/CD validation workflow',
+            status: options.configureCiCd ? 'planned' : 'manual',
+            approved: options.configureCiCd,
+            files: ['.github/workflows/moda-validation.yml'],
+            command: 'moda doctor --online --json',
+            reason: options.configureCiCd ? undefined : 'No CI/CD files are changed until a project-specific plan is approved.',
+        },
+        {
+            category: 'validation',
+            title: 'Run local Moda doctor diagnostics',
+            status: 'planned',
+            approved: true,
+            files: [],
+            command: 'moda doctor',
+        },
+    ];
+}
+function markApplied(setupPlan, category, skipReason) {
+    const action = setupPlan.find((item) => item.category === category);
+    if (!action)
+        return;
+    if (skipReason) {
+        action.status = 'skipped';
+        action.reason = skipReason;
+        return;
+    }
+    if (action.approved)
+        action.status = 'applied';
+}
+function changedFiles(setupPlan) {
+    return [...new Set(setupPlan
+            .filter((action) => action.status === 'applied')
+            .flatMap((action) => action.files))].filter((file) => !file.includes('.env'));
+}
+function writeCiCdWorkflow(cwd = process.cwd()) {
+    const relativePath = '.github/workflows/moda-validation.yml';
+    const path = join(cwd, relativePath);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${[
+        'name: Moda Validation',
+        '',
+        'on:',
+        '  pull_request:',
+        '  push:',
+        '    branches: [main]',
+        '',
+        'jobs:',
+        '  moda-doctor:',
+        '    runs-on: ubuntu-latest',
+        '    env:',
+        '      MODA_API_KEY: ${{ secrets.MODA_API_KEY }}',
+        '      MODA_TENANT_ID: ${{ secrets.MODA_TENANT_ID }}',
+        '    steps:',
+        '      - uses: actions/checkout@v4',
+        '      - uses: actions/setup-node@v4',
+        '        with:',
+        '          node-version: 22',
+        '      - name: Validate Moda setup',
+        '        run: npx -y @moda-ai/cli@latest moda doctor --online --json',
+        '',
+    ].join('\n')}`);
+    return relativePath;
+}
+function printHarnessDetectionSummary(cwd = process.cwd()) {
+    const manifestPath = join(cwd, '.moda', 'harness.json');
+    if (!existsSync(manifestPath))
+        return;
+    try {
+        const graph = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        const frameworkNames = (graph.agentFrameworks ?? [])
+            .map((framework) => typeof framework.name === 'string' ? framework.name : undefined)
+            .filter((name) => Boolean(name));
+        const providerNames = (graph.modelProviders ?? [])
+            .map((provider) => typeof provider.name === 'string' ? provider.name : undefined)
+            .filter((name) => Boolean(name));
+        console.log(`  Detected harness: ${(graph.runtimeAgents ?? []).length} runtime agent(s), ` +
+            `${(graph.artifacts ?? []).length} artifact(s), ${(graph.relationships ?? []).length} relationship(s)`);
+        if (frameworkNames.length > 0)
+            console.log(`  Frameworks: ${frameworkNames.join(', ')}`);
+        if (providerNames.length > 0)
+            console.log(`  Model providers: ${providerNames.join(', ')}`);
+    }
+    catch {
+        console.log('  Detected harness summary is available in .moda/HARNESS.md');
+    }
+}
+function commandFlags(flags) {
+    return Object.fromEntries(Object.entries(flags)
+        .filter(([, value]) => value !== undefined && value !== false)
+        .map(([key, value]) => [key, value === true ? 'true' : String(value)]));
+}
+function stringFlag(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
+}
+// Coding-agent capture is temporarily disabled; restore this prompt with the hooks phase.
+// async function shouldIngestCodingAgentTraces(
+//   flags: Record<string, unknown>,
+//   yes: boolean,
+// ): Promise<boolean> {
+//   const explicit = parseOptionalBoolean(flagValue(flags, 'coding-agent-traces', 'coding_agent_traces'));
+//   if (explicit !== undefined) return explicit;
+//   if (isTruthyFlag(flagValue(flags, 'no-coding-agent-traces', 'no_coding_agent_traces'))) return false;
+//   if (yes) return true;
+//   return confirm({
+//     message: 'Ingest coding-agent traces for Claude Code, Codex, and Cursor?',
+//     default: true,
+//   });
+// }
+async function shouldConfigureCiCd(flags, yes) {
+    const explicit = parseOptionalBoolean(flagValue(flags, 'ci-cd', 'ci_cd', 'ci'));
+    if (explicit !== undefined)
+        return explicit;
+    if (isTruthyFlag(flagValue(flags, 'no-ci-cd', 'no_ci_cd')))
+        return false;
+    if (yes)
+        return false;
+    return confirm({
+        message: 'Create a GitHub Actions workflow for Moda validation?',
+        default: false,
+    });
+}
+async function shouldCreateSdkGuide(flags, yes) {
+    const explicit = parseOptionalBoolean(flagValue(flags, 'sdk-guide', 'sdk_guide', 'sdk'));
+    if (explicit !== undefined)
+        return explicit;
+    if (isTruthyFlag(flagValue(flags, 'no-sdk-guide', 'no_sdk_guide')))
+        return false;
+    if (yes)
+        return true;
+    return confirm({
+        message: 'Create a Moda SDK integration guide? (No packages installed, no source files edited.)',
+        default: true,
+    });
+}
+function parseOptionalBoolean(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === true || value === 'true' || value === '1' || value === 'yes')
+        return true;
+    if (value === false || value === 'false' || value === '0' || value === 'no')
+        return false;
+    return undefined;
+}
+function isTruthyFlag(value) {
+    return value === true || value === 'true' || value === '1' || value === 'yes';
+}
+function flagValue(flags, ...keys) {
+    for (const key of keys) {
+        if (flags[key] !== undefined)
+            return flags[key];
+    }
+    return undefined;
 }
 //# sourceMappingURL=index.js.map

package/dist/init/rules.d.ts

@@ -1,2 +1,6 @@
-export declare function installRules(detectedAgents: string[]): Promise<void>;
+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

@@ -15,10 +15,6 @@ import { confirm } from '@inquirer/prompts';
 const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
 const SKILLS_SOURCE_DIR = join(PACKAGE_ROOT, 'skills');
 const SKILLS = [
-    {
-        id: 'integrate-moda',
-        label: 'integrate-moda — instrument this project with the Moda SDK',
-    },
     {
         id: 'moda-cli',
         label: 'moda-cli — let coding agents query Moda analytics via the CLI',
@@ -53,7 +49,7 @@ const ADAPTERS = {
 // 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;
-function claudeSkillToCursorRule(skillContent) {
+export function claudeSkillToCursorRule(skillContent) {
     const match = FRONTMATTER_RE.exec(skillContent);
     if (!match) {
         // Body without frontmatter — pass through untouched rather than guess.
@@ -101,22 +97,26 @@ function installSkillForAgent(skill, adapter, content) {
     }
 }
 // --- Public entry point ---
-export async function installRules(detectedAgents) {
+export async function installRules(detectedAgents, options = {}) {
     const adapters = detectedAgents
         .map((a) => ADAPTERS[a])
         .filter((a) => a !== undefined);
     if (adapters.length === 0) {
-        console.log('  No supported coding agents detected');
+        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 = await confirm({
-        message: `Install Moda skills for ${agentList}?${skillList}\n  Continue?`,
-        default: true,
-    });
+    const shouldInstall = options.yes
+        ? true
+        : await confirm({
+            message: `Install Moda skills for ${agentList}?${skillList}\n  Continue?`,
+            default: true,
+        });
     if (!shouldInstall) {
-        console.log('  Skipped');
+        if (!options.silent)
+            console.log('  Skipped');
         return;
     }
     let wrote = 0;
@@ -137,15 +137,20 @@ export async function installRules(detectedAgents) {
             const outcome = installSkillForAgent(skill, adapter, content);
             switch (outcome.status) {
                 case 'wrote':
-                    console.log(`  ${outcome.agent}: wrote ${outcome.relativePath}`);
+                    if (!options.silent)
+                        console.log(`  ${outcome.agent}: wrote ${outcome.relativePath}`);
                     wrote++;
                     break;
                 case 'exists':
-                    console.log(`  ${outcome.agent}: ${outcome.relativePath} already exists — skipping`);
+                    if (!options.silent) {
+                        console.log(`  ${outcome.agent}: ${outcome.relativePath} already exists — skipping`);
+                    }
                     skipped++;
                     break;
                 case 'failed':
-                    console.error(`  ${outcome.agent}: failed to write ${outcome.relativePath} — ${outcome.error}`);
+                    if (!options.silent) {
+                        console.error(`  ${outcome.agent}: failed to write ${outcome.relativePath} — ${outcome.error}`);
+                    }
                     failed++;
                     break;
             }
@@ -159,7 +164,8 @@ export async function installRules(detectedAgents) {
         .filter(Boolean)
         .join(', ');
     if (summary) {
-        console.log(`  Done — ${summary}`);
+        if (!options.silent)
+            console.log(`  Done — ${summary}`);
     }
 }
 //# sourceMappingURL=rules.js.map

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

@@ -0,0 +1,3 @@
+export declare const SDK_GUIDE_PATH = ".moda/SDK_INTEGRATION.md";
+export declare function writeSdkIntegrationGuide(cwd?: string): string;
+//# sourceMappingURL=sdk-guide.d.ts.map