@shrkcrft/cli 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/dashboard/knowledge-ask.js

@@ -0,0 +1,112 @@
+/**
+ * Read-only "ask a question over the knowledge base" for the dashboard.
+ *
+ * Deterministic retrieval (searchKnowledge) is the source of truth and ALWAYS
+ * populates `sources`. The local LLM only synthesizes a prose `answer` grounded
+ * in those entries. When no LLM is reachable, or it times out / errors, the
+ * response degrades gracefully to the retrieved entries — the GET handler never
+ * hangs and never writes anything.
+ */
+import { ERROR_CODES } from '@shrkcrft/core';
+import { AiMessageRole, selectAiProvider } from '@shrkcrft/ai';
+import { searchKnowledge } from '@shrkcrft/knowledge';
+/** Hard wall-clock bound so a slow local model can't hang a dashboard GET. */
+const ASK_TIMEOUT_MS = 15_000;
+/** How many entries to retrieve and feed as grounding. */
+const RETRIEVE_LIMIT = 8;
+/** Per-entry grounding budget (chars) — keeps the prompt small for local models. */
+const ENTRY_CHARS = 1100;
+const SYSTEM_PROMPT = [
+    'You are the SharkCraft knowledge assistant for a single repository.',
+    'Answer the question USING ONLY the knowledge entries provided below as context.',
+    'Every entry is delimited and prefixed with its id in [brackets].',
+    'Cite the entries you used by writing their id in [brackets] inline.',
+    'If the answer is not present in the provided entries, say so plainly — do not invent.',
+    'Be concise: a few short paragraphs or bullets. No preamble, no sign-off.',
+].join('\n');
+function roundScore(n) {
+    return Math.round(n * 100) / 100;
+}
+function buildMessages(question, grounding) {
+    return [
+        { role: AiMessageRole.System, content: SYSTEM_PROMPT },
+        {
+            role: AiMessageRole.User,
+            content: [
+                '# Knowledge entries',
+                grounding,
+                '',
+                '# Question',
+                question.trim(),
+                '',
+                'Answer now, citing entry ids in [brackets].',
+            ].join('\n'),
+        },
+    ];
+}
+export async function buildKnowledgeAsk(inspection, question) {
+    const startedAt = Date.now();
+    const trimmed = question.trim();
+    // 1. Deterministic retrieval — always available, the engine's ground truth.
+    const results = searchKnowledge(inspection.knowledgeEntries, {
+        query: trimmed,
+        limit: RETRIEVE_LIMIT,
+    });
+    const sources = results.map((r) => ({
+        id: r.entry.id,
+        title: r.entry.title,
+        type: String(r.entry.type),
+        score: roundScore(r.score),
+    }));
+    const degrade = (note, provider) => ({
+        question: trimmed,
+        llmAvailable: false,
+        ...(provider ? { provider } : {}),
+        answer: null,
+        degraded: true,
+        note,
+        sources,
+        citedEntryIds: [],
+        durationMs: Date.now() - startedAt,
+    });
+    // 2. Provider selection — local-only, may be absent.
+    const selection = selectAiProvider(process.env.AI_PROVIDER);
+    if (!selection.provider) {
+        return degrade('No local LLM is reachable, so this is the deterministic top-matches view. Start an Ollama daemon or set LLAMACPP_MODEL_PATH to enable synthesized answers.');
+    }
+    if (results.length === 0) {
+        return degrade('No knowledge entries matched the question.', selection.provider.id);
+    }
+    // 3. Grounded prompt from the retrieved entries.
+    const grounding = results
+        .map((r) => {
+        const body = (r.entry.summary ?? r.entry.content).slice(0, ENTRY_CHARS);
+        return `### [${r.entry.id}] ${r.entry.title}\n${body}`;
+    })
+        .join('\n\n');
+    // 4. Bounded LLM call; any failure degrades to retrieval-only.
+    const res = await selection.provider.send({
+        messages: buildMessages(trimmed, grounding),
+        maxTokens: 1024,
+        temperature: 0.2,
+        timeoutMs: ASK_TIMEOUT_MS,
+    });
+    if (!res.ok) {
+        const note = res.error.code === ERROR_CODES.TIMEOUT
+            ? 'The local LLM timed out — showing the deterministic top matches instead.'
+            : `The local LLM could not answer (${res.error.message}) — showing the deterministic top matches instead.`;
+        return degrade(note, selection.provider.id);
+    }
+    const answer = res.value.content.trim();
+    const citedEntryIds = sources.map((s) => s.id).filter((id) => answer.includes(id));
+    return {
+        question: trimmed,
+        llmAvailable: true,
+        provider: selection.provider.id,
+        answer,
+        degraded: false,
+        sources,
+        citedEntryIds,
+        durationMs: Date.now() - startedAt,
+    };
+}

package/dist/env/load-dotenv.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Minimal `.env` loader for the Node-based `shrk` binary.
+ *
+ * Bun auto-loads `.env`; Node does not. This walks from `cwd` up to the
+ * filesystem root looking for a `.env` file and merges any KEY=VALUE
+ * pairs into `process.env` — but only when the key is not already set,
+ * so an actual shell export always wins.
+ *
+ * No dependency on `dotenv`. Parser is intentionally small: lines that
+ * start with `#` are comments, blank lines are skipped, surrounding
+ * single/double quotes on the value are stripped, and escaped `\n`
+ * sequences inside double-quoted values become real newlines.
+ */
+export declare function loadDotenv(startDir: string): void;
+//# sourceMappingURL=load-dotenv.d.ts.map

package/dist/env/load-dotenv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-dotenv.d.ts","sourceRoot":"","sources":["../../src/env/load-dotenv.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAmBjD"}

package/dist/env/load-dotenv.js

@@ -0,0 +1,70 @@
+import { existsSync, readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+/**
+ * Minimal `.env` loader for the Node-based `shrk` binary.
+ *
+ * Bun auto-loads `.env`; Node does not. This walks from `cwd` up to the
+ * filesystem root looking for a `.env` file and merges any KEY=VALUE
+ * pairs into `process.env` — but only when the key is not already set,
+ * so an actual shell export always wins.
+ *
+ * No dependency on `dotenv`. Parser is intentionally small: lines that
+ * start with `#` are comments, blank lines are skipped, surrounding
+ * single/double quotes on the value are stripped, and escaped `\n`
+ * sequences inside double-quoted values become real newlines.
+ */
+export function loadDotenv(startDir) {
+    const envPath = findEnvFile(startDir);
+    if (!envPath)
+        return;
+    let body;
+    try {
+        body = readFileSync(envPath, 'utf8');
+    }
+    catch {
+        return;
+    }
+    for (const rawLine of body.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (line.length === 0 || line.startsWith('#'))
+            continue;
+        const eq = line.indexOf('=');
+        if (eq <= 0)
+            continue;
+        const key = line.slice(0, eq).trim();
+        if (!isValidKey(key))
+            continue;
+        if (process.env[key] !== undefined)
+            continue;
+        process.env[key] = unquote(line.slice(eq + 1).trim());
+    }
+}
+function isValidKey(key) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
+}
+function unquote(value) {
+    if (value.length >= 2) {
+        const first = value[0];
+        const last = value[value.length - 1];
+        if (first === '"' && last === '"') {
+            return value.slice(1, -1).replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\t/g, '\t');
+        }
+        if (first === "'" && last === "'") {
+            return value.slice(1, -1);
+        }
+    }
+    const hash = value.indexOf(' #');
+    return hash === -1 ? value : value.slice(0, hash).trimEnd();
+}
+function findEnvFile(startDir) {
+    let dir = nodePath.resolve(startDir);
+    while (true) {
+        const candidate = nodePath.join(dir, '.env');
+        if (existsSync(candidate))
+            return candidate;
+        const parent = nodePath.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}

package/dist/export/claude-commands-export.d.ts

@@ -0,0 +1,60 @@
+/**
+ * `.claude/commands/` generator — emits per-project slash commands
+ * for Claude Code. Companion to `claude-skill` export, but with a
+ * different inversion semantics:
+ *
+ *   - **claude-skill** loads rules into Claude's prompt automatically
+ *     based on description match. Passive — Claude reads the rules.
+ *   - **claude-commands** registers slash commands the USER invokes
+ *     (`/new-service`, `/check-changes`). Active — the command IS the
+ *     recipe; Claude follows it step-by-step.
+ *
+ * Generated commands fall into two buckets:
+ *
+ * **Static commands** (always present, project-agnostic recipes):
+ *   - `/follow-shrk` — short reminder of the apply-gate flow.
+ *   - `/check-changes` — runs `shrk check boundaries --changed-only`
+ *     scoped to the current diff and reports back.
+ *   - `/shrk-brief` — runs `shrk brief` and uses the output for the
+ *     current task.
+ *   - `/explain-file <path>` — per-file rules / paths / boundary
+ *     lookup (pairs with `shrk advise <path>` from Phase 3).
+ *
+ * **Per-template commands** (one per id in `sharkcraft/templates.ts`):
+ *   - `/new-<template-id>` — Claude runs `shrk gen <template-id>
+ *     <name> --dry-run --save-plan ...`, reviews the plan, and
+ *     applies via `shrk apply ... --verify-signature --validate`.
+ *
+ * Generated files are self-contained markdown — no `@shrkcrft/*`
+ * imports, no shell expansions. Each one is a complete "recipe in a
+ * file" that Claude Code reads when the user types the slash command.
+ */
+import type { ISharkcraftInspection } from '@shrkcrft/inspector';
+export interface IClaudeCommandFile {
+    /** Path relative to project root (e.g. `.claude/commands/new-service.md`). */
+    path: string;
+    /** Full markdown body, including YAML frontmatter. */
+    content: string;
+    /** The slash name users type (e.g. `new-service` → `/new-service`). */
+    slash: string;
+    /** Why this command was generated — surfaces in the dry-run summary. */
+    source: 'static' | 'template';
+}
+export interface IClaudeCommandsResult {
+    files: readonly IClaudeCommandFile[];
+}
+export interface IClaudeCommandsOptions {
+    /**
+     * Cap on the number of per-template commands to emit. Default 20.
+     * Templates are sorted by id; the first N are kept.
+     */
+    maxTemplateCommands?: number;
+}
+/**
+ * Build the full set of `.claude/commands/*.md` files for a project.
+ *
+ * Pure — caller writes the bytes. Same shape as the `synthesize-*`
+ * functions in this codebase: input inspection → output file list.
+ */
+export declare function buildClaudeCommands(inspection: ISharkcraftInspection, options?: IClaudeCommandsOptions): IClaudeCommandsResult;
+//# sourceMappingURL=claude-commands-export.d.ts.map

package/dist/export/claude-commands-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-commands-export.d.ts","sourceRoot":"","sources":["../../src/export/claude-commands-export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAEjE,MAAM,WAAW,kBAAkB;IACjC,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,MAAM,EAAE,QAAQ,GAAG,UAAU,CAAC;CAC/B;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACtC;AA0MD,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,qBAAqB,EACjC,OAAO,GAAE,sBAA2B,GACnC,qBAAqB,CAsDvB"}

package/dist/export/claude-commands-export.js

@@ -0,0 +1,276 @@
+/**
+ * `.claude/commands/` generator — emits per-project slash commands
+ * for Claude Code. Companion to `claude-skill` export, but with a
+ * different inversion semantics:
+ *
+ *   - **claude-skill** loads rules into Claude's prompt automatically
+ *     based on description match. Passive — Claude reads the rules.
+ *   - **claude-commands** registers slash commands the USER invokes
+ *     (`/new-service`, `/check-changes`). Active — the command IS the
+ *     recipe; Claude follows it step-by-step.
+ *
+ * Generated commands fall into two buckets:
+ *
+ * **Static commands** (always present, project-agnostic recipes):
+ *   - `/follow-shrk` — short reminder of the apply-gate flow.
+ *   - `/check-changes` — runs `shrk check boundaries --changed-only`
+ *     scoped to the current diff and reports back.
+ *   - `/shrk-brief` — runs `shrk brief` and uses the output for the
+ *     current task.
+ *   - `/explain-file <path>` — per-file rules / paths / boundary
+ *     lookup (pairs with `shrk advise <path>` from Phase 3).
+ *
+ * **Per-template commands** (one per id in `sharkcraft/templates.ts`):
+ *   - `/new-<template-id>` — Claude runs `shrk gen <template-id>
+ *     <name> --dry-run --save-plan ...`, reviews the plan, and
+ *     applies via `shrk apply ... --verify-signature --validate`.
+ *
+ * Generated files are self-contained markdown — no `@shrkcrft/*`
+ * imports, no shell expansions. Each one is a complete "recipe in a
+ * file" that Claude Code reads when the user types the slash command.
+ */
+// ─── Static commands (always emitted) ────────────────────────────────────────
+const STATIC_FOLLOW_SHRK = `---
+description: Reminder of the shrk apply-gate flow for this project. Use when generating or modifying code so the change passes the same boundary / validation gates the project CI uses.
+---
+
+# Follow the shrk apply-gate flow
+
+This repo uses [SharkCraft](https://github.com/shrkcrft/sharkcraft) as the
+gate for AI-written code. Skip the gate and CI will fail with the same
+errors anyway — save the round-trip.
+
+## The loop
+
+1. **Get focused context first.**
+   - Run: \`shrk task "<one-sentence task>"\` for a task packet (relevant rules + templates + verification commands).
+   - Or: \`shrk brief\` for the single-page project brief.
+
+2. **Scaffold via a template (not freehand).**
+   - List options: \`shrk templates list\`.
+   - Dry-run + save plan: \`shrk gen <template-id> <name> --dry-run --save-plan /tmp/plan.json\`.
+
+3. **Apply the plan through the CLI.**
+   - \`shrk apply /tmp/plan.json --verify-signature --validate\`.
+   - Never write files directly through MCP — MCP is read-only in this repo.
+
+4. **Verify before declaring done.**
+   - \`shrk check boundaries --changed-only\` — fails if the diff broke any layer rule.
+   - \`shrk check imports\` — fails on lazy requires / cross-package deep imports.
+   - Project verification commands (from \`shrk task\`'s \`actionHints.verificationCommands\`).
+
+## When this loop doesn't apply
+
+- Tiny changes that don't touch source files (docs, comments).
+- Read-only investigations.
+- Anything where shrk would clearly be in the way.
+
+In all other cases: **follow the loop**. The gates are short; the rework if you skip them is long.
+`;
+const STATIC_CHECK_CHANGES = `---
+description: Run shrk's boundary + import-hygiene checks on the current git diff. Use after making any file change to confirm the change didn't violate the project's architecture rules before declaring the task done.
+---
+
+# Check the current diff for boundary violations
+
+Run the diff-scoped boundary check:
+
+\`\`\`bash
+shrk check boundaries --changed-only
+\`\`\`
+
+Run the import-hygiene check on the changed files:
+
+\`\`\`bash
+shrk check imports
+\`\`\`
+
+## Interpreting the output
+
+- **Exit 0, "0 violations":** safe to declare done.
+- **Exit non-zero with violations listed:** fix each violation before continuing. Each violation has a \`suggestedFix\` line — apply it.
+- **A violation on a file you didn't change:** that's a pre-existing violation in the repo. Ignore it; the \`--changed-only\` filter only fails on violations your diff introduced.
+
+If the violations look like false positives, consult \`sharkcraft/boundaries.ts\` (the rule definitions) — don't disable them ad-hoc.
+`;
+const STATIC_SHRK_BRIEF = `---
+description: Pull shrk's single-page project brief — focused rules, paths, verification commands. Use when starting work in this codebase so you have the project's actual conventions in context before writing any code.
+---
+
+# Pull the shrk brief for this project
+
+Run the project brief:
+
+\`\`\`bash
+shrk brief
+\`\`\`
+
+This returns a compact markdown brief covering:
+- Project overview (name, frameworks, package manager).
+- Top rules that apply to code generation in this repo.
+- Path conventions (where different file types belong).
+- Action hints (commands, MCP tools, verification commands).
+- Forbidden actions (what NOT to do).
+
+For a per-task version (only the rules + paths + templates relevant to one task):
+
+\`\`\`bash
+shrk task "<one-sentence task description>"
+\`\`\`
+
+Both are read-only — no files are touched. Use the output to shape your plan before making any changes.
+`;
+const STATIC_EXPLAIN_FILE = `---
+description: Look up the rules, path conventions, and boundary rules that apply to a specific file in this codebase. Use before editing an unfamiliar file so you follow the project's per-area conventions instead of generic patterns.
+---
+
+# Explain what applies to a file in this codebase
+
+For a given file path (e.g. \`apps/users/src/profile.service.ts\`):
+
+\`\`\`bash
+shrk why <file-path>
+\`\`\`
+
+Returns:
+- Which package / layer the file belongs to.
+- Which path conventions apply (e.g. "services live in \`apps/<x>/src/services/\`").
+- Which rules are scoped to this file's path.
+- Which boundary rules constrain this file's imports.
+- Cross-references to related knowledge entries.
+
+Use this *before* editing. The output is the project's actual conventions for that area, not your guess based on the file's content.
+`;
+// ─── Per-template command generator ──────────────────────────────────────────
+/**
+ * Slugify a template id into a slash-command name. Template ids
+ * conventionally look like `typescript.service`; the slash command is
+ * `new-typescript-service` (or `new-service` if the segment after the
+ * dot is unique and shorter).
+ */
+function templateSlash(templateId) {
+    // Use the LAST dot-separated segment as the primary name —
+    // `typescript.service` → `new-service`. Falls back to the full id
+    // when there's no dot or the segment is too generic (single char).
+    const parts = templateId.split('.');
+    const tail = parts[parts.length - 1] ?? templateId;
+    const safeName = tail.length >= 3 ? tail : templateId.replace(/\./g, '-');
+    return `new-${safeName}`
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function templateCommandBody(template) {
+    const displayName = template.name ?? template.id;
+    const description = template.description
+        ? template.description.replace(/\s+/g, ' ').trim()
+        : `Scaffold a new ${displayName} using the project's actual template (\`${template.id}\`). Follows the shrk plan → apply → validate flow.`;
+    return `---
+description: ${JSON.stringify(description)}
+---
+
+# /${templateSlash(template.id)} — scaffold ${displayName}
+
+This command scaffolds a new ${displayName} using the project's actual template
+defined in \`sharkcraft/templates.ts\`. The template encodes this repo's
+conventions for path, naming, and structure — the result will match how
+the rest of the codebase is organized, not generic patterns.
+
+## The flow
+
+When the user invokes \`/${templateSlash(template.id)} <name>\`:
+
+1. **Generate a plan (no writes yet):**
+   \`\`\`bash
+   shrk gen ${template.id} <name> --dry-run --save-plan /tmp/${templateSlash(template.id)}.plan.json
+   \`\`\`
+
+2. **Read the plan back** from \`/tmp/${templateSlash(template.id)}.plan.json\` and show the user which files will be created.
+
+3. **Confirm.** Wait for the user to approve. If they want changes, adjust the plan or re-run \`shrk gen\` with different flags.
+
+4. **Apply through the validated CLI path:**
+   \`\`\`bash
+   shrk apply /tmp/${templateSlash(template.id)}.plan.json --verify-signature --validate
+   \`\`\`
+
+5. **Verify** the diff didn't break any boundary rules:
+   \`\`\`bash
+   shrk check boundaries --changed-only
+   \`\`\`
+
+## If the template doesn't fit
+
+If the user's request doesn't match the \`${template.id}\` template
+shape, fall back to:
+
+- \`shrk templates list\` — see all available templates.
+- \`shrk gen <other-template> <name> --dry-run\` — try a different template.
+- Hand-author only as last resort, and run \`/check-changes\` after.
+
+The whole point of using the template is consistency with the rest of
+this codebase. Skipping it means the new code will look different from
+what's already there.
+`;
+}
+/**
+ * Build the full set of `.claude/commands/*.md` files for a project.
+ *
+ * Pure — caller writes the bytes. Same shape as the `synthesize-*`
+ * functions in this codebase: input inspection → output file list.
+ */
+export function buildClaudeCommands(inspection, options = {}) {
+    const files = [];
+    files.push({
+        path: '.claude/commands/follow-shrk.md',
+        slash: 'follow-shrk',
+        source: 'static',
+        content: STATIC_FOLLOW_SHRK,
+    });
+    files.push({
+        path: '.claude/commands/check-changes.md',
+        slash: 'check-changes',
+        source: 'static',
+        content: STATIC_CHECK_CHANGES,
+    });
+    files.push({
+        path: '.claude/commands/shrk-brief.md',
+        slash: 'shrk-brief',
+        source: 'static',
+        content: STATIC_SHRK_BRIEF,
+    });
+    files.push({
+        path: '.claude/commands/explain-file.md',
+        slash: 'explain-file',
+        source: 'static',
+        content: STATIC_EXPLAIN_FILE,
+    });
+    // Per-template commands — bounded so a pack with 50 templates
+    // doesn't dump 50 slash commands into the user's palette. Sorted
+    // by id for deterministic emit order.
+    const cap = options.maxTemplateCommands ?? 20;
+    const templates = [...inspection.templates].sort((a, b) => a.id.localeCompare(b.id));
+    const seenSlash = new Set(files.map((f) => f.slash));
+    for (const t of templates) {
+        if (files.filter((f) => f.source === 'template').length >= cap)
+            break;
+        let slash = templateSlash(t.id);
+        if (seenSlash.has(slash)) {
+            // Two templates with the same tail (e.g. `ts.service` and
+            // `py.service` both → `new-service`) — fall back to the full id
+            // to disambiguate the second one.
+            slash = `new-${t.id.replace(/\./g, '-').toLowerCase()}`;
+            if (seenSlash.has(slash))
+                continue;
+        }
+        seenSlash.add(slash);
+        files.push({
+            path: `.claude/commands/${slash}.md`,
+            slash,
+            source: 'template',
+            content: templateCommandBody(t),
+        });
+    }
+    return { files };
+}

package/dist/export/export-formats.d.ts

@@ -1,5 +1,5 @@
 import type { ISharkcraftInspection } from '@shrkcrft/inspector';
-export type ExportFormat = 'agents-md' | 'claude-md' | 'cursor-rules' | 'copilot-instructions';
+export type ExportFormat = 'agents-md' | 'claude-md' | 'claude-skill' | 'cursor-rules' | 'copilot-instructions';
 export interface ExportOptions {
     format: ExportFormat;
     /** Optional task to scope the export. */

package/dist/export/export-formats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"export-formats.d.ts","sourceRoot":"","sources":["../../src/export/export-formats.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAIjE,MAAM,MAAM,YAAY,GACpB,WAAW,GACX,WAAW,GACX,cAAc,GACd,sBAAsB,CAAC;AAE3B,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,YAAY,CAAC;IACrB,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,YAAY,CAAC;IACrB,yDAAyD;IACzD,aAAa,EAAE,MAAM,CAAC;IACtB,wBAAwB;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAqHD,wBAAgB,YAAY,CAC1B,UAAU,EAAE,qBAAqB,EACjC,OAAO,EAAE,aAAa,GACrB,YAAY,CAsBd;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,YAAY,CAOnE;AAED,eAAO,MAAM,kBAAkB,EAAE,SAAS,YAAY,EAKpD,CAAC"}
+{"version":3,"file":"export-formats.d.ts","sourceRoot":"","sources":["../../src/export/export-formats.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAIjE,MAAM,MAAM,YAAY,GACpB,WAAW,GACX,WAAW,GACX,cAAc,GACd,cAAc,GACd,sBAAsB,CAAC;AAE3B,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,YAAY,CAAC;IACrB,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,YAAY,CAAC;IACrB,yDAAyD;IACzD,aAAa,EAAE,MAAM,CAAC;IACtB,wBAAwB;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAqPD,wBAAgB,YAAY,CAC1B,UAAU,EAAE,qBAAqB,EACjC,OAAO,EAAE,aAAa,GACrB,YAAY,CAmCd;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,YAAY,CAQnE;AAED,eAAO,MAAM,kBAAkB,EAAE,SAAS,YAAY,EAMpD,CAAC"}