@moda-ai/cli 1.22.0 → 1.22.2

package/dist/skills.js

@@ -1,777 +0,0 @@
-// 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 { execFileSync } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from 'node:fs';
-import { basename, dirname, join, relative } from 'node:path';
-import { callControlAPI } from './api-client.js';
-import { createCommandContext } from './command-context.js';
-import { resolveApiKey, resolveIngestUrl, resolveTenantId } from './config.js';
-import { claudeSkillToCursorRule } from './init/rules.js';
-import { detectAgents } from './init/mcp.js';
-import { SKILL_SOURCE_HARNESS, SKILL_SOURCE_INTEGRATION_BUNDLED, pruneManagedSkillPaths, readSkillsManifest, writeSkillsManifest, } from './skills-manifest.js';
-import { CliInputError } from './errors.js';
-const SKILLS_REQUEST_TIMEOUT_MS = 15_000;
-const VALID_STATUSES = new Set(['approved', 'proposed', 'all']);
-const SKILL_PROPOSALS_MANIFEST_PATH = join('.moda', 'skill-proposals.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,
-    };
-}
-/**
- * Authenticated GET against the ingest worker's `/v1/skills/runs` surface.
- * Returns `{ status, body }` so callers can treat 404 (no such run) as data;
- * every other non-2xx throws.
- */
-async function skillRunsRequest(url) {
-    const apiKey = resolveApiKey();
-    if (!apiKey) {
-        throw new CliInputError('No Moda API key found. Run `moda init` first (or set MODA_API_KEY).');
-    }
-    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 ${url} (${message})`);
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-    const text = await response.text().catch(() => '');
-    if (!response.ok && response.status !== 404) {
-        throw new Error(`Failed to fetch run status (HTTP ${response.status}): ${text.slice(0, 200)}`);
-    }
-    let body = {};
-    try {
-        body = text ? JSON.parse(text) : {};
-    }
-    catch {
-        body = {};
-    }
-    return { status: response.status, body };
-}
-/**
- * Resolve a run's status + recent events. Without a run id, the tenant's
- * latest run (`GET /v1/skills/runs?limit=1`) is used; the detail form
- * (`GET /v1/skills/runs/:id`) always supplies the event breadcrumbs.
- */
-async function fetchSkillRunStatus(runId) {
-    const ingestUrl = resolveIngestUrl().replace(/\/$/, '');
-    let resolvedRunId = runId;
-    if (!resolvedRunId) {
-        const list = await skillRunsRequest(`${ingestUrl}/v1/skills/runs?limit=1`);
-        const listBody = list.body;
-        const latest = Array.isArray(listBody.runs) ? listBody.runs[0] : undefined;
-        if (!latest)
-            return { run: null, events: [] };
-        resolvedRunId = latest.generation_run_id;
-        // Defensive: a row without an id can still be shown, just without events.
-        if (!resolvedRunId)
-            return { run: latest, events: [] };
-    }
-    const detail = await skillRunsRequest(`${ingestUrl}/v1/skills/runs/${encodeURIComponent(resolvedRunId)}`);
-    if (detail.status === 404) {
-        if (runId) {
-            throw new CliInputError(`No skill generation run found with id '${runId}'`);
-        }
-        return { run: null, events: [] };
-    }
-    const detailBody = detail.body;
-    return {
-        run: detailBody.run ?? null,
-        events: Array.isArray(detailBody.events) ? detailBody.events : [],
-    };
-}
-const STATUS_HUMAN_EVENT_LIMIT = 10;
-/** Human rendering for `moda skills status` (key: value lines, gen-style). */
-function formatRunStatusHuman(run, events) {
-    const counters = run.counters ?? {};
-    const lines = [
-        run.generation_run_id && `run: ${run.generation_run_id}`,
-        `status: ${run.status || 'unknown'}`,
-        run.current_stage && `stage: ${run.current_stage}`,
-        run.outcome && `outcome: ${run.outcome}`,
-        `processed: ${Number(counters.sessions_processed ?? 0)}`,
-        `failed: ${Number(counters.sessions_failed ?? 0)}`,
-        Number(counters.distilled_skills_generated ?? 0) > 0
-            && `distilled: ${Number(counters.distilled_skills_generated ?? 0)}`,
-        Number(counters.skills_indexed ?? 0) > 0
-            && `indexed: ${Number(counters.skills_indexed ?? 0)}`,
-        (run.generated_skill_ids?.length ?? 0) > 0
-            && `skills: ${(run.generated_skill_ids ?? []).join(', ')}`,
-        run.error && `error: ${run.error}`,
-        run.started_at && `started: ${run.started_at}`,
-        run.updated_at && `updated: ${run.updated_at}`,
-    ].filter(Boolean);
-    if (events.length > 0) {
-        lines.push('recent events (newest first):');
-        for (const event of events.slice(0, STATUS_HUMAN_EVENT_LIMIT)) {
-            lines.push(`  ${[event.created_at, event.level, event.stage, event.message]
-                .filter(Boolean)
-                .join('  ')}`);
-        }
-    }
-    return lines.join('\n');
-}
-/**
- * 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);
-    // A release change only invalidates harness-generated skills. Paths owned
-    // by integration-bundled records are CLI-managed and must never be pruned
-    // by a harness release change (cross-source regression guard).
-    const preservedIntegrationRecords = (previousManifest?.records ?? []).filter((record) => record.source === SKILL_SOURCE_INTEGRATION_BUNDLED);
-    if (previousManifest &&
-        previousManifest.managedPaths.length > 0 &&
-        previousManifest.releaseKey !== fetched.releaseKey) {
-        const integrationPaths = new Set(preservedIntegrationRecords.flatMap((record) => record.paths));
-        const harnessPaths = previousManifest.managedPaths.filter((path) => !integrationPaths.has(path));
-        if (harnessPaths.length > 0) {
-            summary.pruned = pruneManagedSkillPaths(cwd, harnessPaths, 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),
-                source: SKILL_SOURCE_HARNESS,
-                paths,
-            });
-        }
-    }
-    writeSkillsManifest(cwd, manifestHeaderFor(fetched), [...records, ...preservedIntegrationRecords]);
-    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;
-    }
-}
-const SKILLS_DIR = join('.claude', 'skills');
-const SKILL_FILE = 'SKILL.md';
-const MAX_SKILL_WALK_DEPTH = 4;
-/**
- * Push locally-authored `.claude/skills/**\/SKILL.md` files up to Moda via
- * `POST /api/skills/sync`. Modeled on `runPromptSync`: returns the synced list
- * without printing so callers (e.g. `moda init`) control their own output.
- * `moda skills sync` wraps this with JSON output.
- *
- * Skills that Moda itself manages — those previously pulled/generated (tracked
- * in `.moda/skills.yml`) and the shipped `moda-cli` skill — are excluded so we
- * only push skills the user authored.
- */
-export async function runSkillSync(flags = {}, profileOptions = {}, options = {}) {
-    const cwd = options.cwd ?? process.cwd();
-    const dryRun = flags['dry-run'] === 'true';
-    const skills = discoverLocalSkills(cwd);
-    if (skills.length === 0) {
-        return { synced: [], dryRun };
-    }
-    const sourceCommit = getGitCommit(cwd);
-    const response = (await callControlAPI('/skills/sync', {
-        method: 'POST',
-        body: JSON.stringify({
-            skills: skills.map((skill) => ({
-                key: skill.key,
-                name: skill.name,
-                description: skill.description,
-                skillMd: skill.skillMd,
-                sourcePath: skill.sourcePath,
-                contentHash: skill.contentHash,
-                sourceCommit,
-            })),
-            sourceCommit,
-            dryRun,
-        }),
-    }, profileOptions));
-    return { synced: response.synced ?? [], dryRun };
-}
-/**
- * Discover user-authored skills under `.claude/skills/`. Excludes Moda-managed
- * skills (the `.moda/skills.yml` managed paths and the shipped `moda-cli`
- * skill) and validates each directory key.
- */
-function discoverLocalSkills(cwd) {
-    const skillsRoot = join(cwd, SKILLS_DIR);
-    if (!existsSync(skillsRoot))
-        return [];
-    const managed = new Set(managedSkillPaths(cwd));
-    const skills = [];
-    for (const absPath of walkSkillFiles(skillsRoot, 0)) {
-        const sourcePath = relative(cwd, absPath).replace(/\\/g, '/');
-        if (managed.has(sourcePath))
-            continue;
-        const key = basename(dirname(absPath));
-        // Never re-upload Moda's own shipped skill; only accept plain identifiers.
-        if (key === 'moda-cli' || !/^[A-Za-z0-9_-]+$/.test(key))
-            continue;
-        let content;
-        try {
-            content = readFileSync(absPath, 'utf8');
-        }
-        catch {
-            continue;
-        }
-        if (!content.trim())
-            continue;
-        const { name, description } = parseSkillFrontmatter(content, key);
-        skills.push({
-            key,
-            name,
-            description,
-            skillMd: content,
-            sourcePath,
-            contentHash: sha256(content),
-        });
-    }
-    return skills.sort((a, b) => a.key.localeCompare(b.key));
-}
-/** Managed SKILL.md paths recorded by a previous `moda skills pull`. */
-function managedSkillPaths(cwd) {
-    const manifest = readSkillsManifest(cwd);
-    if (!manifest)
-        return [];
-    return manifest.managedPaths.filter((path) => path.startsWith('.claude/skills/') && path.endsWith('/SKILL.md'));
-}
-/** Recursively find `SKILL.md` files, never following symlinks. */
-function walkSkillFiles(dir, depth) {
-    if (depth > MAX_SKILL_WALK_DEPTH)
-        return [];
-    let entries;
-    try {
-        entries = readdirSync(dir);
-    }
-    catch {
-        return [];
-    }
-    const files = [];
-    for (const entry of entries) {
-        const fullPath = join(dir, entry);
-        let stat;
-        try {
-            stat = lstatSync(fullPath);
-        }
-        catch {
-            continue;
-        }
-        if (stat.isSymbolicLink())
-            continue;
-        if (stat.isDirectory()) {
-            files.push(...walkSkillFiles(fullPath, depth + 1));
-        }
-        else if (stat.isFile() && entry === SKILL_FILE) {
-            files.push(fullPath);
-        }
-    }
-    return files;
-}
-/** Pull `name`/`description` from a SKILL.md YAML frontmatter block. */
-function parseSkillFrontmatter(raw, fallbackKey) {
-    let name = fallbackKey;
-    let description;
-    if (raw.startsWith('---')) {
-        const end = raw.indexOf('\n---', 3);
-        if (end !== -1) {
-            const frontmatter = raw.slice(3, end);
-            const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
-            const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
-            if (nameMatch)
-                name = stripQuotes(nameMatch[1].trim()) || fallbackKey;
-            if (descMatch)
-                description = stripQuotes(descMatch[1].trim()) || undefined;
-        }
-    }
-    return { name, description };
-}
-function stripQuotes(value) {
-    return value.replace(/^["']|["']$/g, '');
-}
-function getGitCommit(cwd) {
-    try {
-        return execFileSync('git', ['rev-parse', 'HEAD'], {
-            cwd,
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-        }).trim();
-    }
-    catch {
-        return undefined;
-    }
-}
-async function fetchSkillProposals(flags, profileOptions = {}) {
-    const params = new URLSearchParams();
-    if (flags['generation-run-id'])
-        params.set('generationRunId', flags['generation-run-id']);
-    const status = flags.status ?? 'ready_for_pr';
-    if (status !== 'all')
-        params.set('status', status);
-    if (flags['tenant-id'])
-        params.set('tenantId', flags['tenant-id']);
-    const suffix = params.toString() ? `?${params.toString()}` : '';
-    const response = (await callControlAPI(`/skills/proposals${suffix}`, { method: 'GET' }, profileOptions));
-    return Array.isArray(response.proposals) ? response.proposals : [];
-}
-async function applySkillProposal(proposalId, flags, profileOptions = {}, options = {}) {
-    const cwd = options.cwd ?? process.cwd();
-    const params = new URLSearchParams();
-    if (flags['tenant-id'])
-        params.set('tenantId', flags['tenant-id']);
-    const suffix = params.toString() ? `?${params.toString()}` : '';
-    const proposal = (await callControlAPI(`/skills/proposals/${encodeURIComponent(proposalId)}${suffix}`, { method: 'GET' }, profileOptions));
-    if (!proposal.skillMd?.trim()) {
-        throw new CliInputError(`Proposal ${proposalId} does not include SKILL.md content`);
-    }
-    const safeId = safeSkillId(proposal.skillId);
-    const relativePath = `.claude/skills/${safeId}/SKILL.md`;
-    const writeStatus = writeIfChanged(join(cwd, relativePath), proposal.skillMd);
-    if (writeStatus === 'failed') {
-        throw new Error(`Failed to write ${relativePath}`);
-    }
-    writeSkillProposalManifest(cwd, proposal, relativePath);
-    let acknowledged = true;
-    let ackError;
-    try {
-        await callControlAPI(`/skills/proposals/${encodeURIComponent(proposalId)}/mark-applied${suffix}`, {
-            method: 'POST',
-            body: JSON.stringify({ appliedBy: 'moda-cli' }),
-        }, profileOptions);
-    }
-    catch (err) {
-        acknowledged = false;
-        ackError = err instanceof Error ? err.message : String(err);
-    }
-    return {
-        proposalId,
-        skillId: proposal.skillId,
-        path: relativePath,
-        status: writeStatus,
-        acknowledged,
-        ackError,
-    };
-}
-function safeSkillId(skillId) {
-    const safeId = basename(skillId || '');
-    if (!safeId || !/^[A-Za-z0-9_-]+$/.test(safeId)) {
-        throw new CliInputError(`Invalid skill_id in proposal: ${JSON.stringify(skillId).slice(0, 80)}`);
-    }
-    return safeId;
-}
-function writeSkillProposalManifest(cwd, proposal, relativePath) {
-    const manifestPath = join(cwd, SKILL_PROPOSALS_MANIFEST_PATH);
-    mkdirSync(dirname(manifestPath), { recursive: true });
-    const existing = existsSync(manifestPath) ? readFileSync(manifestPath, 'utf8') : 'applied_proposals:\n';
-    const entry = [
-        `  - proposal_id: "${escapeYamlString(proposal.proposalId)}"`,
-        `    skill_id: "${escapeYamlString(proposal.skillId)}"`,
-        `    skill_family_id: "${escapeYamlString(proposal.skillFamilyId)}"`,
-        `    skill_version: ${Number(proposal.skillVersion || 0)}`,
-        `    generation_run_id: "${escapeYamlString(proposal.generationRunId)}"`,
-        `    clustering_run_id: "${escapeYamlString(proposal.clusteringRunId)}"`,
-        `    topic_id: "${escapeYamlString(proposal.topicId)}"`,
-        `    replay_set_id: "${escapeYamlString(proposal.replaySetId)}"`,
-        `    delta_pass_rate: ${Number(proposal.deltaPassRate || 0)}`,
-        `    path: "${escapeYamlString(relativePath)}"`,
-        `    applied_at: "${new Date().toISOString()}"`,
-    ].join('\n');
-    const prefix = existing.endsWith('\n') ? existing : `${existing}\n`;
-    writeFileSync(manifestPath, `${prefix}${entry}\n`);
-}
-function escapeYamlString(value) {
-    return String(value ?? '').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-}
-function formatProposalRate(value) {
-    return `${(Number(value || 0) * 100).toFixed(1)}%`;
-}
-export async function runSkillsCommand(input) {
-    const context = 'output' in input
-        ? input
-        : createCommandContext({
-            command: input.command,
-            positional: input.positional,
-            positionals: input.positionals,
-            flags: input.flags,
-        }, {
-            outputMode: input.flags.agent === 'true' ? 'agent' : input.flags.json === 'true' ? 'json' : 'human',
-        });
-    const sub = context.positional;
-    const positionals = context.positionals ?? (sub ? [sub] : []);
-    const flags = context.flags;
-    if (sub === 'gen') {
-        const result = await generateSkills(flags);
-        if (context.outputMode !== 'human') {
-            context.output.writeData(result, {
-                status: Number(result.sessions_failed ?? 0) > 0 ? 'error' : 'success',
-            });
-        }
-        else if (result.accepted) {
-            console.log([
-                'accepted: true',
-                result.generation_run_id && `generation_run_id: ${result.generation_run_id}`,
-                result.message && `message: ${result.message}`,
-                result.generation_run_id
-                    && `follow progress: moda skills status ${result.generation_run_id}`,
-            ].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)}`,
-                result.distillation_skipped
-                    && `distillation skipped: ${result.distillation_skip_reason || 'unknown'}`,
-            ].filter(Boolean).join('\n'));
-        }
-        return Number(result.sessions_failed ?? 0) > 0 ? 1 : 0;
-    }
-    if (sub === 'status') {
-        const runId = positionals[1] || flags['run-id'] || undefined;
-        const { run, events } = await fetchSkillRunStatus(runId);
-        if (context.outputMode !== 'human') {
-            context.output.writeData({ run, events }, { status: run?.status === 'failed' ? 'error' : 'success' });
-        }
-        else if (!run) {
-            console.log('No skill generation runs found yet. Start one with `moda skills gen`.');
-        }
-        else {
-            console.log(formatRunStatusHuman(run, events));
-        }
-        return run?.status === 'failed' ? 1 : 0;
-    }
-    if (sub === 'proposals' && positionals[1] === 'list') {
-        const proposals = await fetchSkillProposals(flags, { profile: context.profile });
-        if (flags.json === 'true') {
-            console.log(JSON.stringify({ proposals }));
-        }
-        else if (proposals.length === 0) {
-            console.log('No skill proposals found.');
-        }
-        else {
-            for (const proposal of proposals) {
-                console.log([
-                    proposal.proposalId,
-                    proposal.proposalStatus,
-                    `${proposal.skillId}@v${proposal.skillVersion}`,
-                    `delta=${formatProposalRate(proposal.deltaPassRate)}`,
-                    `baseline=${formatProposalRate(proposal.baselinePassRate)}`,
-                    `candidate=${formatProposalRate(proposal.candidatePassRate)}`,
-                    proposal.name,
-                ].filter(Boolean).join('\t'));
-            }
-        }
-        return 0;
-    }
-    if (sub === 'proposal' && positionals[1] === 'apply') {
-        const proposalId = positionals[2] || flags['proposal-id'];
-        if (!proposalId) {
-            throw new CliInputError('A proposal id is required', 'Usage: moda skills proposal apply <proposal-id>');
-        }
-        const result = await applySkillProposal(proposalId, flags, { profile: context.profile });
-        if (flags.json === 'true') {
-            console.log(JSON.stringify(result));
-        }
-        else {
-            console.log([
-                `${result.status} ${result.path}`,
-                result.acknowledged ? 'acknowledged: true' : 'acknowledged: false',
-            ].join('\n'));
-        }
-        if (!result.acknowledged) {
-            // The local SKILL.md was written, but the server still lists this
-            // proposal as ready_for_pr. Warn (to stderr so JSON stdout stays clean)
-            // and exit non-zero so the failed acknowledgement isn't silently treated
-            // as success — re-running `apply` re-attempts the acknowledgement.
-            console.error(`Warning: wrote ${result.path} but failed to acknowledge proposal ${proposalId} on the server` +
-                (result.ackError ? ` (${result.ackError})` : '') +
-                '. The proposal is still listed as ready — re-run `moda skills proposal apply` to acknowledge it.');
-            return 1;
-        }
-        return 0;
-    }
-    if (sub === 'sync') {
-        const result = await runSkillSync(flags, { profile: context.profile, env: context.env });
-        context.output.writeData({ synced: result.synced, dryRun: result.dryRun });
-        return 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] [--replay-set-id=ID] [--reprocess-segments] [--force-reprocess] [--wait] | moda skills status [run-id] | moda skills proposals list [--status=ready_for_pr] | moda skills proposal apply <proposal-id> | moda skills pull [--status=approved|proposed|all] | moda skills sync [--dry-run]');
-    }
-    const status = (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, silent: context.outputMode !== 'human' });
-    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 (context.outputMode === 'human' && summary.total > 0) {
-        console.log(`  Done — ${parts.join(', ') || 'no changes'}`);
-    }
-    if (context.outputMode !== 'human') {
-        context.output.writeData({ status, summary });
-    }
-    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,
-        replay_set_id: flags['replay-set-id'] || flags['eval-set-id'] || undefined,
-        run_clustering: flags['no-clustering'] !== 'true',
-        source: normalizeSkillSource(flags.source),
-        clustering_timeout_seconds: parsePositiveInt(flags['clustering-timeout-seconds'], 7200),
-        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 manifestHeaderFor(fetched) {
-    const release = fetched.release;
-    return {
-        tenantId: fetched.tenantId,
-        releaseKey: fetched.releaseKey,
-        statusFilter: fetched.status,
-        generationRunId: release?.generation_run_id || '',
-        generationVersion: Number(release?.generation_version || 0),
-        releasedAt: release?.released_at || '',
-    };
-}
-function sha256(input) {
-    return createHash('sha256').update(input).digest('hex');
-}
-//# sourceMappingURL=skills.js.map