@hold-rein/cli 0.0.0

package/dist/runtime/api/modules/agents/task/run-monitor.js

@@ -0,0 +1,42 @@
+export async function startTaskRun(input) {
+    input.activeTaskRuns?.markStarting(input.taskId);
+    try {
+        const run = await input.runtime.start(input.runtimeInput);
+        input.activeTaskRuns?.register(input.taskId, run.agentId);
+        monitorTaskRun({
+            ...(input.activeTaskRuns
+                ? { activeTaskRuns: input.activeTaskRuns }
+                : {}),
+            agentId: run.agentId,
+            eventBus: input.eventBus,
+            now: input.now,
+            repository: input.repository,
+            taskId: input.taskId
+        });
+        return run;
+    }
+    catch (error) {
+        input.activeTaskRuns?.remove(input.taskId);
+        input.repository.updateTaskStatus(input.taskId, "error", input.now().toISOString());
+        throw error;
+    }
+}
+function monitorTaskRun(input) {
+    let terminal = false;
+    let subscription;
+    subscription = input.eventBus.subscribe({ agentId: input.agentId }, (event) => {
+        const status = event.type === "task_end"
+            ? "completed"
+            : event.type === "agent_error"
+                ? "error"
+                : undefined;
+        if (!status || terminal)
+            return;
+        terminal = true;
+        input.repository.updateTaskStatus(input.taskId, status, input.now().toISOString());
+        input.activeTaskRuns?.remove(input.taskId);
+        subscription?.unsubscribe();
+    });
+    if (terminal)
+        subscription.unsubscribe();
+}

package/dist/runtime/api/modules/agents/task/title-generator.d.ts

@@ -0,0 +1,15 @@
+import { type AgentModelLookup } from "../model/resolver";
+export interface GenerateTaskTitleInput {
+    apiKey?: string;
+    modelId: string;
+    prompt: string;
+    provider: string;
+}
+export interface TaskTitleGenerator {
+    generateTitle: (input: GenerateTaskTitleInput) => Promise<string>;
+}
+export interface CreateTaskTitleGeneratorOptions {
+    getCustomModel?: AgentModelLookup;
+}
+export declare function createDefaultTaskTitleGenerator(options?: CreateTaskTitleGeneratorOptions): TaskTitleGenerator;
+//# sourceMappingURL=title-generator.d.ts.map

package/dist/runtime/api/modules/agents/task/title-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"title-generator.d.ts","sourceRoot":"","sources":["../../../../src/modules/agents/task/title-generator.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACnE;AAED,MAAM,WAAW,+BAA+B;IAC9C,cAAc,CAAC,EAAE,gBAAgB,CAAC;CACnC;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,GAAE,+BAAoC,GAC5C,kBAAkB,CAqDpB"}

package/dist/runtime/api/modules/agents/task/title-generator.js

@@ -0,0 +1,61 @@
+import { complete } from "@earendil-works/pi-ai";
+import { resolveAgentModel } from "../model/resolver.js";
+export function createDefaultTaskTitleGenerator(options = {}) {
+    return {
+        generateTitle: async (input) => {
+            const model = await resolveAgentModel(input.provider, input.modelId, options.getCustomModel);
+            if (!model) {
+                return createFallbackTitle(input.prompt);
+            }
+            try {
+                const message = await complete(model, {
+                    messages: [
+                        {
+                            content: [
+                                {
+                                    text: [
+                                        "Create a concise task title for this user request.",
+                                        "Return only the title, without quotes or punctuation wrappers.",
+                                        `Request: ${input.prompt}`
+                                    ].join("\n"),
+                                    type: "text"
+                                }
+                            ],
+                            role: "user",
+                            timestamp: Date.now()
+                        }
+                    ],
+                    systemPrompt: "You create short software task titles."
+                }, {
+                    ...(input.apiKey ? { apiKey: input.apiKey } : {}),
+                    maxTokens: 64,
+                    temperature: 0.2
+                });
+                const title = message.content
+                    .filter((content) => content.type === "text")
+                    .map((content) => content.text)
+                    .join("")
+                    .trim();
+                return normalizeGeneratedTitle(title, input.prompt);
+            }
+            catch {
+                return createFallbackTitle(input.prompt);
+            }
+        }
+    };
+}
+function normalizeGeneratedTitle(title, prompt) {
+    const normalizedTitle = title
+        .replace(/^["'`]+|["'`]+$/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    return normalizedTitle.length > 0
+        ? normalizedTitle.slice(0, 80)
+        : createFallbackTitle(prompt);
+}
+function createFallbackTitle(prompt) {
+    const normalizedPrompt = prompt.replace(/\s+/g, " ").trim();
+    return normalizedPrompt.length > 0
+        ? normalizedPrompt.slice(0, 80)
+        : "New task";
+}

package/dist/runtime/api/modules/agents/task-run-monitor.d.ts

@@ -0,0 +1,14 @@
+import type { WorkspaceRepository } from "../workspaces/workspace-repository";
+import type { ActiveTaskRunRegistry } from "./active-task-run-registry";
+import type { AgentEventBus } from "./agent-event-bus";
+import type { AgentRuntime } from "./agent-runtime";
+export declare function startTaskRun(input: {
+    activeTaskRuns?: ActiveTaskRunRegistry;
+    eventBus: AgentEventBus;
+    now: () => Date;
+    repository: WorkspaceRepository;
+    runtime: AgentRuntime;
+    runtimeInput: Parameters<AgentRuntime["start"]>[0];
+    taskId: string;
+}): Promise<import("./agent-types").AgentRunResult>;
+//# sourceMappingURL=task-run-monitor.d.ts.map

package/dist/runtime/api/modules/agents/task-run-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-run-monitor.d.ts","sourceRoot":"","sources":["../../../src/modules/agents/task-run-monitor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAC9E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGpD,wBAAsB,YAAY,CAAC,KAAK,EAAE;IACxC,cAAc,CAAC,EAAE,qBAAqB,CAAC;IACvC,QAAQ,EAAE,aAAa,CAAC;IACxB,GAAG,EAAE,MAAM,IAAI,CAAC;IAChB,UAAU,EAAE,mBAAmB,CAAC;IAChC,OAAO,EAAE,YAAY,CAAC;IACtB,YAAY,EAAE,UAAU,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACnD,MAAM,EAAE,MAAM,CAAC;CAChB,mDA0BA"}

package/dist/runtime/api/modules/agents/task-run-monitor.js

@@ -0,0 +1,42 @@
+export async function startTaskRun(input) {
+    input.activeTaskRuns?.markStarting(input.taskId);
+    try {
+        const run = await input.runtime.start(input.runtimeInput);
+        input.activeTaskRuns?.register(input.taskId, run.agentId);
+        monitorTaskRun({
+            ...(input.activeTaskRuns
+                ? { activeTaskRuns: input.activeTaskRuns }
+                : {}),
+            agentId: run.agentId,
+            eventBus: input.eventBus,
+            now: input.now,
+            repository: input.repository,
+            taskId: input.taskId
+        });
+        return run;
+    }
+    catch (error) {
+        input.activeTaskRuns?.remove(input.taskId);
+        input.repository.updateTaskStatus(input.taskId, "error", input.now().toISOString());
+        throw error;
+    }
+}
+function monitorTaskRun(input) {
+    let terminal = false;
+    let subscription;
+    subscription = input.eventBus.subscribe({ agentId: input.agentId }, (event) => {
+        const status = event.type === "task_end"
+            ? "completed"
+            : event.type === "agent_error"
+                ? "error"
+                : undefined;
+        if (!status || terminal)
+            return;
+        terminal = true;
+        input.repository.updateTaskStatus(input.taskId, status, input.now().toISOString());
+        input.activeTaskRuns?.remove(input.taskId);
+        subscription?.unsubscribe();
+    });
+    if (terminal)
+        subscription.unsubscribe();
+}

package/dist/runtime/api/modules/file-system/file-system-router.d.ts

@@ -0,0 +1,6 @@
+import { Router } from "express";
+export interface CreateFileSystemRouterOptions {
+    fileSystemRootPath?: string;
+}
+export declare function createFileSystemRouter(options?: CreateFileSystemRouterOptions): Router;
+//# sourceMappingURL=file-system-router.d.ts.map

package/dist/runtime/api/modules/file-system/file-system-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-system-router.d.ts","sourceRoot":"","sources":["../../../src/modules/file-system/file-system-router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA+B,MAAM,SAAS,CAAC;AAU9D,MAAM,WAAW,6BAA6B;IAC5C,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,wBAAgB,sBAAsB,CACpC,OAAO,GAAE,6BAAkC,GAC1C,MAAM,CAyIR"}

package/dist/runtime/api/modules/file-system/file-system-router.js

@@ -0,0 +1,119 @@
+import { Router } from "express";
+import { sendError, sendSuccess } from "../../response/index.js";
+import { RESPONSE_CODE_DEFINITIONS } from "../../response/response-codes.js";
+import { listDirectoryEntries, listDirectoryEntriesRecursive, readFileContent } from "./file-system-service.js";
+export function createFileSystemRouter(options = {}) {
+    const router = Router();
+    router.get("/file-system/entries", (request, response) => {
+        const parentPath = getParentPath(request.query.parentPath);
+        if (parentPath === null) {
+            sendError(response, RESPONSE_CODE_DEFINITIONS.badRequest, "parentPath must be a string");
+            return;
+        }
+        const listOptions = {
+            ...(parentPath === undefined ? {} : { parentPath }),
+            ...(options.fileSystemRootPath === undefined
+                ? {}
+                : { rootPath: options.fileSystemRootPath })
+        };
+        void listDirectoryEntries(listOptions)
+            .then((listing) => {
+            sendSuccess(response, listing);
+        })
+            .catch((error) => {
+            sendError(response, RESPONSE_CODE_DEFINITIONS.badRequest, error instanceof Error
+                ? error.message
+                : "Failed to list directory entries");
+        });
+    });
+    router.get("/file-system/entries/recursive", (request, response) => {
+        const parentPath = getParentPath(request.query.parentPath);
+        const ignores = getOptionalQueryStringArray(request.query.ignores);
+        const useGitIgnore = getOptionalQueryBoolean(request.query.useGitIgnore);
+        if (parentPath === null) {
+            sendError(response, RESPONSE_CODE_DEFINITIONS.badRequest, "parentPath must be a string");
+            return;
+        }
+        if (ignores === null) {
+            sendError(response, RESPONSE_CODE_DEFINITIONS.badRequest, "ignores must be a string array");
+            return;
+        }
+        if (useGitIgnore === null) {
+            sendError(response, RESPONSE_CODE_DEFINITIONS.badRequest, "useGitIgnore must be a boolean");
+            return;
+        }
+        const listOptions = {
+            ...(ignores === undefined ? {} : { ignores }),
+            ...(parentPath === undefined ? {} : { parentPath }),
+            ...(useGitIgnore === undefined ? {} : { useGitIgnore }),
+            ...(options.fileSystemRootPath === undefined
+                ? {}
+                : { rootPath: options.fileSystemRootPath })
+        };
+        void listDirectoryEntriesRecursive(listOptions)
+            .then((listing) => {
+            sendSuccess(response, listing);
+        })
+            .catch((error) => {
+            sendError(response, RESPONSE_CODE_DEFINITIONS.badRequest, error instanceof Error
+                ? error.message
+                : "Failed to list directory entries recursively");
+        });
+    });
+    router.get("/file-system/file-content", (request, response) => {
+        const filePath = getRequiredQueryString(request.query.filePath);
+        if (filePath === null) {
+            sendError(response, RESPONSE_CODE_DEFINITIONS.badRequest, "filePath must be a string");
+            return;
+        }
+        const readOptions = {
+            filePath,
+            ...(options.fileSystemRootPath === undefined
+                ? {}
+                : { rootPath: options.fileSystemRootPath })
+        };
+        void readFileContent(readOptions)
+            .then((fileContent) => {
+            sendSuccess(response, fileContent);
+        })
+            .catch((error) => {
+            sendError(response, RESPONSE_CODE_DEFINITIONS.badRequest, error instanceof Error
+                ? error.message
+                : "Failed to read file content");
+        });
+    });
+    return router;
+}
+function getParentPath(parentPath) {
+    if (parentPath === undefined) {
+        return undefined;
+    }
+    return typeof parentPath === "string" ? parentPath : null;
+}
+function getRequiredQueryString(value) {
+    return typeof value === "string" ? value : null;
+}
+function getOptionalQueryStringArray(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+        return value;
+    }
+    return null;
+}
+function getOptionalQueryBoolean(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "true") {
+        return true;
+    }
+    if (value === "false") {
+        return false;
+    }
+    return null;
+}

package/dist/runtime/api/modules/file-system/file-system-service.d.ts

@@ -0,0 +1,30 @@
+export type FileSystemEntryKind = "file" | "folder";
+export interface FileSystemEntry {
+    children?: FileSystemEntry[];
+    extension: string;
+    kind: FileSystemEntryKind;
+    name: string;
+    path: string;
+}
+export interface FileSystemDirectoryListing {
+    entries: FileSystemEntry[];
+    parentPath: string;
+}
+export interface FileSystemFileContent {
+    content: string;
+    filePath: string;
+}
+export interface ListDirectoryOptions {
+    ignores?: string[];
+    parentPath?: string;
+    rootPath?: string;
+    useGitIgnore?: boolean;
+}
+export interface ReadFileContentOptions {
+    filePath: string;
+    rootPath?: string;
+}
+export declare function listDirectoryEntries(options?: ListDirectoryOptions): Promise<FileSystemDirectoryListing>;
+export declare function listDirectoryEntriesRecursive(options?: ListDirectoryOptions): Promise<FileSystemDirectoryListing>;
+export declare function readFileContent(options: ReadFileContentOptions): Promise<FileSystemFileContent>;
+//# sourceMappingURL=file-system-service.d.ts.map

package/dist/runtime/api/modules/file-system/file-system-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-system-service.d.ts","sourceRoot":"","sources":["../../../src/modules/file-system/file-system-service.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEpD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,mBAAmB,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAsB,oBAAoB,CACxC,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,0BAA0B,CAAC,CA6BrC;AAED,wBAAsB,6BAA6B,CACjD,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,0BAA0B,CAAC,CAerC;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,qBAAqB,CAAC,CAahC"}

package/dist/runtime/api/modules/file-system/file-system-service.js

@@ -0,0 +1,209 @@
+import { readFile, readdir, stat } from "node:fs/promises";
+import { extname, isAbsolute, parse, relative, resolve } from "node:path";
+export async function listDirectoryEntries(options = {}) {
+    const rootPath = normalizeRootPath(options.rootPath);
+    const parentPath = normalizeParentPath(rootPath, options.parentPath);
+    const parentStat = await stat(parentPath);
+    if (!parentStat.isDirectory()) {
+        throw new Error("parentPath must be a directory");
+    }
+    const entries = await readdir(parentPath, { withFileTypes: true });
+    const visibleEntries = entries.filter((entry) => !entry.name.startsWith("."));
+    return {
+        entries: visibleEntries
+            .filter((entry) => entry.isDirectory() || entry.isFile())
+            .map((entry) => {
+            const entryPath = resolve(parentPath, entry.name);
+            const isDirectory = entry.isDirectory();
+            return {
+                extension: isDirectory ? "" : extname(entry.name),
+                kind: isDirectory ? "folder" : "file",
+                name: entry.name,
+                path: entryPath
+            };
+        })
+            .sort(compareEntries),
+        parentPath
+    };
+}
+export async function listDirectoryEntriesRecursive(options = {}) {
+    const rootPath = normalizeRootPath(options.rootPath);
+    const parentPath = normalizeParentPath(rootPath, options.parentPath);
+    const parentStat = await stat(parentPath);
+    if (!parentStat.isDirectory()) {
+        throw new Error("parentPath must be a directory");
+    }
+    const ignoreMatcher = await createIgnoreMatcher(parentPath, options);
+    return {
+        entries: await listEntriesRecursive(parentPath, ignoreMatcher),
+        parentPath
+    };
+}
+export async function readFileContent(options) {
+    const rootPath = normalizeRootPath(options.rootPath);
+    const filePath = normalizeFilePath(rootPath, options.filePath);
+    const fileStat = await stat(filePath);
+    if (!fileStat.isFile()) {
+        throw new Error("filePath must be a file");
+    }
+    return {
+        content: await readFile(filePath, "utf8"),
+        filePath
+    };
+}
+function normalizeRootPath(rootPath) {
+    return rootPath ? resolve(rootPath) : parse(process.cwd()).root;
+}
+function normalizeParentPath(rootPath, parentPath) {
+    const resolvedParentPath = parentPath
+        ? resolve(parentPath)
+        : rootPath;
+    if (!isPathInsideRoot(rootPath, resolvedParentPath)) {
+        throw new Error("parentPath must be inside the root directory");
+    }
+    return resolvedParentPath;
+}
+function normalizeFilePath(rootPath, filePath) {
+    const resolvedFilePath = resolve(filePath);
+    if (!isPathInsideRoot(rootPath, resolvedFilePath)) {
+        throw new Error("filePath must be inside the root directory");
+    }
+    return resolvedFilePath;
+}
+function isPathInsideRoot(rootPath, targetPath) {
+    const pathFromRoot = relative(rootPath, targetPath);
+    return (pathFromRoot === "" ||
+        (!pathFromRoot.startsWith("..") && !isAbsolute(pathFromRoot)));
+}
+async function createIgnoreMatcher(parentPath, options) {
+    const ignoredNames = new Set(options.ignores ?? []);
+    const gitIgnoreRules = options.useGitIgnore
+        ? await loadGitIgnoreRules(parentPath)
+        : [];
+    return (entryPath, name, isDirectory) => {
+        if (ignoredNames.has(name)) {
+            return true;
+        }
+        const relativeEntryPath = normalizeRelativePath(relative(parentPath, entryPath));
+        return isIgnoredByGitIgnoreRules(relativeEntryPath, name, isDirectory, gitIgnoreRules);
+    };
+}
+async function listEntriesRecursive(parentPath, ignoreMatcher) {
+    const entries = await readdir(parentPath, { withFileTypes: true });
+    const visibleEntries = await Promise.all(entries
+        .filter((entry) => !entry.name.startsWith("."))
+        .filter((entry) => entry.isDirectory() || entry.isFile())
+        .filter((entry) => {
+        const entryPath = resolve(parentPath, entry.name);
+        return !ignoreMatcher(entryPath, entry.name, entry.isDirectory());
+    })
+        .map(async (entry) => {
+        const entryPath = resolve(parentPath, entry.name);
+        const isDirectory = entry.isDirectory();
+        return {
+            ...(isDirectory
+                ? { children: await listEntriesRecursive(entryPath, ignoreMatcher) }
+                : {}),
+            extension: isDirectory ? "" : extname(entry.name),
+            kind: isDirectory ? "folder" : "file",
+            name: entry.name,
+            path: entryPath
+        };
+    }));
+    return visibleEntries.sort(compareEntries);
+}
+async function loadGitIgnoreRules(parentPath) {
+    let gitIgnoreContent = "";
+    try {
+        gitIgnoreContent = await readFile(resolve(parentPath, ".gitignore"), "utf8");
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    return gitIgnoreContent
+        .split(/\r?\n/u)
+        .map(parseGitIgnoreRule)
+        .filter((rule) => rule !== null);
+}
+function parseGitIgnoreRule(line) {
+    let pattern = line.trim();
+    if (!pattern || pattern.startsWith("#")) {
+        return null;
+    }
+    if (pattern.startsWith("\\#") || pattern.startsWith("\\!")) {
+        pattern = pattern.slice(1);
+    }
+    const ignored = !pattern.startsWith("!");
+    pattern = ignored ? pattern : pattern.slice(1);
+    if (!pattern) {
+        return null;
+    }
+    if (pattern.startsWith("/")) {
+        pattern = pattern.slice(1);
+    }
+    const directoryOnly = pattern.endsWith("/");
+    pattern = directoryOnly ? pattern.slice(0, -1) : pattern;
+    if (!pattern) {
+        return null;
+    }
+    return {
+        directoryOnly,
+        hasSlash: pattern.includes("/"),
+        ignored,
+        pattern,
+        regex: createGitIgnorePatternRegex(pattern)
+    };
+}
+function isIgnoredByGitIgnoreRules(relativeEntryPath, name, isDirectory, rules) {
+    let ignored = false;
+    for (const rule of rules) {
+        if (rule.directoryOnly && !isDirectory) {
+            continue;
+        }
+        const target = rule.hasSlash ? relativeEntryPath : name;
+        if (rule.regex.test(target)) {
+            ignored = rule.ignored;
+        }
+    }
+    return ignored;
+}
+function createGitIgnorePatternRegex(pattern) {
+    let source = "";
+    for (let index = 0; index < pattern.length; index += 1) {
+        const character = pattern[index] ?? "";
+        const nextCharacter = pattern[index + 1];
+        if (character === "*" && nextCharacter === "*") {
+            source += ".*";
+            index += 1;
+            continue;
+        }
+        if (character === "*") {
+            source += "[^/]*";
+            continue;
+        }
+        if (character === "?") {
+            source += "[^/]";
+            continue;
+        }
+        source += escapeRegexCharacter(character);
+    }
+    return new RegExp(`^${source}$`, "u");
+}
+function normalizeRelativePath(path) {
+    return path.replace(/\\/gu, "/");
+}
+function escapeRegexCharacter(character) {
+    return character.replace(/[|\\{}()[\]^$+*?.]/gu, "\\$&");
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+function compareEntries(left, right) {
+    if (left.kind !== right.kind) {
+        return left.kind === "folder" ? -1 : 1;
+    }
+    return left.name.localeCompare(right.name);
+}

package/dist/runtime/api/modules/file-system/index.d.ts

@@ -0,0 +1,4 @@
+export { createFileSystemRouter } from "./file-system-router";
+export type { CreateFileSystemRouterOptions } from "./file-system-router";
+export type { FileSystemDirectoryListing, FileSystemEntry, FileSystemEntryKind } from "./file-system-service";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/api/modules/file-system/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/modules/file-system/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,YAAY,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAC;AAC1E,YAAY,EACV,0BAA0B,EAC1B,eAAe,EACf,mBAAmB,EACpB,MAAM,uBAAuB,CAAC"}

package/dist/runtime/api/modules/file-system/index.js

@@ -0,0 +1 @@
+export { createFileSystemRouter } from "./file-system-router.js";

package/dist/runtime/api/modules/health/health-router.d.ts

@@ -0,0 +1,3 @@
+import { Router } from "express";
+export declare function createHealthRouter(): Router;
+//# sourceMappingURL=health-router.d.ts.map

package/dist/runtime/api/modules/health/health-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-router.d.ts","sourceRoot":"","sources":["../../../src/modules/health/health-router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA+B,MAAM,SAAS,CAAC;AAK9D,wBAAgB,kBAAkB,IAAI,MAAM,CAQ3C"}

package/dist/runtime/api/modules/health/health-router.js

@@ -0,0 +1,10 @@
+import { Router } from "express";
+import { sendSuccess } from "../../response/index.js";
+import { getHealthStatus } from "../../service/health-service.js";
+export function createHealthRouter() {
+    const router = Router();
+    router.get("/health", (_request, response) => {
+        sendSuccess(response, getHealthStatus());
+    });
+    return router;
+}

package/dist/runtime/api/modules/health/index.d.ts

@@ -0,0 +1,2 @@
+export { createHealthRouter } from "./health-router";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/api/modules/health/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/modules/health/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/runtime/api/modules/health/index.js

@@ -0,0 +1 @@
+export { createHealthRouter } from "./health-router.js";

package/dist/runtime/api/modules/model-providers/default-model-provider-service.d.ts

@@ -0,0 +1,3 @@
+import { type ModelProvidersService } from "./model-providers-service";
+export declare function getDefaultModelProvidersService(): ModelProvidersService;
+//# sourceMappingURL=default-model-provider-service.d.ts.map

package/dist/runtime/api/modules/model-providers/default-model-provider-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-model-provider-service.d.ts","sourceRoot":"","sources":["../../../src/modules/model-providers/default-model-provider-service.ts"],"names":[],"mappings":"AAOA,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,2BAA2B,CAAC;AAKnC,wBAAgB,+BAA+B,IAAI,qBAAqB,CAoBvE"}

package/dist/runtime/api/modules/model-providers/default-model-provider-service.js

@@ -0,0 +1,21 @@
+import { loadApiEnv } from "../../config/env.js";
+import { DB_FILE } from "../../config/const.js";
+import { createDatabase, migrateDatabase } from "../../db/index.js";
+import { createSqliteModelProviderRepository } from "./model-provider-repository.js";
+import { createModelProvidersService } from "./model-providers-service.js";
+let repository;
+let service;
+export function getDefaultModelProvidersService() {
+    if (service) {
+        return service;
+    }
+    loadApiEnv();
+    const database = createDatabase(process.env.SQLITE_DB_PATH ?? DB_FILE);
+    migrateDatabase(database.sqlite);
+    repository = createSqliteModelProviderRepository(database);
+    service = createModelProvidersService({
+        providerApiKeyEncryptionKey: process.env.PROVIDER_API_KEY_ENCRYPTION_KEY ?? "",
+        repository
+    });
+    return service;
+}

package/dist/runtime/api/modules/model-providers/index.d.ts

@@ -0,0 +1,5 @@
+export { getDefaultModelProvidersService } from "./default-model-provider-service";
+export { createModelProvidersRouter } from "./model-providers-router";
+export { createInMemoryModelProviderRepository, createSqliteModelProviderRepository } from "./model-provider-repository";
+export { createModelProvidersService } from "./model-providers-service";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/api/modules/model-providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/modules/model-providers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,kCAAkC,CAAC;AACnF,OAAO,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,EACL,qCAAqC,EACrC,mCAAmC,EACpC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/runtime/api/modules/model-providers/index.js

@@ -0,0 +1,4 @@
+export { getDefaultModelProvidersService } from "./default-model-provider-service.js";
+export { createModelProvidersRouter } from "./model-providers-router.js";
+export { createInMemoryModelProviderRepository, createSqliteModelProviderRepository } from "./model-provider-repository.js";
+export { createModelProvidersService } from "./model-providers-service.js";