@dawn-ai/core 0.0.2

package/README.md

@@ -0,0 +1,11 @@
+# @dawn-ai/core
+
+Shared Dawn app discovery, config loading, route validation, and route type generation primitives.
+
+Public surface:
+- `loadDawnConfig()`
+- `findDawnApp()`
+- `discoverRoutes()`
+- `renderRouteTypes()`
+
+This package owns Dawn's filesystem and metadata conventions. It does not provide a graph runtime.

package/dist/config.d.ts

@@ -0,0 +1,4 @@
+import type { LoadDawnConfigOptions, LoadedDawnConfig } from "./types.js";
+export declare const DAWN_CONFIG_FILE = "dawn.config.ts";
+export declare function loadDawnConfig(options: LoadDawnConfigOptions): Promise<LoadedDawnConfig>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +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"}

package/dist/config.js

@@ -0,0 +1,225 @@
+import { constants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { join } from "node:path";
+export const DAWN_CONFIG_FILE = "dawn.config.ts";
+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");
+    return {
+        appRoot: options.appRoot,
+        config: parseDawnConfig(source),
+        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/discovery/discover-routes.d.ts

@@ -0,0 +1,3 @@
+import type { DiscoverRoutesOptions, RouteManifest } from "../types.js";
+export declare function discoverRoutes(options?: DiscoverRoutesOptions): Promise<RouteManifest>;
+//# sourceMappingURL=discover-routes.d.ts.map

package/dist/discovery/discover-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover-routes.d.ts","sourceRoot":"","sources":["../../src/discovery/discover-routes.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAmB,aAAa,EAAE,MAAM,aAAa,CAAA;AAQxF,wBAAsB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,aAAa,CAAC,CAQhG"}

package/dist/discovery/discover-routes.js

@@ -0,0 +1,114 @@
+import { readdir } from "node:fs/promises";
+import { join, relative, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { findDawnApp } from "./find-dawn-app.js";
+import { isPrivateSegment, isRouteGroupSegment, toRouteSegments } from "./route-segments.js";
+const INDEX_FILE = "index.ts";
+let loaderPromise;
+export async function discoverRoutes(options = {}) {
+    const app = await findDawnApp(options);
+    const routes = validateRouteCollisions(await collectRouteDefinitions(app.routesDir));
+    return {
+        appRoot: app.appRoot,
+        routes: routes.sort((left, right) => left.pathname.localeCompare(right.pathname)),
+    };
+}
+async function collectRouteDefinitions(routesDir) {
+    const discovered = [];
+    await walkRouteTree(routesDir, routesDir, discovered);
+    return discovered;
+}
+async function walkRouteTree(routesDir, currentDir, discovered) {
+    const routeEntry = await readRouteEntry(routesDir, currentDir);
+    if (routeEntry) {
+        discovered.push(routeEntry);
+    }
+    const entries = (await readdir(currentDir, { withFileTypes: true })).sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+        if (!entry.isDirectory() || isPrivateSegment(entry.name)) {
+            continue;
+        }
+        await walkRouteTree(routesDir, join(currentDir, entry.name), discovered);
+    }
+}
+async function readRouteEntry(routesDir, routeDir) {
+    const entries = await readdir(routeDir, { withFileTypes: true }).catch(() => null);
+    if (!entries) {
+        return null;
+    }
+    const hasIndex = entries.some((entry) => entry.isFile() && entry.name === INDEX_FILE);
+    if (!hasIndex) {
+        return null;
+    }
+    const indexFile = resolve(routeDir, INDEX_FILE);
+    const kind = await inferRouteKind(indexFile);
+    if (!kind) {
+        return null;
+    }
+    const routeSegments = relative(routesDir, routeDir)
+        .split(sep)
+        .filter(Boolean)
+        .filter((segment) => !isRouteGroupSegment(segment));
+    return {
+        id: toPathname(routeSegments),
+        pathname: toPathname(routeSegments),
+        kind,
+        entryFile: indexFile,
+        routeDir,
+        segments: toRouteSegments(routeSegments),
+    };
+}
+async function inferRouteKind(indexFile) {
+    await registerTsxLoader();
+    const routeExports = await loadRouteExports(indexFile);
+    const hasChain = "chain" in routeExports && routeExports.chain !== undefined;
+    const hasGraph = "graph" in routeExports && routeExports.graph !== undefined;
+    const hasWorkflow = "workflow" in routeExports && routeExports.workflow !== undefined;
+    const count = [hasChain, hasGraph, hasWorkflow].filter(Boolean).length;
+    if (count > 1) {
+        throw new Error(`Route index.ts must export exactly one of "workflow", "graph", or "chain"`);
+    }
+    if (hasChain) {
+        return "chain";
+    }
+    if (hasGraph) {
+        return "graph";
+    }
+    if (hasWorkflow) {
+        return "workflow";
+    }
+    return null;
+}
+async function loadRouteExports(indexFile) {
+    try {
+        return (await import(pathToFileURL(indexFile).href));
+    }
+    catch (cause) {
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        throw new Error(`Failed to load route at ${indexFile}: ${reason}`, { cause });
+    }
+}
+async function registerTsxLoader() {
+    loaderPromise ??= (async () => {
+        const { register } = (await import("tsx/esm/api"));
+        register();
+    })();
+    await loaderPromise;
+}
+function validateRouteCollisions(routes) {
+    const byPathname = new Map();
+    for (const route of routes) {
+        const existingRoute = byPathname.get(route.pathname);
+        if (existingRoute) {
+            throw new Error(`Duplicate Dawn route pathname "${route.pathname}" detected at ${existingRoute.routeDir} and ${route.routeDir}`);
+        }
+        byPathname.set(route.pathname, route);
+    }
+    return [...routes];
+}
+function toPathname(routeSegments) {
+    if (routeSegments.length === 0) {
+        return "/";
+    }
+    return `/${routeSegments.join("/")}`;
+}

package/dist/discovery/find-dawn-app.d.ts

@@ -0,0 +1,4 @@
+import type { DiscoveredDawnApp, FindDawnAppOptions } from "../types.js";
+export declare function findDawnApp(options?: FindDawnAppOptions): Promise<DiscoveredDawnApp>;
+export declare function assertDawnRoutesDir(appRoot: string, routesDir?: string): Promise<void>;
+//# sourceMappingURL=find-dawn-app.d.ts.map

package/dist/discovery/find-dawn-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-dawn-app.d.ts","sourceRoot":"","sources":["../../src/discovery/find-dawn-app.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAMxE,wBAAsB,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAgB9F;AAiCD,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,SAAS,SAAiC,GACzC,OAAO,CAAC,IAAI,CAAC,CAMf"}

package/dist/discovery/find-dawn-app.js

@@ -0,0 +1,58 @@
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { DAWN_CONFIG_FILE, loadDawnConfig } from "../config.js";
+const PACKAGE_JSON_FILE = "package.json";
+const DEFAULT_APP_DIR = "src/app";
+const DAWN_DIR = ".dawn";
+export async function findDawnApp(options = {}) {
+    const appRoot = options.appRoot ? resolve(options.appRoot) : await findAppRootFromCwd(options.cwd);
+    await assertDawnAppFiles(appRoot);
+    const loadedConfig = await loadDawnConfig({ appRoot });
+    const routesDir = resolve(appRoot, loadedConfig.config.appDir ?? DEFAULT_APP_DIR);
+    await assertDawnRoutesDir(appRoot, routesDir);
+    const dawnDir = join(appRoot, DAWN_DIR);
+    return {
+        appRoot,
+        configPath: loadedConfig.configPath,
+        dawnDir,
+        routesDir,
+    };
+}
+async function findAppRootFromCwd(cwd = process.cwd()) {
+    let currentDir = resolve(cwd);
+    while (true) {
+        if ((await fileExists(join(currentDir, DAWN_CONFIG_FILE))) &&
+            (await fileExists(join(currentDir, PACKAGE_JSON_FILE)))) {
+            return currentDir;
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir) {
+            throw new Error(`Could not find ${DAWN_CONFIG_FILE} from ${cwd}`);
+        }
+        currentDir = parentDir;
+    }
+}
+async function assertDawnAppFiles(appRoot) {
+    const missingPaths = await Promise.all([join(appRoot, PACKAGE_JSON_FILE), join(appRoot, DAWN_CONFIG_FILE)].map(async (filePath) => (await fileExists(filePath)) ? null : filePath));
+    throwIfMissing(appRoot, missingPaths);
+}
+export async function assertDawnRoutesDir(appRoot, routesDir = join(appRoot, DEFAULT_APP_DIR)) {
+    const missingPaths = await Promise.all([routesDir].map(async (filePath) => ((await fileExists(filePath)) ? null : filePath)));
+    throwIfMissing(appRoot, missingPaths);
+}
+function throwIfMissing(appRoot, missingPaths) {
+    const missing = missingPaths.filter((value) => value !== null);
+    if (missing.length > 0) {
+        throw new Error(`Invalid Dawn app at ${appRoot}. Missing: ${missing.join(", ")}`);
+    }
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/discovery/load-authoring-route-definition.d.ts

@@ -0,0 +1,9 @@
+export interface ResolvedAuthoringRouteDefinition {
+    readonly entry: "./graph.ts" | "./workflow.ts";
+    readonly executableFile: string;
+    readonly kind: "graph" | "workflow";
+    readonly routeDefinitionFile: string;
+    readonly routeDir: string;
+}
+export declare function loadAuthoringRouteDefinition(routeDefinitionFile: string): Promise<ResolvedAuthoringRouteDefinition | null>;
+//# sourceMappingURL=load-authoring-route-definition.d.ts.map

package/dist/discovery/load-authoring-route-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-authoring-route-definition.d.ts","sourceRoot":"","sources":["../../src/discovery/load-authoring-route-definition.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,eAAe,CAAA;IAC9C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAAA;IACnC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAA;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED,wBAAsB,4BAA4B,CAChD,mBAAmB,EAAE,MAAM,GAC1B,OAAO,CAAC,gCAAgC,GAAG,IAAI,CAAC,CAwDlD"}

package/dist/discovery/load-authoring-route-definition.js

@@ -0,0 +1,57 @@
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+let loaderPromise;
+const TSX_MODULE = "tsx";
+export async function loadAuthoringRouteDefinition(routeDefinitionFile) {
+    if (!(await fileExists(routeDefinitionFile))) {
+        return null;
+    }
+    await registerTsxLoader();
+    const routeModule = (await import(pathToFileURL(routeDefinitionFile).href));
+    const definition = routeModule.route ?? routeModule.default;
+    if (!isRecord(definition)) {
+        throw new Error(`Route definition ${routeDefinitionFile} must export a Dawn route definition`);
+    }
+    const routeDir = dirname(routeDefinitionFile);
+    const kind = definition.kind;
+    const entry = definition.entry;
+    if (kind !== "graph" && kind !== "workflow") {
+        throw new Error(`Route definition ${routeDefinitionFile} must define kind as "graph" or "workflow"`);
+    }
+    if (entry !== "./graph.ts" && entry !== "./workflow.ts") {
+        throw new Error(`Route definition ${routeDefinitionFile} kind "${kind}" must bind entry "./${kind}.ts", received ${JSON.stringify(entry)}`);
+    }
+    if ((kind === "graph" && entry !== "./graph.ts") ||
+        (kind === "workflow" && entry !== "./workflow.ts")) {
+        throw new Error(`Route definition ${routeDefinitionFile} kind "${kind}" must bind entry "./${kind}.ts", received ${JSON.stringify(entry)}`);
+    }
+    const executableFile = resolve(routeDir, entry.slice(2));
+    if (!(await fileExists(executableFile))) {
+        throw new Error(`Route definition ${routeDefinitionFile} binds to missing executable file: ${executableFile}`);
+    }
+    return {
+        entry,
+        executableFile,
+        kind,
+        routeDefinitionFile,
+        routeDir,
+    };
+}
+async function registerTsxLoader() {
+    loaderPromise ??= import(TSX_MODULE).then(() => undefined);
+    await loaderPromise;
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/discovery/route-segments.d.ts

@@ -0,0 +1,5 @@
+import type { RouteSegment } from "../types.js";
+export declare function isRouteGroupSegment(segment: string): boolean;
+export declare function isPrivateSegment(segment: string): boolean;
+export declare function toRouteSegments(routeSegments: readonly string[]): RouteSegment[];
+//# sourceMappingURL=route-segments.d.ts.map

package/dist/discovery/route-segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-segments.d.ts","sourceRoot":"","sources":["../../src/discovery/route-segments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,wBAAgB,eAAe,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,YAAY,EAAE,CAEhF"}

package/dist/discovery/route-segments.js

@@ -0,0 +1,36 @@
+export function isRouteGroupSegment(segment) {
+    return segment.startsWith("(") && segment.endsWith(")");
+}
+export function isPrivateSegment(segment) {
+    return segment.startsWith("_");
+}
+export function toRouteSegments(routeSegments) {
+    return routeSegments.map((segment) => parseRouteSegment(segment));
+}
+function parseRouteSegment(segment) {
+    if (segment.startsWith("[[...") && segment.endsWith("]]")) {
+        return {
+            kind: "optional-catchall",
+            name: segment.slice(5, -2),
+            raw: segment,
+        };
+    }
+    if (segment.startsWith("[...") && segment.endsWith("]")) {
+        return {
+            kind: "catchall",
+            name: segment.slice(4, -1),
+            raw: segment,
+        };
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+        return {
+            kind: "dynamic",
+            name: segment.slice(1, -1),
+            raw: segment,
+        };
+    }
+    return {
+        kind: "static",
+        raw: segment,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { loadDawnConfig } from "./config.js";
+export { discoverRoutes } from "./discovery/discover-routes.js";
+export { assertDawnRoutesDir, findDawnApp } from "./discovery/find-dawn-app.js";
+export { isPrivateSegment, isRouteGroupSegment, toRouteSegments, } from "./discovery/route-segments.js";
+export type { ExtractToolTypesOptions } from "./typegen/extract-tool-types.js";
+export { extractToolTypesForRoute } from "./typegen/extract-tool-types.js";
+export { renderDawnTypes, renderRouteTypes } from "./typegen/render-route-types.js";
+export { renderToolTypes } from "./typegen/render-tool-types.js";
+export type { DawnConfig, DiscoveredDawnApp, DiscoverRoutesOptions, ExtractedToolType, FindDawnAppOptions, LoadDawnConfigOptions, LoadedDawnConfig, RouteDefinition, RouteKind, RouteManifest, RouteSegment, RouteToolTypes, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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,uBAAuB,EAAE,MAAM,iCAAiC,CAAA;AAC9E,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAA;AAC1E,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AACnF,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAChE,YAAY,EACV,UAAU,EACV,iBAAiB,EACjB,qBAAqB,EACrB,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,eAAe,EACf,SAAS,EACT,aAAa,EACb,YAAY,EACZ,cAAc,GACf,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export { loadDawnConfig } from "./config.js";
+export { discoverRoutes } from "./discovery/discover-routes.js";
+export { assertDawnRoutesDir, findDawnApp } from "./discovery/find-dawn-app.js";
+export { isPrivateSegment, isRouteGroupSegment, toRouteSegments, } from "./discovery/route-segments.js";
+export { extractToolTypesForRoute } from "./typegen/extract-tool-types.js";
+export { renderDawnTypes, renderRouteTypes } from "./typegen/render-route-types.js";
+export { renderToolTypes } from "./typegen/render-tool-types.js";

package/dist/typegen/extract-tool-types.d.ts

@@ -0,0 +1,7 @@
+import type { ExtractedToolType } from "../types.js";
+export interface ExtractToolTypesOptions {
+    readonly routeDir: string;
+    readonly sharedToolsDir: string | undefined;
+}
+export declare function extractToolTypesForRoute(options: ExtractToolTypesOptions): Promise<readonly ExtractedToolType[]>;
+//# sourceMappingURL=extract-tool-types.d.ts.map

package/dist/typegen/extract-tool-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-tool-types.d.ts","sourceRoot":"","sources":["../../src/typegen/extract-tool-types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAEpD,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;CAC5C;AAED,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAsEvC"}

package/dist/typegen/extract-tool-types.js

@@ -0,0 +1,93 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import ts from "typescript";
+export async function extractToolTypesForRoute(options) {
+    const routeToolFiles = discoverToolFiles(join(options.routeDir, "tools"));
+    const sharedToolFiles = options.sharedToolsDir
+        ? discoverToolFiles(join(options.sharedToolsDir, "tools"))
+        : new Map();
+    // Merge: route-local tools shadow shared tools
+    const merged = new Map(sharedToolFiles);
+    for (const [name, filePath] of routeToolFiles) {
+        merged.set(name, filePath);
+    }
+    if (merged.size === 0)
+        return [];
+    const allFilePaths = [...merged.values()];
+    const compilerOptions = {
+        target: ts.ScriptTarget.ES2022,
+        module: ts.ModuleKind.ESNext,
+        moduleResolution: ts.ModuleResolutionKind.Bundler,
+        strict: true,
+        noEmit: true,
+        lib: ["lib.es2022.d.ts"],
+    };
+    const program = ts.createProgram(allFilePaths, compilerOptions);
+    const checker = program.getTypeChecker();
+    const results = [];
+    for (const [name, filePath] of merged) {
+        const sourceFile = program.getSourceFile(filePath);
+        if (!sourceFile)
+            continue;
+        const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+        if (!moduleSymbol)
+            continue;
+        const exports = checker.getExportsOfModule(moduleSymbol);
+        const defaultExport = exports.find((e) => e.escapedName === "default");
+        if (!defaultExport)
+            continue;
+        const exportType = checker.getTypeOfSymbolAtLocation(defaultExport, sourceFile);
+        const signatures = checker.getSignaturesOfType(exportType, ts.SignatureKind.Call);
+        if (signatures.length === 0)
+            continue;
+        const signature = signatures[0];
+        if (!signature)
+            continue;
+        const params = signature.getParameters();
+        let inputType;
+        if (params.length === 0) {
+            inputType = "void";
+        }
+        else {
+            const firstParam = params[0];
+            if (!firstParam)
+                continue;
+            const paramType = checker.getTypeOfSymbolAtLocation(firstParam, sourceFile);
+            inputType = checker.typeToString(paramType);
+        }
+        const returnType = checker.getReturnTypeOfSignature(signature);
+        const outputType = unwrapPromise(returnType);
+        results.push({
+            name,
+            inputType,
+            outputType: checker.typeToString(outputType),
+        });
+    }
+    results.sort((a, b) => a.name.localeCompare(b.name));
+    return results;
+}
+function unwrapPromise(type) {
+    const symbol = type.getSymbol();
+    if (symbol && symbol.getName() === "Promise") {
+        const typeArgs = type.typeArguments;
+        if (typeArgs && typeArgs.length > 0 && typeArgs[0]) {
+            return typeArgs[0];
+        }
+    }
+    return type;
+}
+function discoverToolFiles(toolsDir) {
+    const files = new Map();
+    if (!existsSync(toolsDir))
+        return files;
+    const entries = readdirSync(toolsDir);
+    for (const entry of entries) {
+        if (!entry.endsWith(".ts"))
+            continue;
+        if (entry.endsWith(".d.ts"))
+            continue;
+        const name = entry.replace(/\.ts$/, "");
+        files.set(name, join(toolsDir, entry));
+    }
+    return files;
+}

package/dist/typegen/render-route-types.d.ts

@@ -0,0 +1,4 @@
+import type { RouteManifest, RouteToolTypes } from "../types.js";
+export declare function renderDawnTypes(manifest: RouteManifest, toolTypes: readonly RouteToolTypes[]): string;
+export declare function renderRouteTypes(manifest: RouteManifest): string;
+//# sourceMappingURL=render-route-types.d.ts.map

package/dist/typegen/render-route-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-route-types.d.ts","sourceRoot":"","sources":["../../src/typegen/render-route-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAgB,cAAc,EAAE,MAAM,aAAa,CAAA;AAG9E,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,SAAS,cAAc,EAAE,GACnC,MAAM,CA4BR;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CA+BhE"}

package/dist/typegen/render-route-types.js

@@ -0,0 +1,70 @@
+import { renderToolTypes } from "./render-tool-types.js";
+export function renderDawnTypes(manifest, toolTypes) {
+    const pathUnion = manifest.routes.length > 0
+        ? manifest.routes.map((route) => JSON.stringify(route.pathname)).join(" | ")
+        : "never";
+    const paramLines = manifest.routes.map((route) => {
+        const params = renderParamsForSegments(route.segments);
+        return `  ${JSON.stringify(route.pathname)}: ${params};`;
+    });
+    const paramBlock = paramLines.length === 0
+        ? "  export interface DawnRouteParams {}"
+        : ["  export interface DawnRouteParams {", ...paramLines, "  }"].join("\n");
+    const toolBlock = renderToolTypes(toolTypes).trimEnd();
+    return [
+        'declare module "dawn:routes" {',
+        `  export type DawnRoutePath = ${pathUnion};`,
+        "",
+        paramBlock,
+        "",
+        toolBlock,
+        "}",
+        "",
+    ].join("\n");
+}
+export function renderRouteTypes(manifest) {
+    const pathUnion = manifest.routes.length > 0
+        ? manifest.routes.map((route) => JSON.stringify(route.pathname)).join(" | ")
+        : "never";
+    const paramLines = manifest.routes.map((route) => {
+        const params = renderParamsForSegments(route.segments);
+        return `  ${JSON.stringify(route.pathname)}: ${params};`;
+    });
+    if (paramLines.length === 0) {
+        return [
+            'declare module "dawn:routes" {',
+            `  export type DawnRoutePath = ${pathUnion};`,
+            "",
+            "  export interface DawnRouteParams {}",
+            "}",
+            "",
+        ].join("\n");
+    }
+    return [
+        'declare module "dawn:routes" {',
+        `  export type DawnRoutePath = ${pathUnion};`,
+        "",
+        "  export interface DawnRouteParams {",
+        ...paramLines,
+        "  }",
+        "}",
+        "",
+    ].join("\n");
+}
+function renderParamsForSegments(segments) {
+    const params = segments.filter((segment) => segment.kind !== "static");
+    if (params.length === 0) {
+        return "{}";
+    }
+    return `{ ${params.map(renderParam).join("; ")} }`;
+}
+function renderParam(segment) {
+    switch (segment.kind) {
+        case "dynamic":
+            return `${segment.name}: string`;
+        case "catchall":
+            return `${segment.name}: string[]`;
+        case "optional-catchall":
+            return `${segment.name}?: string[]`;
+    }
+}

package/dist/typegen/render-tool-types.d.ts

@@ -0,0 +1,3 @@
+import type { RouteToolTypes } from "../types.js";
+export declare function renderToolTypes(routeTools: readonly RouteToolTypes[]): string;
+//# sourceMappingURL=render-tool-types.d.ts.map

package/dist/typegen/render-tool-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-tool-types.d.ts","sourceRoot":"","sources":["../../src/typegen/render-tool-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAEjD,wBAAgB,eAAe,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,GAAG,MAAM,CAyB7E"}

package/dist/typegen/render-tool-types.js

@@ -0,0 +1,19 @@
+export function renderToolTypes(routeTools) {
+    const routesWithTools = routeTools.filter((r) => r.tools.length > 0);
+    const routeToolsType = "  export type RouteTools<P extends DawnRoutePath> = DawnRouteTools[P];";
+    if (routesWithTools.length === 0) {
+        return ["  export interface DawnRouteTools {}", "", routeToolsType, ""].join("\n");
+    }
+    const routeLines = [];
+    for (const route of routesWithTools) {
+        routeLines.push(`    ${JSON.stringify(route.pathname)}: {`);
+        for (const tool of route.tools) {
+            const sig = tool.inputType === "void"
+                ? `() => Promise<${tool.outputType}>`
+                : `(input: ${tool.inputType}) => Promise<${tool.outputType}>`;
+            routeLines.push(`      readonly ${tool.name}: ${sig};`);
+        }
+        routeLines.push("    };");
+    }
+    return ["  export interface DawnRouteTools {", ...routeLines, "  }", "", routeToolsType, ""].join("\n");
+}

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+import type { RouteKind } from "@dawn-ai/sdk";
+export type { RouteKind };
+export interface DawnConfig {
+    readonly appDir?: string;
+}
+export type RouteSegment = {
+    readonly kind: "static";
+    readonly raw: string;
+} | {
+    readonly kind: "dynamic" | "catchall" | "optional-catchall";
+    readonly name: string;
+    readonly raw: string;
+};
+export interface RouteDefinition {
+    readonly id: string;
+    readonly pathname: string;
+    readonly kind: RouteKind;
+    readonly entryFile: string;
+    readonly routeDir: string;
+    readonly segments: RouteSegment[];
+}
+export interface RouteManifest {
+    readonly appRoot: string;
+    readonly routes: RouteDefinition[];
+}
+export interface LoadDawnConfigOptions {
+    readonly appRoot: string;
+}
+export interface LoadedDawnConfig {
+    readonly appRoot: string;
+    readonly config: DawnConfig;
+    readonly configPath: string;
+}
+export interface FindDawnAppOptions {
+    readonly appRoot?: string;
+    readonly cwd?: string;
+}
+export interface DiscoveredDawnApp {
+    readonly appRoot: string;
+    readonly configPath: string;
+    readonly dawnDir: string;
+    readonly routesDir: string;
+}
+export interface DiscoverRoutesOptions {
+    readonly appRoot?: string;
+    readonly cwd?: string;
+}
+export interface ExtractedToolType {
+    readonly name: string;
+    readonly inputType: string;
+    readonly outputType: string;
+}
+export interface RouteToolTypes {
+    readonly pathname: string;
+    readonly tools: readonly ExtractedToolType[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C,YAAY,EAAE,SAAS,EAAE,CAAA;AAEzB,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,MAAM,YAAY,GACpB;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACrB,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,UAAU,GAAG,mBAAmB,CAAA;IAC3D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACrB,CAAA;AAEL,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,YAAY,EAAE,CAAA;CAClC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,eAAe,EAAE,CAAA;CACnC;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAA;CAC7C"}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@dawn-ai/core",
+  "version": "0.0.2",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://github.com/cacheplane/dawnai/tree/main/packages/core#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cacheplane/dawnai.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/cacheplane/dawnai/issues"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "tsx": "^4.8.1",
+    "typescript": "5.8.3",
+    "@dawn-ai/sdk": "0.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "25.6.0",
+    "@dawn-ai/config-typescript": "0.0.2"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.json",
+    "lint": "biome check --config-path ../config-biome/biome.json package.json src test tsconfig.json vitest.config.ts",
+    "test": "vitest --run --config vitest.config.ts",
+    "typecheck": "tsc --noEmit"
+  }
+}