@dawn-ai/core 0.1.7 → 0.2.0

package/dist/capabilities/built-in/workspace.js

@@ -0,0 +1,187 @@
+import { existsSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+import { suggestedCommandPattern, suggestedPathPattern } from "@dawn-ai/permissions";
+import { localExec, localFilesystem } from "@dawn-ai/workspace";
+import { interrupt } from "@langchain/langgraph";
+import { z } from "zod";
+const WORKSPACE_DIRNAME = "workspace";
+/**
+ * Resolve the workspace root to a cwd-relative path. This matches the
+ * AGENTS.md capability's resolution (process.cwd() + "workspace") so
+ * the agent's memory and workspace tools point at the same directory.
+ */
+function workspaceRoot() {
+    return join(process.cwd(), WORKSPACE_DIRNAME);
+}
+const READ_FILE_INPUT = z.object({ path: z.string().min(1) });
+const WRITE_FILE_INPUT = z.object({ path: z.string().min(1), content: z.string() });
+const LIST_DIR_INPUT = z.object({ path: z.string().default(".") });
+const RUN_BASH_INPUT = z.object({ command: z.string().min(1) });
+function backendContext(workspaceRoot, signal) {
+    return { signal, workspaceRoot };
+}
+async function gatePathOp(permissions, operation, absPath, workspaceRoot) {
+    // If permissions store is absent, allow (legacy behavior — capability used without permissions context).
+    if (!permissions)
+        return { allowed: true };
+    if (permissions.mode === "bypass")
+        return { allowed: true };
+    const insideWorkspace = absPath === workspaceRoot || absPath.startsWith(workspaceRoot + sep);
+    // Inside workspace: always allow silently.
+    if (insideWorkspace)
+        return { allowed: true };
+    // Outside workspace: consult the store.
+    const decision = permissions.match(operation, absPath);
+    if (decision === "allow")
+        return { allowed: true };
+    if (decision === "deny") {
+        return { allowed: false, reason: `Permission denied by user: ${absPath}` };
+    }
+    // decision === "unknown"
+    if (permissions.mode === "non-interactive") {
+        return { allowed: false, reason: `Permission denied (fail-closed): ${absPath}` };
+    }
+    // Interactive: emit LangGraph interrupt and await user decision.
+    const result = await emitPermissionInterrupt({
+        kind: "path",
+        operation,
+        path: absPath,
+        permissions,
+    });
+    if (result === "deny") {
+        return { allowed: false, reason: `Permission denied by user: ${absPath}` };
+    }
+    return { allowed: true };
+}
+async function gateBashOp(permissions, command) {
+    if (!permissions)
+        return { allowed: true };
+    if (permissions.mode === "bypass")
+        return { allowed: true };
+    const decision = permissions.match("bash", command);
+    if (decision === "allow")
+        return { allowed: true };
+    if (decision === "deny") {
+        return { allowed: false, reason: `Permission denied by user: ${command}` };
+    }
+    if (permissions.mode === "non-interactive") {
+        return { allowed: false, reason: `Permission denied (fail-closed): ${command}` };
+    }
+    const result = await emitPermissionInterrupt({
+        kind: "command",
+        command,
+        permissions,
+    });
+    if (result === "deny") {
+        return { allowed: false, reason: `Permission denied by user: ${command}` };
+    }
+    return { allowed: true };
+}
+async function emitPermissionInterrupt(args) {
+    const interruptId = `perm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const suggestedPattern = args.kind === "command"
+        ? suggestedCommandPattern(args.command ?? "")
+        : suggestedPathPattern(args.path ?? "");
+    const payload = {
+        interruptId,
+        type: "permission-request",
+        kind: args.kind,
+        detail: args.kind === "command"
+            ? { command: args.command ?? "", suggestedPattern }
+            : {
+                operation: args.operation ?? "readFile",
+                path: args.path ?? "",
+                suggestedPattern,
+            },
+    };
+    const decision = interrupt(payload);
+    if (decision === "deny")
+        return "deny";
+    if (decision === "always") {
+        const tool = args.kind === "command" ? "bash" : (args.operation ?? "readFile");
+        await args.permissions.addAllow(tool, suggestedPattern);
+    }
+    return "allow";
+}
+function buildWorkspaceTools(workspaceRoot, fs, exec, permissions) {
+    const readFile = {
+        name: "readFile",
+        description: "Read a UTF-8 file from the workspace.",
+        schema: READ_FILE_INPUT,
+        overridable: true,
+        run: async (input, ctx) => {
+            const { path } = READ_FILE_INPUT.parse(input);
+            const absPath = resolve(workspaceRoot, path);
+            const gate = await gatePathOp(permissions, "readFile", absPath, workspaceRoot);
+            if (!gate.allowed) {
+                throw new Error(gate.reason);
+            }
+            return fs.readFile(absPath, backendContext(workspaceRoot, ctx.signal));
+        },
+    };
+    const writeFile = {
+        name: "writeFile",
+        description: "Write a UTF-8 file inside the workspace.",
+        schema: WRITE_FILE_INPUT,
+        overridable: true,
+        run: async (input, ctx) => {
+            const { path, content } = WRITE_FILE_INPUT.parse(input);
+            const absPath = resolve(workspaceRoot, path);
+            const gate = await gatePathOp(permissions, "writeFile", absPath, workspaceRoot);
+            if (!gate.allowed) {
+                throw new Error(gate.reason);
+            }
+            const result = await fs.writeFile(absPath, content, backendContext(workspaceRoot, ctx.signal));
+            return `wrote ${result.bytesWritten} bytes to ${path}`;
+        },
+    };
+    const listDir = {
+        name: "listDir",
+        description: "List entries in a workspace directory.",
+        schema: LIST_DIR_INPUT,
+        overridable: true,
+        run: async (input, ctx) => {
+            const { path } = LIST_DIR_INPUT.parse(input);
+            const absPath = resolve(workspaceRoot, path);
+            const gate = await gatePathOp(permissions, "listDir", absPath, workspaceRoot);
+            if (!gate.allowed) {
+                throw new Error(gate.reason);
+            }
+            const entries = await fs.listDir(absPath, backendContext(workspaceRoot, ctx.signal));
+            return [...entries];
+        },
+    };
+    const runBash = {
+        name: "runBash",
+        description: "Run a shell command inside the workspace.",
+        schema: RUN_BASH_INPUT,
+        overridable: true,
+        run: async (input, ctx) => {
+            const { command } = RUN_BASH_INPUT.parse(input);
+            const gate = await gateBashOp(permissions, command);
+            if (!gate.allowed) {
+                throw new Error(gate.reason);
+            }
+            return exec.runCommand({ command }, backendContext(workspaceRoot, ctx.signal));
+        },
+    };
+    return [readFile, writeFile, listDir, runBash];
+}
+export function createWorkspaceMarker() {
+    return {
+        name: "workspace",
+        detect: async (_routeDir, _context) => existsSync(workspaceRoot()),
+        load: async (_routeDir, context) => {
+            const root = workspaceRoot();
+            if (!existsSync(root))
+                return {};
+            const fs = context.backends?.filesystem ?? localFilesystem();
+            const exec = context.backends?.exec ?? localExec();
+            const permissions = context.permissions;
+            if (permissions?.mode === "bypass") {
+                console.warn("[dawn:permissions] mode=bypass — path-jail disabled, all bash unrestricted. Do not use in production.");
+            }
+            return { tools: buildWorkspaceTools(root, fs, exec, permissions) };
+        },
+    };
+}

package/dist/capabilities/registry.d.ts

@@ -0,0 +1,21 @@
+import type { CapabilityContribution, CapabilityMarker, CapabilityMarkerContext } from "./types.js";
+export type { CapabilityMarker, CapabilityMarkerContext };
+export interface CapabilityRegistry {
+    readonly markers: ReadonlyArray<CapabilityMarker>;
+}
+export interface AppliedContribution {
+    readonly markerName: string;
+    readonly contribution: CapabilityContribution;
+}
+export interface CapabilityError {
+    readonly markerName: string;
+    readonly phase: "detect" | "load";
+    readonly message: string;
+}
+export interface ApplyResult {
+    readonly contributions: ReadonlyArray<AppliedContribution>;
+    readonly errors: ReadonlyArray<CapabilityError>;
+}
+export declare function createCapabilityRegistry(markers: ReadonlyArray<CapabilityMarker>): CapabilityRegistry;
+export declare function applyCapabilities(registry: CapabilityRegistry, routeDir: string, context: CapabilityMarkerContext): Promise<ApplyResult>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/capabilities/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/capabilities/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAA;AAEnG,YAAY,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,CAAA;AAEzD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAA;CAClD;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,YAAY,EAAE,sBAAsB,CAAA;CAC9C;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAA;IAC1D,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,eAAe,CAAC,CAAA;CAChD;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,aAAa,CAAC,gBAAgB,CAAC,GACvC,kBAAkB,CAEpB;AAED,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,kBAAkB,EAC5B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,WAAW,CAAC,CAgCtB"}

package/dist/capabilities/registry.js

@@ -0,0 +1,35 @@
+export function createCapabilityRegistry(markers) {
+    return { markers };
+}
+export async function applyCapabilities(registry, routeDir, context) {
+    const contributions = [];
+    const errors = [];
+    for (const marker of registry.markers) {
+        let detected;
+        try {
+            detected = await marker.detect(routeDir, context);
+        }
+        catch (error) {
+            errors.push({
+                markerName: marker.name,
+                phase: "detect",
+                message: error instanceof Error ? error.message : String(error),
+            });
+            continue;
+        }
+        if (!detected)
+            continue;
+        try {
+            const contribution = await marker.load(routeDir, context);
+            contributions.push({ markerName: marker.name, contribution });
+        }
+        catch (error) {
+            errors.push({
+                markerName: marker.name,
+                phase: "load",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return { contributions, errors };
+}

package/dist/capabilities/types.d.ts

@@ -0,0 +1,56 @@
+import type { PermissionsStore } from "@dawn-ai/permissions";
+import type { DawnAgent } from "@dawn-ai/sdk";
+import type { ExecBackend, FilesystemBackend } from "@dawn-ai/workspace";
+import type { ResolvedStateField, RouteManifest } from "../types.js";
+export interface CapabilityMarkerContext {
+    readonly routeManifest: RouteManifest;
+    readonly descriptor: DawnAgent | undefined;
+    readonly descriptorRouteMap?: ReadonlyMap<DawnAgent, string>;
+    readonly backends?: {
+        readonly filesystem?: FilesystemBackend;
+        readonly exec?: ExecBackend;
+    };
+    readonly permissions?: PermissionsStore;
+}
+export interface DawnToolDefinition {
+    readonly description?: string;
+    readonly name: string;
+    readonly run: (input: unknown, context: {
+        readonly middleware?: Readonly<Record<string, unknown>>;
+        readonly signal: AbortSignal;
+    }) => Promise<unknown> | unknown;
+    readonly schema?: unknown;
+}
+export interface PromptFragment {
+    readonly placement: "after_user_prompt";
+    /**
+     * Render this fragment given the current state of the agent's channels.
+     * Called every model turn so the rendered text can reflect live state
+     * (e.g., the current todos list is re-injected each turn).
+     */
+    readonly render: (state: Readonly<Record<string, unknown>>) => string;
+}
+export interface StreamTransformerInput {
+    readonly toolName: string;
+    readonly toolOutput: unknown;
+}
+export interface StreamTransformerOutput {
+    readonly event: string;
+    readonly data: unknown;
+}
+export interface StreamTransformer {
+    readonly observes: "tool_result";
+    readonly transform: (input: StreamTransformerInput) => Iterable<StreamTransformerOutput> | AsyncIterable<StreamTransformerOutput>;
+}
+export interface CapabilityContribution {
+    readonly tools?: ReadonlyArray<DawnToolDefinition>;
+    readonly stateFields?: ReadonlyArray<ResolvedStateField>;
+    readonly promptFragment?: PromptFragment;
+    readonly streamTransformers?: ReadonlyArray<StreamTransformer>;
+}
+export interface CapabilityMarker {
+    readonly name: string;
+    readonly detect: (routeDir: string, context: CapabilityMarkerContext) => Promise<boolean>;
+    readonly load: (routeDir: string, context: CapabilityMarkerContext) => Promise<CapabilityContribution>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/capabilities/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/capabilities/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEpE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAA;IACrC,QAAQ,CAAC,UAAU,EAAE,SAAS,GAAG,SAAS,CAAA;IAC1C,QAAQ,CAAC,kBAAkB,CAAC,EAAE,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,CAAA;IAC5D,QAAQ,CAAC,QAAQ,CAAC,EAAE;QAClB,QAAQ,CAAC,UAAU,CAAC,EAAE,iBAAiB,CAAA;QACvC,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,CAAA;KAC5B,CAAA;IACD,QAAQ,CAAC,WAAW,CAAC,EAAE,gBAAgB,CAAA;CACxC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,CACZ,KAAK,EAAE,OAAO,EACd,OAAO,EAAE;QACP,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;QACvD,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;KAC7B,KACE,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAA;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAA;IACvC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,MAAM,CAAA;CACtE;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;CAC7B;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAA;IAChC,QAAQ,CAAC,SAAS,EAAE,CAClB,KAAK,EAAE,sBAAsB,KAC1B,QAAQ,CAAC,uBAAuB,CAAC,GAAG,aAAa,CAAC,uBAAuB,CAAC,CAAA;CAChF;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAA;IAClD,QAAQ,CAAC,WAAW,CAAC,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAA;IACxD,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAA;IACxC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;CAC/D;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,uBAAuB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACzF,QAAQ,CAAC,IAAI,EAAE,CACb,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,uBAAuB,KAC7B,OAAO,CAAC,sBAAsB,CAAC,CAAA;CACrC"}

package/dist/capabilities/types.js

@@ -0,0 +1 @@
+export {};

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAc,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAErF,eAAO,MAAM,gBAAgB,mBAAmB,CAAA;AAsBhD,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAY9F"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAc,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAErF,eAAO,MAAM,gBAAgB,mBAAmB,CAAA;AAchD,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAkB9F"}

package/dist/config.js

@@ -1,225 +1,27 @@
 import { constants } from "node:fs";
-import { access, readFile } from "node:fs/promises";
+import { access } from "node:fs/promises";
 import { join } from "node:path";
+import { pathToFileURL } from "node:url";
 export const DAWN_CONFIG_FILE = "dawn.config.ts";
+let loaderPromise;
+async function registerTsxLoader() {
+    loaderPromise ??= (async () => {
+        const { register } = (await import("tsx/esm/api"));
+        register();
+    })();
+    await loaderPromise;
+}
 export async function loadDawnConfig(options) {
     const configPath = join(options.appRoot, DAWN_CONFIG_FILE);
     await access(configPath, constants.F_OK);
-    const source = await readFile(configPath, "utf8");
+    await registerTsxLoader();
+    const mod = (await import(pathToFileURL(configPath).href));
+    if (!mod.default || typeof mod.default !== "object") {
+        throw new Error(`${DAWN_CONFIG_FILE} must export default an object. Got: ${typeof mod.default}`);
+    }
     return {
         appRoot: options.appRoot,
-        config: parseDawnConfig(source),
+        config: mod.default,
         configPath,
     };
 }
-function parseDawnConfig(source) {
-    const parser = new DawnConfigParser(source);
-    return parser.parse();
-}
-class DawnConfigParser {
-    tokens;
-    currentIndex = 0;
-    stringBindings = new Map();
-    constructor(source) {
-        this.tokens = tokenize(source);
-    }
-    parse() {
-        while (this.match("const")) {
-            this.parseConstDeclaration();
-            this.consumeOptional("semicolon");
-        }
-        this.consume("export");
-        this.consume("default");
-        const config = this.parseConfigObject();
-        this.consumeOptional("semicolon");
-        this.consume("eof");
-        return config;
-    }
-    parseConstDeclaration() {
-        const identifier = this.consume("identifier");
-        this.consume("equals");
-        const value = this.consume("string");
-        this.stringBindings.set(identifier.value, value.value);
-    }
-    parseConfigObject() {
-        this.consume("lbrace");
-        let appDir;
-        while (!this.check("rbrace")) {
-            const property = this.consume("identifier");
-            if (property.value !== "appDir") {
-                throw unsupportedConfig(`unsupported property "${property.value}"`);
-            }
-            const resolvedValue = this.match("colon")
-                ? this.parsePropertyValue()
-                : this.resolveIdentifier(property.value);
-            appDir = resolvedValue;
-            if (!this.match("comma")) {
-                break;
-            }
-        }
-        this.consume("rbrace");
-        return appDir ? { appDir } : {};
-    }
-    parsePropertyValue() {
-        if (this.check("string")) {
-            return this.consume("string").value;
-        }
-        if (this.check("identifier")) {
-            return this.resolveIdentifier(this.consume("identifier").value);
-        }
-        throw unsupportedConfig("property values must be string literals or const identifiers");
-    }
-    resolveIdentifier(identifier) {
-        const resolved = this.stringBindings.get(identifier);
-        if (!resolved) {
-            throw unsupportedConfig(`unknown identifier "${identifier}"`);
-        }
-        return resolved;
-    }
-    match(type) {
-        if (!this.check(type)) {
-            return false;
-        }
-        this.currentIndex += 1;
-        return true;
-    }
-    consume(type) {
-        const token = this.peek();
-        if (token.type !== type) {
-            throw unsupportedConfig(`expected ${type} but found ${describeToken(token)}`);
-        }
-        this.currentIndex += 1;
-        return token;
-    }
-    consumeOptional(type) {
-        this.match(type);
-    }
-    check(type) {
-        return this.peek().type === type;
-    }
-    peek() {
-        return this.tokens[this.currentIndex] ?? { type: "eof" };
-    }
-}
-function tokenize(source) {
-    const tokens = [];
-    let index = source.startsWith("\uFEFF") ? 1 : 0;
-    while (index < source.length) {
-        const character = source[index];
-        if (!character) {
-            break;
-        }
-        if (isWhitespace(character)) {
-            index += 1;
-            continue;
-        }
-        if (character === "/" && source[index + 1] === "/") {
-            index += 2;
-            while (index < source.length && source[index] !== "\n") {
-                index += 1;
-            }
-            continue;
-        }
-        if (character === "/" && source[index + 1] === "*") {
-            const commentEnd = source.indexOf("*/", index + 2);
-            if (commentEnd === -1) {
-                throw unsupportedConfig("unterminated block comment");
-            }
-            index = commentEnd + 2;
-            continue;
-        }
-        if (character === "{") {
-            tokens.push({ type: "lbrace" });
-            index += 1;
-            continue;
-        }
-        if (character === "}") {
-            tokens.push({ type: "rbrace" });
-            index += 1;
-            continue;
-        }
-        if (character === ":") {
-            tokens.push({ type: "colon" });
-            index += 1;
-            continue;
-        }
-        if (character === ",") {
-            tokens.push({ type: "comma" });
-            index += 1;
-            continue;
-        }
-        if (character === "=") {
-            tokens.push({ type: "equals" });
-            index += 1;
-            continue;
-        }
-        if (character === ";") {
-            tokens.push({ type: "semicolon" });
-            index += 1;
-            continue;
-        }
-        if (character === '"' || character === "'") {
-            const [value, nextIndex] = readStringLiteral(source, index, character);
-            tokens.push({ type: "string", value });
-            index = nextIndex;
-            continue;
-        }
-        if (isIdentifierStart(character)) {
-            const [identifier, nextIndex] = readIdentifier(source, index);
-            index = nextIndex;
-            if (identifier === "const" || identifier === "export" || identifier === "default") {
-                tokens.push({ type: identifier });
-            }
-            else {
-                tokens.push({ type: "identifier", value: identifier });
-            }
-            continue;
-        }
-        throw unsupportedConfig(`unexpected token "${character}"`);
-    }
-    tokens.push({ type: "eof" });
-    return tokens;
-}
-function readStringLiteral(source, startIndex, quote) {
-    let index = startIndex + 1;
-    let value = "";
-    while (index < source.length) {
-        const character = source[index];
-        if (!character) {
-            break;
-        }
-        if (character === "\\") {
-            throw unsupportedConfig("escaped string literals are not supported");
-        }
-        if (character === quote) {
-            return [value, index + 1];
-        }
-        value += character;
-        index += 1;
-    }
-    throw unsupportedConfig("unterminated string literal");
-}
-function readIdentifier(source, startIndex) {
-    let index = startIndex + 1;
-    while (index < source.length && isIdentifierPart(source[index] ?? "")) {
-        index += 1;
-    }
-    return [source.slice(startIndex, index), index];
-}
-function isIdentifierStart(character) {
-    return /[A-Za-z_$]/.test(character);
-}
-function isIdentifierPart(character) {
-    return /[A-Za-z0-9_$]/.test(character);
-}
-function isWhitespace(character) {
-    return /\s/.test(character);
-}
-function describeToken(token) {
-    return token.type === "identifier" || token.type === "string"
-        ? `${token.type} "${token.value}"`
-        : token.type;
-}
-function unsupportedConfig(reason) {
-    return new Error(`Unsupported dawn.config.ts syntax: ${reason}. Supported subset: optional const string declarations followed by export default { appDir } or export default { appDir: "..." }.`);
-}

package/dist/index.d.ts

@@ -1,3 +1,13 @@
+export type { ThreadsStore } from "@dawn-ai/sqlite-storage";
+export { createAgentsMdMarker } from "./capabilities/built-in/agents-md.js";
+export type { RuntimeTodo } from "./capabilities/built-in/planning.js";
+export { createPlanningMarker } from "./capabilities/built-in/planning.js";
+export { createSkillsMarker } from "./capabilities/built-in/skills.js";
+export { createSubagentsMarker } from "./capabilities/built-in/subagents.js";
+export { createWorkspaceMarker } from "./capabilities/built-in/workspace.js";
+export type { AppliedContribution, ApplyResult, CapabilityError, CapabilityRegistry, } from "./capabilities/registry.js";
+export { applyCapabilities, createCapabilityRegistry } from "./capabilities/registry.js";
+export type { CapabilityContribution, CapabilityMarker, CapabilityMarkerContext, DawnToolDefinition, PromptFragment, StreamTransformer, StreamTransformerInput, StreamTransformerOutput, } from "./capabilities/types.js";
 export { loadDawnConfig } from "./config.js";
 export { discoverRoutes } from "./discovery/discover-routes.js";
 export { assertDawnRoutesDir, findDawnApp } from "./discovery/find-dawn-app.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAC/D,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA;AAC/E,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,eAAe,GAChB,MAAM,+BAA+B,CAAA;AACtC,YAAY,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAA;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AACpE,YAAY,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAA;AACjF,OAAO,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAA;AAC7E,YAAY,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAA;AAC9E,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAA;AAC1E,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AACnF,YAAY,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAChE,YAAY,EACV,UAAU,EACV,iBAAiB,EACjB,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,eAAe,EACf,SAAS,EACT,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,iBAAiB,GAClB,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAA;AAC3E,YAAY,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAA;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAA;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAA;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAA;AAC5E,YAAY,EACV,mBAAmB,EACnB,WAAW,EACX,eAAe,EACf,kBAAkB,GACnB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAA;AACxF,YAAY,EACV,sBAAsB,EACtB,gBAAgB,EAChB,uBAAuB,EACvB,kBAAkB,EAClB,cAAc,EACd,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,GACxB,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAC/D,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA;AAC/E,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,eAAe,GAChB,MAAM,+BAA+B,CAAA;AACtC,YAAY,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAA;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AACpE,YAAY,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAA;AACjF,OAAO,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAA;AAC7E,YAAY,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAA;AAC9E,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAA;AAC1E,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AACnF,YAAY,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAChE,YAAY,EACV,UAAU,EACV,iBAAiB,EACjB,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,eAAe,EACf,SAAS,EACT,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,iBAAiB,GAClB,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -1,3 +1,9 @@
+export { createAgentsMdMarker } from "./capabilities/built-in/agents-md.js";
+export { createPlanningMarker } from "./capabilities/built-in/planning.js";
+export { createSkillsMarker } from "./capabilities/built-in/skills.js";
+export { createSubagentsMarker } from "./capabilities/built-in/subagents.js";
+export { createWorkspaceMarker } from "./capabilities/built-in/workspace.js";
+export { applyCapabilities, createCapabilityRegistry } from "./capabilities/registry.js";
 export { loadDawnConfig } from "./config.js";
 export { discoverRoutes } from "./discovery/discover-routes.js";
 export { assertDawnRoutesDir, findDawnApp } from "./discovery/find-dawn-app.js";