@bastani/atomic 0.6.8-0 → 0.7.0-1

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/batching.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"batching.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/deep-research-codebase/helpers/batching.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,uEAAuE;AACvE,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,wEAAwE;AACxE,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,gBAAgB,CAAC;AAEtD,8EAA8E;AAC9E,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,mBAAmB,CAAC;AAE1D,wEAAwE;AACxE,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,UAAU,GAAG,UAAU,EAAE,MAAM,CAKjE,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,UAAU,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,uEAAuE;IACvE,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,UAAU,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,CAAC,EAC5B,KAAK,EAAE,CAAC,EAAE,EACV,IAAI,GAAE,MAA4B,GACjC,CAAC,EAAE,EAAE,CAOP"}

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/heuristic.d.ts

@@ -1,14 +0,0 @@
-/**
- * Determine how many parallel explorer sub-agents to spawn for the
- * deep-research-codebase workflow, based on lines of code in the codebase.
- *
- * Scales linearly: one explorer per `LOC_PER_EXPLORER` (5K) lines of code,
- * with a floor of 2 for tiny or empty codebases. The actual number of
- * spawned explorers is still bounded by the number of partition units
- * the scout finds (see `partitionUnits` in ./scout.ts), so we never get
- * more explorers than the natural granularity of the codebase allows.
- */
-export declare function calculateExplorerCount(loc: number): number;
-/** Human-readable rationale for the heuristic decision — surfaced in logs/prompts. */
-export declare function explainHeuristic(loc: number, count: number): string;
-//# sourceMappingURL=heuristic.d.ts.map

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/heuristic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"heuristic.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/deep-research-codebase/helpers/heuristic.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG1D;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAInE"}

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/prompts.d.ts

@@ -1,136 +0,0 @@
-/**
- * Prompt builders for the deep-research-codebase workflow.
- *
- * Each builder produces a focused, single-responsibility prompt for one
- * specialist sub-agent. The sub-agents themselves are dispatched as separate
- * `ctx.stage(...)` calls via the provider SDK's native `agent` parameter
- * (Claude SDK options, Copilot sessionOpts, OpenCode session.prompt). Because
- * each sub-agent already carries a detailed system prompt in `.claude/agents/`,
- * `.opencode/agents/`, and `.github/agents/`, these user-prompts are intentionally
- * short — they only supply the topic, the scope, and the output shape the
- * downstream synthesizer expects.
- *
- * Context-engineering principles applied throughout:
- *
- *   • Position-aware framing: the research question is repeated at the TOP
- *     and BOTTOM of every prompt. Long-context recall is strongest at the
- *     edges of the context window (see `context-fundamentals`).
- *
- *   • Informativity over exhaustiveness: each per-partition prompt embeds
- *     ONLY that partition's directories — never the full file list. This
- *     keeps token cost roughly constant in N rather than O(N²).
- *
- *   • Forward-only data flow: the analyzer prompt embeds the locator's
- *     output verbatim; the online-researcher prompt does the same. No
- *     sub-agent has to re-discover what its sibling already produced.
- *
- *   • Trailing-prose guarantee (failure-modes F6): every prompt asks for a
- *     short prose recap as the final assistant turn so downstream stages
- *     reading via `transcript()` never get an empty string when the agent
- *     ends on a tool call.
- *
- *   • Documentarian framing: every prompt explicitly forbids critique or
- *     improvement suggestions. We are recording what EXISTS.
- *
- *   • File-based handoff (filesystem-context skill): explorer findings are
- *     written deterministically to a scratch file by TypeScript (no extra
- *     LLM "synthesizer" stage) and the aggregator reads them by path.
- */
-import type { PartitionUnit } from "./scout.ts";
-/** Slugify the user's prompt for use in the final research filename. */
-export declare function slugifyPrompt(prompt: string): string;
-export declare function buildScoutPrompt(opts: {
-    question: string;
-    tree: string;
-    totalLoc: number;
-    totalFiles: number;
-    explorerCount: number;
-    partitionPreview: PartitionUnit[][];
-}): string;
-/** codebase-locator — find files in the partition relevant to the question. */
-export declare function buildLocatorPrompt(opts: {
-    question: string;
-    partition: PartitionUnit[];
-    scoutOverview: string;
-    index: number;
-    total: number;
-}): string;
-/** codebase-pattern-finder — surface concrete reusable code patterns. */
-export declare function buildPatternFinderPrompt(opts: {
-    question: string;
-    partition: PartitionUnit[];
-    scoutOverview: string;
-    index: number;
-    total: number;
-}): string;
-/** codebase-analyzer — document HOW the most relevant impl files work. */
-export declare function buildAnalyzerPrompt(opts: {
-    question: string;
-    partition: PartitionUnit[];
-    locatorOutput: string;
-    scoutOverview: string;
-    index: number;
-    total: number;
-}): string;
-/** codebase-online-researcher — focused external doc fetch when libs are central. */
-export declare function buildOnlineResearcherPrompt(opts: {
-    question: string;
-    partition: PartitionUnit[];
-    locatorOutput: string;
-    index: number;
-    total: number;
-}): string;
-/** codebase-research-locator — find prior research docs about the topic. */
-export declare function buildHistoryLocatorPrompt(opts: {
-    question: string;
-}): string;
-/** codebase-research-analyzer — synthesize insights from located research docs. */
-export declare function buildHistoryAnalyzerPrompt(opts: {
-    question: string;
-    locatorOutput: string;
-}): string;
-export declare function buildAggregatorPrompt(opts: {
-    question: string;
-    totalLoc: number;
-    totalFiles: number;
-    explorerCount: number;
-    explorerFiles: {
-        index: number;
-        scratchPath: string;
-        partition: PartitionUnit[];
-    }[];
-    finalPath: string;
-    scoutOverview: string;
-    historyOverview: string;
-}): string;
-/**
- * Wrap a specialist prompt with the "write to file, reply with token only"
- * envelope. The envelope is what the orchestrator hands to the Task tool's
- * `prompt` parameter — the inner specialist prompt is built by the existing
- * `buildLocatorPrompt` / `buildPatternFinderPrompt` / etc. and embedded
- * verbatim so prompt semantics stay identical to the unbatched workflow.
- */
-export declare function wrapPromptForTaskDispatch(opts: {
-    specialistPrompt: string;
-    outputPath: string;
-    agentLabel: string;
-}): string;
-/**
- * Build the orchestrator prompt for a batch session. The orchestrator's job
- * is purely deterministic dispatch — fire one Task tool call per task in
- * **a single assistant message** so they execute in parallel, then report a
- * one-line tally. It must NOT inline sub-agent findings, paraphrase the
- * embedded prompts, or retry failures — siblings still run and synthesis
- * tolerates missing files.
- */
-export declare function buildBatchOrchestratorPrompt(opts: {
-    wave: 1 | 2;
-    batchIndex: number;
-    totalBatches: number;
-    tasks: Array<{
-        subagentType: string;
-        prompt: string;
-        outputPath: string;
-    }>;
-}): string;
-//# sourceMappingURL=prompts.d.ts.map

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/prompts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/deep-research-codebase/helpers/prompts.ts"],"names":[],"mappings":"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"}

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/scout.d.ts

@@ -1,58 +0,0 @@
-/**
- * Codebase scout: deterministic helpers for the deep-research-codebase workflow.
- *
- * Responsibilities:
- *   1. Discover the codebase root (git toplevel, falling back to cwd).
- *   2. List all source files, honoring `.gitignore` via git ls-files in repos
- *      and via `rg --files` in non-repo directories that still have one.
- *   3. Count lines of code per file using batched `wc -l`.
- *   4. Render a compact directory tree (depth-bounded) for prompt context.
- *   5. Build "partition units" by aggregating LOC at depth-1, then drilling
- *      down on any unit that is too large to live in a single explorer.
- *   6. Bin-pack partition units into N balanced groups (largest-first).
- *
- * Everything here is pure TypeScript + child_process — no LLM calls.
- */
-/** Per-file LOC + path. */
-export type FileStats = {
-    path: string;
-    loc: number;
-};
-/**
- * A "partition unit" is the atomic chunk of work that gets bin-packed into
- * an explorer. It is always one directory (possibly drilled down to depth 2)
- * with all of the code files that live anywhere underneath it.
- */
-export type PartitionUnit = {
-    /** Repo-relative path, e.g. "src/cli" or "packages/foo/src". */
-    path: string;
-    loc: number;
-    fileCount: number;
-    /** Repo-relative file paths inside this unit (full recursive listing). */
-    files: string[];
-};
-export type CodebaseScout = {
-    /** Absolute path to the repository root. */
-    root: string;
-    totalLoc: number;
-    totalFiles: number;
-    /** Compact rendered directory tree (depth-bounded) for prompt context. */
-    tree: string;
-    /** Partition units, sorted by LOC descending. */
-    units: PartitionUnit[];
-};
-/** Resolve the project root. Prefers `git rev-parse --show-toplevel`. */
-export declare function getCodebaseRoot(): string;
-/**
- * Run the full scout: list files, count LOC, render tree, build partition units.
- */
-export declare function scoutCodebase(root: string): CodebaseScout;
-/**
- * Bin-pack partition units into `count` balanced groups. Greedy
- * largest-first: assign each unit to the currently-lightest bin.
- *
- * If there are fewer units than requested bins, the result has exactly
- * `units.length` non-empty bins (we never return empty bins).
- */
-export declare function partitionUnits(units: PartitionUnit[], count: number): PartitionUnit[][];
-//# sourceMappingURL=scout.d.ts.map

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/scout.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scout.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/deep-research-codebase/helpers/scout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA4JH,2BAA2B;AAC3B,MAAM,MAAM,SAAS,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtD;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB,CAAC;AAEF,yEAAyE;AACzE,wBAAgB,eAAe,IAAI,MAAM,CAexC;AA0OD;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAiBzD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,aAAa,EAAE,EACtB,KAAK,EAAE,MAAM,GACZ,aAAa,EAAE,EAAE,CAwBnB"}

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/scratch.d.ts

@@ -1,43 +0,0 @@
-/**
- * Deterministic synthesis of per-partition explorer scratch files.
- *
- * Each partition is investigated by four specialist sub-agents dispatched
- * directly via the provider SDK's `agent` parameter:
- *
- *   - codebase-locator           → file index for the partition
- *   - codebase-pattern-finder    → reusable code patterns in the partition
- *   - codebase-analyzer          → how the most relevant impl files work
- *   - codebase-online-researcher → external library docs (when central)
- *
- * Rather than spawn a fifth "synthesizer" LLM stage just to concatenate four
- * markdown sections, we do that synthesis in plain TypeScript here. This keeps
- * the per-partition cost at exactly four LLM calls and avoids burning tokens
- * on a step whose output is fully determined by its inputs.
- *
- * The file we write is the canonical handoff to the aggregator — it MUST keep
- * the heading shape that buildAggregatorPrompt() promises ("Scope / Files in
- * Scope / How It Works / Patterns / External References / Out-of-Partition
- * References"), or the aggregator will look for sections that don't exist.
- */
-import type { PartitionUnit } from "./scout.ts";
-export type ExplorerSections = {
-    index: number;
-    total: number;
-    partition: PartitionUnit[];
-    /** Full assistant text from the codebase-locator sub-agent. */
-    locatorOutput: string;
-    /** Full assistant text from the codebase-pattern-finder sub-agent. */
-    patternsOutput: string;
-    /** Full assistant text from the codebase-analyzer sub-agent. */
-    analyzerOutput: string;
-    /** Full assistant text from the codebase-online-researcher sub-agent. */
-    onlineOutput: string;
-};
-/** Render the markdown body deterministically. */
-export declare function renderExplorerMarkdown(sections: ExplorerSections): string;
-/**
- * Write a partition's deterministic scratch file. Returns the absolute path so
- * the caller can record it in the explorer manifest the aggregator reads.
- */
-export declare function writeExplorerScratchFile(scratchPath: string, sections: ExplorerSections): Promise<string>;
-//# sourceMappingURL=scratch.d.ts.map

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/scratch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scratch.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/deep-research-codebase/helpers/scratch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,+DAA+D;IAC/D,aAAa,EAAE,MAAM,CAAC;IACtB,sEAAsE;IACtE,cAAc,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,cAAc,EAAE,MAAM,CAAC;IACvB,yEAAyE;IACzE,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAOF,kDAAkD;AAClD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAsDzE;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,MAAM,CAAC,CAKjB"}

package/dist/sdk/workflows/builtin/deep-research-codebase/opencode/index.d.ts

@@ -1,37 +0,0 @@
-/**
- * deep-research-codebase / opencode
- *
- * OpenCode replica of the Claude deep-research-codebase workflow with the
- * same **batched** Task-tool fan-out. Specialist sub-agents run inside batch
- * sessions: each batch is a single `ctx.stage()` whose orchestrator turn
- * dispatches up to MAX_TASKS_PER_BATCH (≈10) specialists in parallel via
- * OpenCode's `task` tool. The default agent must have `task: "allow"` in
- * its permission ruleset (see `.opencode/agents/worker.md` for the
- * canonical example).
- *
- * See claude/index.ts for the full design rationale and topology diagram.
- *
- * OpenCode-specific concerns baked in (see references/failure-modes.md):
- *
- *   • F3 — `result.data!.parts` is heterogenous. Batch sessions don't read
- *     `extractResponseText` for orchestrator output (sub-agents write to
- *     disk; the orchestrator reply is just a short tally), but the history
- *     pipeline still uses it.
- *
- *   • F5 — every `ctx.stage()` is a FRESH session. Batch session prompts
- *     embed everything the orchestrator needs in the first turn.
- *
- *   • F6 — orchestrator prompt requires a single-line tally as the trailing
- *     turn so transcripts are never empty.
- *
- *   • F9 — `s.save()` receives the unwrapped `{ info, parts }` payload from
- *     `result.data!`.
- */
-declare const _default: import("../../../index.ts").WorkflowDefinition<"opencode", readonly [{
-    readonly name: "prompt";
-    readonly type: "text";
-    readonly required: true;
-    readonly description: "research question";
-}]>;
-export default _default;
-//# sourceMappingURL=index.d.ts.map

package/dist/sdk/workflows/builtin/deep-research-codebase/opencode/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/deep-research-codebase/opencode/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;;;;;;;AAwEH,wBA6aa"}

package/dist/sdk/workflows/builtin/open-claude-design/claude/index.d.ts

@@ -1,68 +0,0 @@
-/**
- * open-claude-design / claude
- *
- * An open-source replica of Anthropic's Claude Design product, implemented
- * as an Atomic CLI workflow. Orchestrates the design skill ecosystem
- * (impeccable, critique, shape, polish, audit, etc.) into a deterministic
- * 5-phase pipeline:
- *
- *   Phase 1: Design System Onboarding — extract tokens, build Design.md (HIL)
- *   Phase 2: Import — aggregate text/URL/file references
- *   Phase 3: Generation — produce first design version
- *   Phase 4: Refinement Loop — bounded iterate with critique + user feedback
- *   Phase 5: Export/Handoff — HTML export + Claude Code handoff bundle
- *
- * Topology:
- *
- *   ┌─→ ds-locator (headless)  ∥  ds-analyzer (headless)  ∥  ds-patterns (headless)
- *   │                          │
- *   │                          ▼
- *   │                design-system-builder (visible, HIL)
- *   │                          │
- *   │                          ▼
- *   │   web-capture (headless, if URL)  ∥  file-parser (headless, if file)
- *   │                          │
- *   │                          ▼
- *   │                     generator (visible)
- *   │                          │
- *   │                          ▼
- *   │   ┌─→ user-feedback-i (visible, HIL)
- *   │   │         │
- *   │   │         ├─→ critique-i (headless)  ∥  screenshot-i (headless)
- *   │   │         │
- *   │   │         ▼
- *   │   │   apply-changes-i (visible)
- *   │   │         │
- *   │   └─────────┘ (loop until approved or MAX_REFINEMENTS)
- *   │                          │
- *   │                          ▼
- *   │                     exporter (visible)
- *   └──────────────────────────────────────
- *
- * Run: atomic workflow -n open-claude-design -a claude "design a dashboard"
- */
-declare const _default: import("../../../index.ts").WorkflowDefinition<"claude", readonly [{
-    readonly name: "prompt";
-    readonly type: "text";
-    readonly required: true;
-    readonly description: "What to design (e.g., 'a dashboard for monitoring API latency')";
-}, {
-    readonly name: "reference";
-    readonly type: "text";
-    readonly required: false;
-    readonly description: "URL, file path, or codebase path to import as design reference";
-}, {
-    readonly name: "output-type";
-    readonly type: "enum";
-    readonly required: false;
-    readonly values: readonly ["prototype", "wireframe", "page", "component"];
-    readonly default: "prototype";
-    readonly description: "Type of design output to generate";
-}, {
-    readonly name: "design-system";
-    readonly type: "text";
-    readonly required: false;
-    readonly description: "Path to existing Design.md (skips onboarding if provided)";
-}]>;
-export default _default;
-//# sourceMappingURL=index.d.ts.map

package/dist/sdk/workflows/builtin/open-claude-design/claude/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/open-claude-design/claude/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;;;;;;;;;;;;;;;;;;;;;;;;AA8CH,wBA2Za"}

package/dist/sdk/workflows/builtin/open-claude-design/copilot/index.d.ts

@@ -1,56 +0,0 @@
-/**
- * open-claude-design / copilot
- *
- * Copilot replica of the Claude open-claude-design workflow. Orchestrates
- * the design skill ecosystem (impeccable, critique, shape, polish, audit,
- * etc.) into a deterministic 5-phase pipeline:
- *
- *   Phase 1: Design System Onboarding — extract tokens, build Design.md (HIL)
- *   Phase 2: Import — aggregate text/URL/file references
- *   Phase 3: Generation — produce first design version
- *   Phase 4: Refinement Loop — bounded iterate with critique + user feedback
- *   Phase 5: Export/Handoff — HTML export + Claude Code handoff bundle
- *
- * Copilot-specific concerns (see references/failure-modes.md):
- *
- *   • F5 — every `ctx.stage()` is a FRESH session. Every specialist receives
- *     its required context verbatim in its first prompt.
- *   • F1 — Copilot's last assistant turn is often empty when the agent ends
- *     on a tool call. Use `getAssistantText()` (concatenation of every
- *     top-level non-empty assistant turn, ignoring sub-agent
- *     `parentToolCallId` traffic) instead of `.at(-1).data.content`.
- *   • F9 — `s.save()` receives `SessionEvent[]` from `s.session.getMessages()`.
- *
- * Sub-agents are dispatched via `sessionOpts.agent` (the Copilot-native way
- * to bind a session to a single named sub-agent). Permissions default to
- * `approveAll` so headless stages run unattended.
- *
- * See claude/index.ts for the full topology diagram and design rationale.
- *
- * Run: atomic workflow -n open-claude-design -a copilot "design a dashboard"
- */
-declare const _default: import("../../../index.ts").WorkflowDefinition<"copilot", readonly [{
-    readonly name: "prompt";
-    readonly type: "text";
-    readonly required: true;
-    readonly description: "What to design (e.g., 'a dashboard for monitoring API latency')";
-}, {
-    readonly name: "reference";
-    readonly type: "text";
-    readonly required: false;
-    readonly description: "URL, file path, or codebase path to import as design reference";
-}, {
-    readonly name: "output-type";
-    readonly type: "enum";
-    readonly required: false;
-    readonly values: readonly ["prototype", "wireframe", "page", "component"];
-    readonly default: "prototype";
-    readonly description: "Type of design output to generate";
-}, {
-    readonly name: "design-system";
-    readonly type: "text";
-    readonly required: false;
-    readonly description: "Path to existing Design.md (skips onboarding if provided)";
-}]>;
-export default _default;
-//# sourceMappingURL=index.d.ts.map

package/dist/sdk/workflows/builtin/open-claude-design/copilot/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/open-claude-design/copilot/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;;;;;;;;;;;;;;;;;;;;;;;;AA2DH,wBAkaa"}

package/dist/sdk/workflows/builtin/open-claude-design/helpers/constants.d.ts

@@ -1,72 +0,0 @@
-/**
- * Constants for the open-claude-design workflow.
- *
- * Design-rule constants (REFLEX_FONTS, IMPECCABLE_BANS, DESIGN_DONTS) mirror
- * the canonical impeccable skill shipped at
- * `~/.claude/skills/impeccable/SKILL.md`. The skill itself is only loaded
- * opportunistically by the agent — so we inline the load-bearing rules here
- * to guarantee every generation/refinement/critique turn sees them even if
- * the skill is missing or fails to load. Re-sync when the skill updates.
- */
-/** Maximum refinement iterations before the loop exits unconditionally. */
-export declare const MAX_REFINEMENTS = 5;
-/**
- * Headless stages: structured analysis, tool orchestration, rubric-following.
- * Uses Sonnet for cost efficiency. Bypasses permissions for unattended operation.
- */
-export declare const HEADLESS_OPTS: {
-    readonly permissionMode: "bypassPermissions";
-    readonly allowDangerouslySkipPermissions: true;
-    readonly model: "sonnet";
-};
-/**
- * Visible/creative stages: inherit orchestrator model (Opus).
- * No model override — inherits from the parent session.
- */
-export declare const VISIBLE_OPTS: {
-    readonly permissionMode: "bypassPermissions";
-    readonly allowDangerouslySkipPermissions: true;
-};
-/** Name of the design system file written to the project root. */
-export declare const DESIGN_SYSTEM_FILENAME = "Design.md";
-/** Directory under project root where final design outputs are stored. */
-export declare const DESIGNS_DIR = "research/designs";
-/** Name of the existing impeccable brand context file. */
-export declare const IMPECCABLE_FILENAME = ".impeccable.md";
-/**
- * Structured ban — rendered into generation/refinement/critique prompts as a
- * `rule` (what is forbidden) plus `detail` (the CSS pattern + the rewrite).
- */
-export interface ImpeccableBan {
-    readonly id: string;
-    readonly rule: string;
-    readonly detail: string;
-}
-/**
- * Absolute CSS bans from the canonical impeccable skill's `<absolute_bans>`
- * section. These are the two patterns that the skill flags as "NEVER
- * acceptable" regardless of color, radius, or CSS variable naming. If you
- * change this list, re-sync with `~/.claude/skills/impeccable/SKILL.md`.
- */
-export declare const IMPECCABLE_BANS: readonly ImpeccableBan[];
-/**
- * Canonical reflex fonts from the impeccable skill's
- * `<reflex_fonts_to_reject>` list. These are the training-data defaults that
- * create monoculture across projects; every one of them is banned.
- */
-export declare const REFLEX_FONTS: readonly string[];
-/**
- * Non-ban DON'Ts distilled from the impeccable skill sections on Typography,
- * Color, Layout/Space, Motion, UX Writing, and Responsive. These are not
- * absolute bans, but they are the recognizable AI fingerprints from
- * 2024-2025 and must be avoided in generated designs.
- */
-export declare const DESIGN_DONTS: readonly string[];
-/**
- * Command invocation for the impeccable scanner. The correct subcommand is
- * `detect`; a bare `impeccable --json` just prints the top-level help.
- * Exit code is always 0 — callers must parse the JSON array and check length
- * to know whether findings exist.
- */
-export declare const IMPECCABLE_SCAN_CMD: readonly ["bunx", "impeccable", "detect", "--json"];
-//# sourceMappingURL=constants.d.ts.map

package/dist/sdk/workflows/builtin/open-claude-design/helpers/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/open-claude-design/helpers/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;CAIhB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,YAAY;;;CAGf,CAAC;AAEX,kEAAkE;AAClE,eAAO,MAAM,sBAAsB,cAAc,CAAC;AAElD,0EAA0E;AAC1E,eAAO,MAAM,WAAW,qBAAqB,CAAC;AAE9C,0DAA0D;AAC1D,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,aAAa,EAoB1C,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAwBhC,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EA4BhC,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,qDAKtB,CAAC"}

package/dist/sdk/workflows/builtin/open-claude-design/helpers/design-system.d.ts

@@ -1,46 +0,0 @@
-/**
- * Design.md persistence — loading, saving, and reading design system data.
- *
- * The Design.md file is a structured markdown document containing design
- * tokens (colors, typography, spacing, components) extracted from the
- * codebase and approved by the user via HIL. It serves as the single
- * source of truth for all generation and refinement stages.
- */
-/** Structured representation of the design system data. */
-export interface DesignSystemData {
-    /** Raw markdown content of Design.md. */
-    raw: string;
-    /** Absolute path to the Design.md file. */
-    path: string;
-}
-/**
- * Load an existing Design.md from the given path.
- * Used when the user provides `--design-system=<path>`.
- */
-export declare function loadDesignSystem(designSystemPath: string): Promise<DesignSystemData>;
-/**
- * Persist the design system builder's output as Design.md in the project root.
- *
- * The builder stage produces a visible session where the agent constructs
- * the Design.md content interactively with the user. We read the transcript
- * and extract the final Design.md content that the agent wrote.
- *
- * For simplicity, the agent in the builder stage is instructed to write
- * Design.md directly to disk. This function reads it back to populate
- * the DesignSystemData for downstream stages.
- */
-export declare function persistDesignSystem(root: string): Promise<DesignSystemData>;
-/**
- * Read the existing .impeccable.md brand context file, if present.
- * Returns empty string if the file does not exist.
- */
-export declare function readImpeccableMd(root: string): Promise<string>;
-/**
- * Derive a URL-safe slug from the user's prompt for directory naming.
- */
-export declare function slugifyPrompt(prompt: string): string;
-/**
- * Ensure the scratch directory exists for intermediate workflow outputs.
- */
-export declare function ensureScratchDir(root: string): Promise<string>;
-//# sourceMappingURL=design-system.d.ts.map

package/dist/sdk/workflows/builtin/open-claude-design/helpers/design-system.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"design-system.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/open-claude-design/helpers/design-system.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,2DAA2D;AAC3D,MAAM,WAAW,gBAAgB;IAC/B,yCAAyC;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAI3B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,gBAAgB,CAAC,CAI3B;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAMpE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAUpD;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAKpE"}

package/dist/sdk/workflows/builtin/open-claude-design/helpers/export.d.ts

@@ -1,32 +0,0 @@
-/**
- * Export engine — handoff bundle packaging.
- *
- * Writes the deterministic parts of the handoff bundle (no LLM call):
- *   - handoff-prompt.md  — ready-to-use prompt for Claude Code
- *   - README.md          — how to use the bundle
- *
- * The exporter stage (LLM) handles copying design files, writing
- * design-intent.md and component-specs.md since those require
- * understanding the generated design content.
- */
-import type { DesignSystemData } from "./design-system.ts";
-export interface HandoffBundleOptions {
-    designSystem: DesignSystemData;
-    prompt: string;
-    outputType: string;
-}
-/**
- * Write the deterministic handoff bundle files.
- *
- * The exporter stage is responsible for:
- *   - Copying design files (index.html, styles.css, script.js) to design/
- *   - Writing design-intent.md from transcript analysis
- *   - Writing component-specs.md from design analysis
- *
- * This function writes the remaining deterministic files:
- *   - Design.md (copy of the design system)
- *   - handoff-prompt.md (ready-to-use implementation prompt)
- *   - README.md (bundle documentation)
- */
-export declare function writeHandoffBundle(finalDesignDir: string, opts: HandoffBundleOptions): Promise<void>;
-//# sourceMappingURL=export.d.ts.map

package/dist/sdk/workflows/builtin/open-claude-design/helpers/export.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/open-claude-design/helpers/export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,gBAAgB,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,cAAc,EAAE,MAAM,EACtB,IAAI,EAAE,oBAAoB,GACzB,OAAO,CAAC,IAAI,CAAC,CAyBf"}

package/dist/sdk/workflows/builtin/open-claude-design/helpers/import.d.ts

@@ -1,33 +0,0 @@
-/**
- * Import handler — input type detection and aggregation.
- *
- * Classifies the user's `--reference` input as a URL, file path, or
- * neither, and aggregates all import sources into a structured context
- * object that the generator consumes.
- */
-/** Aggregated import context passed to the generator stage. */
-export interface ImportContext {
-    /** The user's free-form design prompt. */
-    prompt: string;
-    /** Raw reference string (URL, file path, or empty). */
-    reference: string;
-    /** Extracted content from a web URL capture, or null. */
-    webCapture: string | null;
-    /** Extracted content from a parsed file, or null. */
-    fileParse: string | null;
-}
-/** Check whether the reference string looks like a URL. */
-export declare function isUrl(reference: string): boolean;
-/** Check whether the reference string looks like a file path. */
-export declare function isFilePath(reference: string): boolean;
-/**
- * Aggregate all import results into a single context object.
- * Pure deterministic function — no LLM call.
- */
-export declare function aggregateImportResults(opts: {
-    prompt: string;
-    reference: string;
-    webCapture: string | null;
-    fileParse: string | null;
-}): ImportContext;
-//# sourceMappingURL=import.d.ts.map