@cjhyy/code-shell 0.1.0-alpha.0

package/dist/native-ts/yoga-layout/enums.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Yoga enums — ported from yoga-layout/src/generated/YGEnums.ts
+ * Kept as `const` objects (not TS enums) per repo convention.
+ * Values match upstream exactly so callers don't change.
+ */
+export declare const Align: {
+    readonly Auto: 0;
+    readonly FlexStart: 1;
+    readonly Center: 2;
+    readonly FlexEnd: 3;
+    readonly Stretch: 4;
+    readonly Baseline: 5;
+    readonly SpaceBetween: 6;
+    readonly SpaceAround: 7;
+    readonly SpaceEvenly: 8;
+};
+export type Align = (typeof Align)[keyof typeof Align];
+export declare const BoxSizing: {
+    readonly BorderBox: 0;
+    readonly ContentBox: 1;
+};
+export type BoxSizing = (typeof BoxSizing)[keyof typeof BoxSizing];
+export declare const Dimension: {
+    readonly Width: 0;
+    readonly Height: 1;
+};
+export type Dimension = (typeof Dimension)[keyof typeof Dimension];
+export declare const Direction: {
+    readonly Inherit: 0;
+    readonly LTR: 1;
+    readonly RTL: 2;
+};
+export type Direction = (typeof Direction)[keyof typeof Direction];
+export declare const Display: {
+    readonly Flex: 0;
+    readonly None: 1;
+    readonly Contents: 2;
+};
+export type Display = (typeof Display)[keyof typeof Display];
+export declare const Edge: {
+    readonly Left: 0;
+    readonly Top: 1;
+    readonly Right: 2;
+    readonly Bottom: 3;
+    readonly Start: 4;
+    readonly End: 5;
+    readonly Horizontal: 6;
+    readonly Vertical: 7;
+    readonly All: 8;
+};
+export type Edge = (typeof Edge)[keyof typeof Edge];
+export declare const Errata: {
+    readonly None: 0;
+    readonly StretchFlexBasis: 1;
+    readonly AbsolutePositionWithoutInsetsExcludesPadding: 2;
+    readonly AbsolutePercentAgainstInnerSize: 4;
+    readonly All: 2147483647;
+    readonly Classic: 2147483646;
+};
+export type Errata = (typeof Errata)[keyof typeof Errata];
+export declare const ExperimentalFeature: {
+    readonly WebFlexBasis: 0;
+};
+export type ExperimentalFeature = (typeof ExperimentalFeature)[keyof typeof ExperimentalFeature];
+export declare const FlexDirection: {
+    readonly Column: 0;
+    readonly ColumnReverse: 1;
+    readonly Row: 2;
+    readonly RowReverse: 3;
+};
+export type FlexDirection = (typeof FlexDirection)[keyof typeof FlexDirection];
+export declare const Gutter: {
+    readonly Column: 0;
+    readonly Row: 1;
+    readonly All: 2;
+};
+export type Gutter = (typeof Gutter)[keyof typeof Gutter];
+export declare const Justify: {
+    readonly FlexStart: 0;
+    readonly Center: 1;
+    readonly FlexEnd: 2;
+    readonly SpaceBetween: 3;
+    readonly SpaceAround: 4;
+    readonly SpaceEvenly: 5;
+};
+export type Justify = (typeof Justify)[keyof typeof Justify];
+export declare const MeasureMode: {
+    readonly Undefined: 0;
+    readonly Exactly: 1;
+    readonly AtMost: 2;
+};
+export type MeasureMode = (typeof MeasureMode)[keyof typeof MeasureMode];
+export declare const Overflow: {
+    readonly Visible: 0;
+    readonly Hidden: 1;
+    readonly Scroll: 2;
+};
+export type Overflow = (typeof Overflow)[keyof typeof Overflow];
+export declare const PositionType: {
+    readonly Static: 0;
+    readonly Relative: 1;
+    readonly Absolute: 2;
+};
+export type PositionType = (typeof PositionType)[keyof typeof PositionType];
+export declare const Unit: {
+    readonly Undefined: 0;
+    readonly Point: 1;
+    readonly Percent: 2;
+    readonly Auto: 3;
+};
+export type Unit = (typeof Unit)[keyof typeof Unit];
+export declare const Wrap: {
+    readonly NoWrap: 0;
+    readonly Wrap: 1;
+    readonly WrapReverse: 2;
+};
+export type Wrap = (typeof Wrap)[keyof typeof Wrap];

package/dist/native-ts/yoga-layout/index.d.ts

@@ -0,0 +1,270 @@
+/**
+ * Pure-TypeScript port of yoga-layout (Meta's flexbox engine).
+ *
+ * This matches the `yoga-layout/load` API surface used by src/ink/layout/yoga.ts.
+ * The upstream C++ source is ~2500 lines in CalculateLayout.cpp alone; this port
+ * is a simplified single-pass flexbox implementation that covers the subset of
+ * features Ink actually uses:
+ *   - flex-direction (row/column + reverse)
+ *   - flex-grow / flex-shrink / flex-basis
+ *   - align-items / align-self (stretch, flex-start, center, flex-end)
+ *   - justify-content (all six values)
+ *   - margin / padding / border / gap
+ *   - width / height / min / max (point, percent, auto)
+ *   - position: relative / absolute
+ *   - display: flex / none
+ *   - measure functions (for text nodes)
+ *
+ * Also implemented for spec parity (not used by Ink):
+ *   - margin: auto (main + cross axis, overrides justify/align)
+ *   - multi-pass flex clamping when children hit min/max constraints
+ *   - flex-grow/shrink against container min/max when size is indefinite
+ *
+ * Also implemented for spec parity (not used by Ink):
+ *   - flex-wrap: wrap / wrap-reverse (multi-line flex)
+ *   - align-content (positions wrapped lines on cross axis)
+ *
+ * Also implemented for spec parity (not used by Ink):
+ *   - display: contents (children lifted to grandparent, box removed)
+ *
+ * Also implemented for spec parity (not used by Ink):
+ *   - baseline alignment (align-items/align-self: baseline)
+ *
+ * Not implemented (not used by Ink):
+ *   - aspect-ratio
+ *   - box-sizing: content-box
+ *   - RTL direction (Ink always passes Direction.LTR)
+ *
+ * Upstream: https://github.com/facebook/yoga
+ */
+import { Align, BoxSizing, Dimension, Direction, Display, Edge, Errata, ExperimentalFeature, FlexDirection, Gutter, Justify, MeasureMode, Overflow, PositionType, Unit, Wrap } from './enums.js';
+export { Align, BoxSizing, Dimension, Direction, Display, Edge, Errata, ExperimentalFeature, FlexDirection, Gutter, Justify, MeasureMode, Overflow, PositionType, Unit, Wrap, };
+export type Value = {
+    unit: Unit;
+    value: number;
+};
+type Layout = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    border: [number, number, number, number];
+    padding: [number, number, number, number];
+    margin: [number, number, number, number];
+};
+type Style = {
+    direction: Direction;
+    flexDirection: FlexDirection;
+    justifyContent: Justify;
+    alignItems: Align;
+    alignSelf: Align;
+    alignContent: Align;
+    flexWrap: Wrap;
+    overflow: Overflow;
+    display: Display;
+    positionType: PositionType;
+    flexGrow: number;
+    flexShrink: number;
+    flexBasis: Value;
+    margin: Value[];
+    padding: Value[];
+    border: Value[];
+    position: Value[];
+    gap: Value[];
+    width: Value;
+    height: Value;
+    minWidth: Value;
+    minHeight: Value;
+    maxWidth: Value;
+    maxHeight: Value;
+};
+export type MeasureFunction = (width: number, widthMode: MeasureMode, height: number, heightMode: MeasureMode) => {
+    width: number;
+    height: number;
+};
+export type Size = {
+    width: number;
+    height: number;
+};
+export type Config = {
+    pointScaleFactor: number;
+    errata: Errata;
+    useWebDefaults: boolean;
+    free(): void;
+    isExperimentalFeatureEnabled(_: ExperimentalFeature): boolean;
+    setExperimentalFeatureEnabled(_: ExperimentalFeature, __: boolean): void;
+    setPointScaleFactor(factor: number): void;
+    getErrata(): Errata;
+    setErrata(errata: Errata): void;
+    setUseWebDefaults(v: boolean): void;
+};
+export declare class Node {
+    style: Style;
+    layout: Layout;
+    parent: Node | null;
+    children: Node[];
+    measureFunc: MeasureFunction | null;
+    config: Config;
+    isDirty_: boolean;
+    isReferenceBaseline_: boolean;
+    _flexBasis: number;
+    _mainSize: number;
+    _crossSize: number;
+    _lineIndex: number;
+    _hasAutoMargin: boolean;
+    _hasPosition: boolean;
+    _hasPadding: boolean;
+    _hasBorder: boolean;
+    _hasMargin: boolean;
+    _lW: number;
+    _lH: number;
+    _lWM: MeasureMode;
+    _lHM: MeasureMode;
+    _lOW: number;
+    _lOH: number;
+    _lFW: boolean;
+    _lFH: boolean;
+    _lOutW: number;
+    _lOutH: number;
+    _hasL: boolean;
+    _mW: number;
+    _mH: number;
+    _mWM: MeasureMode;
+    _mHM: MeasureMode;
+    _mOW: number;
+    _mOH: number;
+    _mOutW: number;
+    _mOutH: number;
+    _hasM: boolean;
+    _fbBasis: number;
+    _fbOwnerW: number;
+    _fbOwnerH: number;
+    _fbAvailMain: number;
+    _fbAvailCross: number;
+    _fbCrossMode: MeasureMode;
+    _fbGen: number;
+    _cIn: Float64Array | null;
+    _cOut: Float64Array | null;
+    _cGen: number;
+    _cN: number;
+    _cWr: number;
+    constructor(config?: Config);
+    insertChild(child: Node, index: number): void;
+    removeChild(child: Node): void;
+    getChild(index: number): Node;
+    getChildCount(): number;
+    getParent(): Node | null;
+    free(): void;
+    freeRecursive(): void;
+    reset(): void;
+    markDirty(): void;
+    isDirty(): boolean;
+    hasNewLayout(): boolean;
+    markLayoutSeen(): void;
+    setMeasureFunc(fn: MeasureFunction | null): void;
+    unsetMeasureFunc(): void;
+    getComputedLeft(): number;
+    getComputedTop(): number;
+    getComputedWidth(): number;
+    getComputedHeight(): number;
+    getComputedRight(): number;
+    getComputedBottom(): number;
+    getComputedLayout(): {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+        width: number;
+        height: number;
+    };
+    getComputedBorder(edge: Edge): number;
+    getComputedPadding(edge: Edge): number;
+    getComputedMargin(edge: Edge): number;
+    setWidth(v: number | 'auto' | string | undefined): void;
+    setWidthPercent(v: number): void;
+    setWidthAuto(): void;
+    setHeight(v: number | 'auto' | string | undefined): void;
+    setHeightPercent(v: number): void;
+    setHeightAuto(): void;
+    setMinWidth(v: number | string | undefined): void;
+    setMinWidthPercent(v: number): void;
+    setMinHeight(v: number | string | undefined): void;
+    setMinHeightPercent(v: number): void;
+    setMaxWidth(v: number | string | undefined): void;
+    setMaxWidthPercent(v: number): void;
+    setMaxHeight(v: number | string | undefined): void;
+    setMaxHeightPercent(v: number): void;
+    setFlexDirection(dir: FlexDirection): void;
+    setFlexGrow(v: number | undefined): void;
+    setFlexShrink(v: number | undefined): void;
+    setFlex(v: number | undefined): void;
+    setFlexBasis(v: number | 'auto' | string | undefined): void;
+    setFlexBasisPercent(v: number): void;
+    setFlexBasisAuto(): void;
+    setFlexWrap(wrap: Wrap): void;
+    setAlignItems(a: Align): void;
+    setAlignSelf(a: Align): void;
+    setAlignContent(a: Align): void;
+    setJustifyContent(j: Justify): void;
+    setDisplay(d: Display): void;
+    getDisplay(): Display;
+    setPositionType(t: PositionType): void;
+    setPosition(edge: Edge, v: number | string | undefined): void;
+    setPositionPercent(edge: Edge, v: number): void;
+    setPositionAuto(edge: Edge): void;
+    setOverflow(o: Overflow): void;
+    setDirection(d: Direction): void;
+    setBoxSizing(_: BoxSizing): void;
+    setMargin(edge: Edge, v: number | 'auto' | string | undefined): void;
+    setMarginPercent(edge: Edge, v: number): void;
+    setMarginAuto(edge: Edge): void;
+    setPadding(edge: Edge, v: number | string | undefined): void;
+    setPaddingPercent(edge: Edge, v: number): void;
+    setBorder(edge: Edge, v: number | undefined): void;
+    setGap(gutter: Gutter, v: number | string | undefined): void;
+    setGapPercent(gutter: Gutter, v: number): void;
+    getFlexDirection(): FlexDirection;
+    getJustifyContent(): Justify;
+    getAlignItems(): Align;
+    getAlignSelf(): Align;
+    getAlignContent(): Align;
+    getFlexGrow(): number;
+    getFlexShrink(): number;
+    getFlexBasis(): Value;
+    getFlexWrap(): Wrap;
+    getWidth(): Value;
+    getHeight(): Value;
+    getOverflow(): Overflow;
+    getPositionType(): PositionType;
+    getDirection(): Direction;
+    copyStyle(_: Node): void;
+    setDirtiedFunc(_: unknown): void;
+    unsetDirtiedFunc(): void;
+    setIsReferenceBaseline(v: boolean): void;
+    isReferenceBaseline(): boolean;
+    setAspectRatio(_: number | undefined): void;
+    getAspectRatio(): number;
+    setAlwaysFormsContainingBlock(_: boolean): void;
+    calculateLayout(ownerWidth: number | undefined, ownerHeight: number | undefined, _direction?: Direction): void;
+}
+export declare function getYogaCounters(): {
+    visited: number;
+    measured: number;
+    cacheHits: number;
+    live: number;
+};
+export type Yoga = {
+    Config: {
+        create(): Config;
+        destroy(config: Config): void;
+    };
+    Node: {
+        create(config?: Config): Node;
+        createDefault(): Node;
+        createWithConfig(config: Config): Node;
+        destroy(node: Node): void;
+    };
+};
+declare const YOGA_INSTANCE: Yoga;
+export declare function loadYoga(): Promise<Yoga>;
+export default YOGA_INSTANCE;

package/dist/onboarding-6WEPV7C2.js

@@ -0,0 +1,11 @@
+import {
+  hasApiKey,
+  reconfigure,
+  runOnboarding
+} from "./chunk-WRZJUQ5Z.js";
+import "./chunk-DI7RDLOS.js";
+export {
+  hasApiKey,
+  reconfigure,
+  runOnboarding
+};

package/dist/onboarding-QM5DY2TU.cjs

@@ -0,0 +1,11 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkNZ4DQ72Dcjs = require('./chunk-NZ4DQ72D.cjs');
+require('./chunk-IJSHQGMP.cjs');
+
+
+
+
+exports.hasApiKey = _chunkNZ4DQ72Dcjs.hasApiKey; exports.reconfigure = _chunkNZ4DQ72Dcjs.reconfigure; exports.runOnboarding = _chunkNZ4DQ72Dcjs.runOnboarding;

package/dist/openai-5HQGBL4L.js

@@ -0,0 +1,9 @@
+import {
+  OpenAIClient
+} from "./chunk-VKGNCYRL.js";
+import "./chunk-O6F2EF2Z.js";
+import "./chunk-FUOKLKR2.js";
+import "./chunk-DI7RDLOS.js";
+export {
+  OpenAIClient
+};

package/dist/openai-656VWUQW.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkWHRTARDJcjs = require('./chunk-WHRTARDJ.cjs');
+require('./chunk-DICG4AB7.cjs');
+require('./chunk-EL2RL5DG.cjs');
+require('./chunk-IJSHQGMP.cjs');
+
+
+exports.OpenAIClient = _chunkWHRTARDJcjs.OpenAIClient;

package/dist/plugins/loader.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Plugin system — discover, load, and manage plugins.
+ *
+ * Plugin directories:
+ *   ~/.code-shell/plugins/
+ *   .code-shell/plugins/ (project-level)
+ *
+ * Each plugin is a directory with a manifest.json:
+ *   {
+ *     "name": "my-plugin",
+ *     "version": "1.0.0",
+ *     "description": "...",
+ *     "main": "index.js",
+ *     "skills": [...],
+ *     "hooks": {...},
+ *     "mcpServers": {...},
+ *     "tools": [...]
+ *   }
+ */
+export interface PluginManifest {
+    name: string;
+    version: string;
+    description: string;
+    main?: string;
+    enabled?: boolean;
+    skills?: Array<{
+        name: string;
+        description: string;
+        triggers?: {
+            keywords?: string[];
+            tools?: string[];
+            intents?: string[];
+        };
+    }>;
+    hooks?: Record<string, string>;
+    mcpServers?: Record<string, {
+        command: string;
+        args?: string[];
+    }>;
+    tools?: Array<{
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+        handler: string;
+    }>;
+}
+export interface LoadedPlugin {
+    manifest: PluginManifest;
+    path: string;
+    enabled: boolean;
+    error?: string;
+}
+export declare class PluginLoader {
+    private plugins;
+    /**
+     * Scan plugin directories and load manifests.
+     */
+    scan(cwd: string): LoadedPlugin[];
+    /**
+     * Load a single plugin from a directory.
+     */
+    private loadPlugin;
+    private registerPlugin;
+    /** Get a plugin by name. */
+    get(name: string): LoadedPlugin | undefined;
+    /** List all discovered plugins. */
+    list(): LoadedPlugin[];
+    /** Enable/disable a plugin. */
+    setEnabled(name: string, enabled: boolean): boolean;
+    /** Get all enabled plugins. */
+    getEnabled(): LoadedPlugin[];
+}

package/dist/plugins/types.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Plugin type definitions.
+ */
+export type { PluginManifest, LoadedPlugin } from "./loader.js";

package/dist/preset/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Built-in agent presets.
+ *
+ * Presets keep the core engine domain-agnostic while letting callers choose
+ * a default prompt, default tools, and safe permission shortcuts.
+ *
+ * System prompts are assembled from reusable markdown sections in
+ * src/prompt/sections/*.md — each preset declares which sections to include.
+ */
+import type { PermissionRule } from "../types.js";
+export declare const AGENT_PRESET_NAMES: readonly ["general", "terminal-coding"];
+/** Built-in preset names. Custom presets use arbitrary strings via registerPreset(). */
+export type BuiltinPresetName = (typeof AGENT_PRESET_NAMES)[number];
+/** Any preset name — built-in or custom-registered. */
+export type AgentPresetName = BuiltinPresetName | (string & {});
+export interface AgentPreset {
+    name: AgentPresetName;
+    label: string;
+    description: string;
+    /** Ordered list of prompt section filenames (without .md). */
+    promptSections: readonly string[];
+    /** Whether to inject git status into system context. */
+    injectGitStatus: boolean;
+    builtinTools: string[];
+    defaultPermissionRules: PermissionRule[];
+}
+export declare const BUILTIN_AGENT_PRESETS: Record<AgentPresetName, AgentPreset>;
+export declare const DEFAULT_AGENT_PRESET: AgentPresetName;
+export declare const DEFAULT_CLI_PRESET: AgentPresetName;
+/**
+ * Register a custom agent preset.
+ *
+ * External repos can call this to add their own presets:
+ * ```ts
+ * import { registerPreset } from "code-shell";
+ *
+ * registerPreset({
+ *   name: "data-pipeline" as AgentPresetName,
+ *   label: "Data Pipeline Orchestrator",
+ *   description: "Manages ETL workflows and data quality checks.",
+ *   promptSections: ["base", "orchestration"],
+ *   injectGitStatus: false,
+ *   builtinTools: ["Read", "Write", "Bash", "Glob", "Grep", "Agent"],
+ *   defaultPermissionRules: [{ tool: "Read", decision: "allow" }],
+ * });
+ * ```
+ */
+export declare function registerPreset(preset: AgentPreset): void;
+/** List all available preset names (built-in + custom). */
+export declare function listPresetNames(): string[];
+export declare function resolveAgentPreset(name?: string): AgentPreset;
+/**
+ * Build the full system prompt for a preset by loading and joining its sections.
+ */
+export declare function buildPresetSystemPrompt(preset: AgentPreset): string;
+export declare function resolveBuiltinToolNames(options?: {
+    preset?: string;
+    enabledBuiltinTools?: string[];
+    disabledBuiltinTools?: string[];
+}): string[];

package/dist/product/define.d.ts

@@ -0,0 +1,60 @@
+/**
+ * defineProduct — assemble a domain-specific agent product from preset + adapter + contract.
+ *
+ * This is the primary entry point for external repos. One call produces a
+ * ready-to-use RunManager that embodies the product's behavior.
+ *
+ * Example (in an external repo):
+ * ```ts
+ * import { defineProduct } from "code-shell";
+ *
+ * const { manager, preset } = defineProduct({
+ *   preset: {
+ *     name: "security-audit",
+ *     label: "Security Audit Agent",
+ *     description: "Scans repos for OWASP top 10 vulnerabilities.",
+ *     sections: ["base", "orchestration"],
+ *     appendPrompt: "You are a security expert. Focus on...",
+ *   },
+ *   adapter: {
+ *     tools: [myCustomScanTool],
+ *     enableTools: ["Read", "Glob", "Grep", "Bash"],
+ *     permissionRules: [{ tool: "Bash", decision: "ask" }],
+ *   },
+ *   contract: {
+ *     evaluator: new SecurityEvaluator(),
+ *     defaultTags: ["security"],
+ *     maxTurns: 50,
+ *   },
+ * }, {
+ *   llm: { provider: "openai", model: "...", apiKey: "..." },
+ * });
+ *
+ * await manager.submit({ objective: "Audit auth module for SQL injection" });
+ * ```
+ */
+import type { LLMConfig, PermissionMode } from "../types.js";
+import type { AgentPreset } from "../preset/index.js";
+import { RunManager } from "../run/RunManager.js";
+import type { ProductDefinition, CustomTool } from "./types.js";
+export interface ProductRuntimeOptions {
+    /** LLM configuration (required). */
+    llm: LLMConfig;
+    /** Permission mode. Default: "acceptEdits" */
+    permissionMode?: PermissionMode;
+    /** Working directory. Default: process.cwd() */
+    cwd?: string;
+    /** Storage directory for runs. Default: ~/.code-shell/runs */
+    runsDir?: string;
+    /** Storage directory for sessions. */
+    sessionStorageDir?: string;
+}
+export interface ProductInstance {
+    /** The configured RunManager, ready for submit/resume/cancel. */
+    manager: RunManager;
+    /** The registered preset (can be used to create Engine directly). */
+    preset: AgentPreset;
+    /** Custom tools registered by the adapter (for reference). */
+    customTools: CustomTool[];
+}
+export declare function defineProduct(definition: ProductDefinition, runtime: ProductRuntimeOptions): ProductInstance;

package/dist/product/index.cjs

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkWFQF3RT4cjs = require('../chunk-WFQF3RT4.cjs');
+require('../chunk-QHDYFC5U.cjs');
+require('../chunk-3QR52LL5.cjs');
+require('../chunk-UK2SU23S.cjs');
+require('../chunk-FGZGCFJX.cjs');
+require('../chunk-JT2WSQSR.cjs');
+require('../chunk-BMH65OVB.cjs');
+require('../chunk-LRAY5IYC.cjs');
+require('../chunk-HD7MT5XU.cjs');
+require('../chunk-3EAEC566.cjs');
+require('../chunk-CSO5EOEP.cjs');
+require('../chunk-NG73UR3L.cjs');
+require('../chunk-3EUDE77E.cjs');
+require('../chunk-FVP7XJGS.cjs');
+require('../chunk-IMMTBZ33.cjs');
+require('../chunk-EL2RL5DG.cjs');
+require('../chunk-XHC2JMEC.cjs');
+require('../chunk-IJSHQGMP.cjs');
+
+
+exports.defineProduct = _chunkWFQF3RT4cjs.defineProduct;

package/dist/product/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Product module — build domain-specific agents on CodeShell.
+ */
+export type { ProductDefinition, ProductPreset, ProductAdapter, ProductContract, CustomTool, } from "./types.js";
+export { defineProduct, type ProductRuntimeOptions, type ProductInstance, } from "./define.js";

package/dist/product/index.js

@@ -0,0 +1,23 @@
+import {
+  defineProduct
+} from "../chunk-6JOOLG6F.js";
+import "../chunk-7RMAR2Y3.js";
+import "../chunk-SK62UVS6.js";
+import "../chunk-KO2FPF7G.js";
+import "../chunk-6ZIROYXX.js";
+import "../chunk-OG4MIQJ6.js";
+import "../chunk-BE6IPRDM.js";
+import "../chunk-J5XW6UYL.js";
+import "../chunk-4RRUP4MM.js";
+import "../chunk-4PKZPFCD.js";
+import "../chunk-4SFPFHMG.js";
+import "../chunk-S74VVJBF.js";
+import "../chunk-ZXYDDJEJ.js";
+import "../chunk-SQZHPD3S.js";
+import "../chunk-X4HAERTQ.js";
+import "../chunk-FUOKLKR2.js";
+import "../chunk-C7JBCO5V.js";
+import "../chunk-DI7RDLOS.js";
+export {
+  defineProduct
+};