testeranto 0.203.0 → 0.205.0

package/dist/types/src/Types.d.ts

@@ -0,0 +1,120 @@
+import { Plugin } from "esbuild";
+import { ITTestResourceConfiguration } from "./lib/index.js";
+import { PM } from "./PM/index.js";
+import { Ibdd_in_any, Ibdd_out_any } from "./CoreTypes.js";
+import { BaseSuite } from "./lib/BaseSuite.js";
+import { IGivens, BaseGiven } from "./lib/BaseGiven.js";
+import { BaseThen } from "./lib/BaseThen.js";
+import { BaseWhen } from "./lib/BaseWhen.js";
+export type ISummary = Record<string, {
+    runTimeTests: number | "?" | undefined;
+    runTimeErrors: number | "?" | undefined;
+    typeErrors: number | "?" | undefined;
+    staticErrors: number | "?" | undefined;
+    prompt: string | "?" | undefined;
+    failingFeatures: object | undefined;
+}> & {
+    nodeLogs?: string;
+    webLogs?: string;
+    pureLogs?: string;
+};
+export type SuiteSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["suites"]]: (name: string, givens: IGivens<I>) => BaseSuite<I, O>;
+};
+export type TestSummary = {
+    testName: string;
+    errors?: {
+        runtime?: number;
+        type?: number;
+        static?: number;
+    };
+    prompt?: string;
+    failedFeatures: string[];
+};
+export type TestLifecycle<Subject, State, Selection> = {
+    beforeAll?: (input: any) => Promise<Subject>;
+    beforeEach?: (subject: Subject) => Promise<State>;
+    executeStep?: (state: State) => Promise<State>;
+    verifyStep?: (state: State) => Promise<Selection>;
+    afterEach?: (state: State) => Promise<void>;
+    afterAll?: (state: State) => Promise<void>;
+    assert?: (result: Selection) => void;
+};
+export type TestDefinition<Subject, State, Selection> = {
+    subject: Subject;
+    given?: (input: any) => State;
+    when?: (state: State) => State | Promise<State>;
+    then?: (state: State) => Selection | Promise<Selection>;
+    resources?: ITTestResourceConfiguration;
+    pm?: typeof PM;
+};
+export type TestSuite = {
+    name: string;
+    tests: TestDefinition<any, any, any>[];
+    features?: string[];
+};
+export type RuntimeConfig = {
+    type: "node" | "web" | "pure" | "spawn";
+    ports?: number[];
+    plugins?: Plugin[];
+};
+export type ProjectConfig = {
+    name: string;
+    sourceDir: string;
+    testSuites: TestSuite[];
+    runtime: RuntimeConfig;
+    minify?: boolean;
+    debug?: boolean;
+};
+export type GivenSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["givens"]]: (features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], ...xtrasB: O["givens"][K]) => BaseGiven<I>;
+};
+export type WhenSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["whens"]]: (...xtrasC: O["whens"][K]) => BaseWhen<I>;
+};
+export type ThenSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["thens"]]: (...xtrasD: O["thens"][K]) => BaseThen<I>;
+};
+export type TestSuiteImplementation<O extends Ibdd_out_any> = {
+    [K in keyof O["suites"]]: string;
+};
+export type TestGivenImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
+};
+export type TestWhenImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["whens"]]: (...Iw: O["whens"][K]) => (zel: I["iselection"], tr: ITTestResourceConfiguration, utils: PM) => Promise<I["when"]>;
+};
+export type TestThenImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["thens"]]: (...It: O["thens"][K]) => (ssel: I["iselection"], utils: PM) => I["then"];
+};
+export type Modify<T, R> = Omit<T, keyof R> & R;
+export type TestSuiteShape = Record<string, any>;
+export type TestGivenShape = Record<string, any>;
+export type TestWhenShape = Record<string, any>;
+export type TestThenShape = Record<string, any>;
+export type IPluginFactory = (register?: (entrypoint: string, sources: string[]) => any, entrypoints?: string[]) => Plugin;
+export type IRunTime = `node` | `web` | "pure" | `golang` | `python`;
+export type ITestTypes = [string, IRunTime, {
+    ports: number;
+}, ITestTypes[]];
+export type ITestconfig = {
+    clearScreen: boolean;
+    debugger: boolean;
+    externals: string[];
+    featureIngestor: (s: string) => Promise<string>;
+    importPlugins: IPluginFactory[];
+    minify: boolean;
+    nodePlugins: IPluginFactory[];
+    ports: string[];
+    src: string;
+    tests: ITestTypes[];
+    webPlugins: IPluginFactory[];
+    webLoaders: Record<string, string>;
+};
+export type IBuiltConfig = {
+    buildDir: string;
+} & ITestconfig;
+export type IProject = {
+    projects: Record<string, ITestconfig>;
+    ignore: string[];
+};

package/dist/types/src/Web.d.ts

@@ -0,0 +1,9 @@
+import { ITestSpecification, ITestImplementation, ITestAdapter, Ibdd_in_any, Ibdd_out } from "./CoreTypes";
+import Tiposkripto from "./lib/Tiposkripto";
+import { ITTestResourceRequest } from "./lib/index.js";
+export declare class WebTesteranto<I extends Ibdd_in_any, O extends Ibdd_out, M> extends Tiposkripto<I, O, M> {
+    constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest, testAdapter: Partial<ITestAdapter<I>>);
+    receiveTestResourceConfig(partialTestResource: any): Promise<import("./lib/index.js").IFinalResults>;
+}
+declare const _default: <I extends Ibdd_in_any, O extends Ibdd_out, M>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testAdapter: Partial<ITestAdapter<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<WebTesteranto<I, O, M>>;
+export default _default;

package/dist/types/src/WebSidecar.d.ts

@@ -0,0 +1,8 @@
+import { ITTestResourceConfiguration } from "./lib";
+import { Sidecar } from "./lib/Sidecar";
+import { PM_Web_Sidecar } from "./PM/webSidecar";
+export declare class WebSideCar extends Sidecar {
+    start(t: ITTestResourceConfiguration): void;
+    stop(): void;
+    pm: PM_Web_Sidecar;
+}

package/dist/types/src/app/FileService.d.ts

@@ -0,0 +1,37 @@
+export declare const FileService_methods: string[];
+export declare abstract class FileService {
+    abstract writeFile_send(...x: any[]): any;
+    abstract writeFile_receive(...x: any[]): any;
+    abstract readFile_receive(...x: any[]): any;
+    abstract readFile_send(...x: any[]): any;
+    abstract createDirectory_receive(...x: any[]): any;
+    abstract createDirectory_send(...x: any[]): any;
+    abstract deleteFile_receive(...x: any[]): any;
+    abstract deleteFile_send(...x: any[]): any;
+    abstract files_send(...x: any[]): any;
+    abstract files_receive(...x: any[]): any;
+    abstract projects_send(...x: any[]): any;
+    abstract projects_receive(...x: any[]): any;
+    abstract tests_send(...x: any[]): any;
+    abstract tests_receive(...x: any[]): any;
+    abstract report_send(...x: any[]): any;
+    abstract report_receive(...x: any[]): any;
+}
+export interface FileEntry {
+    name: string;
+    path: string;
+    type: "file" | "directory";
+    size?: number;
+    modified?: Date;
+}
+export interface FileStatus {
+    status: "unchanged" | "modified" | "added" | "deleted" | "conflicted";
+}
+export interface FileChange extends FileStatus {
+    path: string;
+    diff?: string;
+}
+export interface RemoteStatus {
+    ahead: number;
+    behind: number;
+}

package/dist/types/src/app/api.d.ts

@@ -0,0 +1,37 @@
+export declare enum ApiFilename {
+    "root" = "./testeranto/index.html",
+    "style" = "./testeranto/App.css",
+    "script" = "./testeranto/App.js"
+}
+export declare const Api: {
+    testeranto: {
+        api: {
+            tests: string;
+            report: string;
+            files: string;
+        };
+        app: {
+            projects: {
+                urls: string;
+                files: string;
+            };
+            root: {
+                url: string;
+                file: string;
+            };
+            css: {
+                url: string;
+                file: string;
+            };
+            script: {
+                url: string;
+                file: string;
+            };
+        };
+    };
+};
+export declare enum ApiEndpoint {
+    root = "/testeranto/index.html",
+    style = "/testeranto/App.css",
+    script = "/testeranto/App.js"
+}

package/dist/types/src/app/backend/PM_0.d.ts

@@ -0,0 +1,38 @@
+import { Browser, Page, ScreenshotOptions } from "puppeteer-core";
+import { PassThrough } from "stream";
+import { ITLog } from "../../lib/index.js";
+import { IBuiltConfig } from "../../Types.js";
+import { IMode } from "../types.js";
+export declare abstract class PM_0 {
+    mode: IMode;
+    browser: Browser;
+    configs: IBuiltConfig;
+    projectName: string;
+    constructor(configs: IBuiltConfig, projectName: string, mode: IMode);
+    mapping(): [string, (...a: any[]) => any][];
+    customclose(): void;
+    waitForSelector(p: string, s: string): any;
+    closePage(p: any): any;
+    newPage(): Promise<string>;
+    goto(p: any, url: string): any;
+    $(selector: string, p: string): Promise<any>;
+    pages(): Promise<string[]>;
+    screencast(ssOpts: ScreenshotOptions, testName: string, page: Page): Promise<Uint8Array<ArrayBufferLike>>;
+    customScreenShot(ssOpts: ScreenshotOptions, testName: string, pageUid: any): Promise<Uint8Array<ArrayBufferLike>>;
+    end(uid: number): Promise<boolean>;
+    existsSync(destFolder: string): boolean;
+    mkdirSync(fp: string): Promise<string | false | undefined>;
+    writeFileSync(...x: any[]): Promise<boolean>;
+    createWriteStream(filepath: string, testName: string): Promise<number>;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): (fPath: any, value: string | Buffer | PassThrough) => void;
+    write(uid: number, contents: string): Promise<boolean>;
+    page(p: any): string | undefined;
+    click(selector: string, page: Page): Promise<void>;
+    focusOn(selector: string, p: string): Promise<void>;
+    typeInto(value: string, p: string): Promise<void>;
+    getAttribute(selector: string, attribute: string, p: string): void;
+    getInnerHtml(selector: string, p: string): Promise<unknown>;
+    isDisabled(selector: string, p: string): void;
+    screencastStop(s: string): Promise<void>;
+    doInPage(p: string, cb: (p: Page) => unknown): Promise<void>;
+}

package/dist/types/src/app/backend/PM_1_WithProcesses.d.ts

@@ -0,0 +1,149 @@
+import { IBuiltConfig, IRunTime, ISummary } from "../../Types.js";
+import { ChildProcess } from "child_process";
+import fs from "fs";
+import { createLogStreams } from "../../PM/utils.js";
+import { PM_0 } from "./PM_0.js";
+export declare abstract class PM_1_WithProcesses extends PM_0 {
+    summary: ISummary;
+    webMetafileWatcher: fs.FSWatcher;
+    nodeMetafileWatcher: fs.FSWatcher;
+    importMetafileWatcher: fs.FSWatcher;
+    pitonoMetafileWatcher: fs.FSWatcher;
+    golangMetafileWatcher: fs.FSWatcher;
+    ports: Record<number, string>;
+    queue: string[];
+    logStreams: Record<string, ReturnType<typeof createLogStreams>>;
+    launchers: Record<string, () => void>;
+    configs: any;
+    abstract launchNode(src: string, dest: string): any;
+    abstract launchWeb(src: string, dest: string): any;
+    abstract launchPure(src: string, dest: string): any;
+    abstract launchPython(src: string, dest: string): any;
+    abstract launchGolang(src: string, dest: string): any;
+    abstract startBuildProcesses(): Promise<void>;
+    abstract tscCheck({ entrypoint, addableFiles, platform, }: {
+        entrypoint: string;
+        addableFiles: string[];
+        platform: IRunTime;
+    }): any;
+    abstract eslintCheck({ entrypoint, addableFiles, platform, }: {
+        entrypoint: string;
+        addableFiles: string[];
+        platform: IRunTime;
+    }): any;
+    abstract onBuildDone(): void;
+    runningProcesses: Map<string, ChildProcess | Promise<any>>;
+    allProcesses: Map<string, {
+        child?: ChildProcess;
+        promise?: Promise<any>;
+        status: "running" | "exited" | "error" | "completed";
+        exitCode?: number;
+        error?: string;
+        command: string;
+        pid?: number;
+        timestamp: string;
+        type: "process" | "promise";
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName?: string;
+        platform?: "node" | "web" | "pure" | "python" | "golang";
+    }>;
+    processLogs: Map<string, string[]>;
+    clients: Set<any>;
+    fs: import("@isomorphic-git/lightning-fs");
+    connected: boolean;
+    constructor(configs: IBuiltConfig, name: any, mode: any);
+    writeBigBoard: () => void;
+    webSocketBroadcastMessage(message: any): void;
+    addPromiseProcess(processId: string, promise: Promise<any>, command: string, category?: "aider" | "bdd-test" | "build-time" | "other", testName?: string, platform?: "node" | "web" | "pure" | "python" | "golang", onResolve?: (result: any) => void, onReject?: (error: any) => void): string;
+    getProcessesByCategory(category: "aider" | "bdd-test" | "build-time" | "other"): {
+        processId: string;
+        command: string;
+        pid: number | undefined;
+        status: "error" | "running" | "exited" | "completed";
+        exitCode: number | undefined;
+        error: string | undefined;
+        timestamp: string;
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName: string | undefined;
+        platform: "node" | "web" | "pure" | "golang" | "python" | undefined;
+        logs: string[];
+    }[];
+    getBDDTestProcesses(): {
+        processId: string;
+        command: string;
+        pid: number | undefined;
+        status: "error" | "running" | "exited" | "completed";
+        exitCode: number | undefined;
+        error: string | undefined;
+        timestamp: string;
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName: string | undefined;
+        platform: "node" | "web" | "pure" | "golang" | "python" | undefined;
+        logs: string[];
+    }[];
+    getBuildTimeProcesses(): {
+        processId: string;
+        command: string;
+        pid: number | undefined;
+        status: "error" | "running" | "exited" | "completed";
+        exitCode: number | undefined;
+        error: string | undefined;
+        timestamp: string;
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName: string | undefined;
+        platform: "node" | "web" | "pure" | "golang" | "python" | undefined;
+        logs: string[];
+    }[];
+    getAiderProcesses(): {
+        processId: string;
+        command: string;
+        pid: number | undefined;
+        status: "error" | "running" | "exited" | "completed";
+        exitCode: number | undefined;
+        error: string | undefined;
+        timestamp: string;
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName: string | undefined;
+        platform: "node" | "web" | "pure" | "golang" | "python" | undefined;
+        logs: string[];
+    }[];
+    getProcessesByTestName(testName: string): {
+        processId: string;
+        command: string;
+        pid: number | undefined;
+        status: "error" | "running" | "exited" | "completed";
+        exitCode: number | undefined;
+        error: string | undefined;
+        timestamp: string;
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName: string | undefined;
+        platform: "node" | "web" | "pure" | "golang" | "python" | undefined;
+        logs: string[];
+    }[];
+    getProcessesByPlatform(platform: "node" | "web" | "pure" | "pitono" | "golang"): {
+        processId: string;
+        command: string;
+        pid: number | undefined;
+        status: "error" | "running" | "exited" | "completed";
+        exitCode: number | undefined;
+        error: string | undefined;
+        timestamp: string;
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName: string | undefined;
+        platform: "node" | "web" | "pure" | "golang" | "python" | undefined;
+        logs: string[];
+    }[];
+    bddTestIsRunning(src: string): void;
+    metafileOutputs(platform: IRunTime): Promise<void>;
+    private findTestNameByEntrypoint;
+    pythonLintCheck(entrypoint: string, addableFiles: string[]): Promise<void>;
+    pythonTypeCheck(entrypoint: string, addableFiles: string[]): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    receiveFeaturesV2: (reportDest: string, srcTest: string, platform: IRunTime) => void;
+    addToQueue(src: string, runtime: IRunTime): void;
+    private cleanupTestProcesses;
+    checkQueue(): void;
+    checkForShutdown: () => void;
+    private ensureSummaryEntry;
+}

package/dist/types/src/app/backend/PM_2_WithTCP.d.ts

@@ -0,0 +1,29 @@
+import { WebSocketMessage } from "../../PM/types.js";
+import { WebSocketServer, WebSocket } from "ws";
+import http from "http";
+import { PM_1_WithProcesses } from "./PM_1_WithProcesses.js";
+export declare abstract class PM_2_WithTCP extends PM_1_WithProcesses {
+    protected wss: WebSocketServer;
+    protected httpServer: http.Server;
+    constructor(configs: any, name: string, mode: string);
+    protected websocket(data: any, ws: WebSocket): void;
+    handleHttpRequest(req: http.IncomingMessage, res: http.ServerResponse<http.IncomingMessage> & {
+        req: http.IncomingMessage;
+    }): void;
+    writeFile_send(wsm: WebSocketMessage, ws: WebSocket): void;
+    writeFile_receive(wsm: WebSocketMessage, ws: WebSocket): void;
+    readFile_receive(wsm: WebSocketMessage, ws: WebSocket): void;
+    readFile_send(wsm: WebSocketMessage, ws: WebSocket, content: string): void;
+    createDirectory_receive(wsm: WebSocketMessage, ws: WebSocket): void;
+    createDirectory_send(wsm: WebSocketMessage, ws: WebSocket): void;
+    deleteFile_receive(wsm: WebSocketMessage, ws: WebSocket): void;
+    deleteFile_send(wsm: WebSocketMessage, ws: WebSocket): void;
+    files_receive(wsm: WebSocketMessage, ws: WebSocket): Promise<void>;
+    files_send(wsm: WebSocketMessage, ws: WebSocket, files: string[]): void;
+    projects_receive(wsm: WebSocketMessage, ws: WebSocket): void;
+    projects_send(wsm: WebSocketMessage, ws: WebSocket, projects: object): void;
+    report_receive(wsm: WebSocketMessage, ws: WebSocket): void;
+    report_send(wsm: WebSocketMessage, ws: WebSocket): Promise<void>;
+    test_receive(wsm: WebSocketMessage, ws: WebSocket): Promise<void>;
+    test_send(wsm: WebSocketMessage, ws: WebSocket, project: string[]): void;
+}

package/dist/types/src/app/backend/PM_WithBuild.d.ts

@@ -0,0 +1,8 @@
+import { IBuiltConfig } from "../../Types.js";
+import { PM_2_WithTCP } from "./PM_2_WithTCP.js";
+export declare abstract class PM_WithBuild extends PM_2_WithTCP {
+    configs: IBuiltConfig;
+    currentBuildResolve: (() => void) | null;
+    currentBuildReject: ((error: any) => void) | null;
+    startBuildProcess(configer: (config: IBuiltConfig, entryPoints: string[], testName: string) => any, entryPoints: Record<string, string>, runtime: string): Promise<void>;
+}

package/dist/types/src/app/backend/PM_WithEslintAndTsc.d.ts

@@ -0,0 +1,22 @@
+import { IBuiltConfig, IRunTime } from "../../Types.js";
+import { PM_WithBuild } from "./PM_WithBuild";
+import { IMode } from "../types";
+export declare abstract class PM_WithEslintAndTsc extends PM_WithBuild {
+    constructor(configs: IBuiltConfig, name: string, mode: IMode);
+    tscCheck: ({ entrypoint, addableFiles, platform, }: {
+        entrypoint: string;
+        addableFiles: string[];
+        platform: IRunTime;
+    }) => Promise<any>;
+    eslintCheck: ({ entrypoint, addableFiles, platform, }: {
+        entrypoint: string;
+        addableFiles: string[];
+        platform: IRunTime;
+    }) => Promise<void>;
+    typeCheckIsRunning: (src: string) => void;
+    typeCheckIsNowDone: (src: string, failures: number) => void;
+    lintIsRunning: (src: string) => void;
+    lintIsNowDone: (src: string, failures: number) => void;
+    bddTestIsRunning: (src: string) => void;
+    bddTestIsNowDone: (src: string, failures: number) => void;
+}

package/dist/types/src/app/backend/PM_WithGit.d.ts

@@ -0,0 +1,24 @@
+import { IBuiltConfig } from "../../Types.js";
+import { PM_WithEslintAndTsc } from "./PM_WithEslintAndTsc.js";
+export declare abstract class PM_WithGit extends PM_WithEslintAndTsc {
+    gitWatchTimeout: NodeJS.Timeout | null;
+    gitWatcher: any;
+    constructor(configs: IBuiltConfig, name: any, mode: any);
+    private handleGitChanges;
+    private handleGitFileStatus;
+    private handleGitCommit;
+    private handleGitPush;
+    private handleGitPull;
+    private handleGitBranch;
+    private handleGitHubTokenExchange;
+    private handleGitRemoteStatus;
+    private getGitFileStatus;
+    private executeGitCommit;
+    private executeGitPush;
+    private executeGitPull;
+    onBuildDone(): void;
+    startGitWatcher(): Promise<void>;
+    private getGitChanges;
+    private getGitRemoteStatus;
+    private getCurrentGitBranch;
+}

package/dist/types/src/app/backend/PM_WithHelpo.d.ts

@@ -0,0 +1,43 @@
+/**
+ * PM_WithHelpo - Process Manager with Helpo Integration
+ *
+ * Helpo is a chat agent using aider that operates separately from other processes.
+ *
+ * How it works:
+ * 1. The server accepts chat messages from the frontend via WebSocket
+ * 2. Messages are added to a managed chat history file (FIFO data structure)
+ * 3. The managed history implements a rolling context window
+ * 4. Messages are passed to the helpo/aider Python process
+ * 5. Responses from helpo are also added to the managed history
+ * 6. Context is cleared after every exchange to maintain a rolling window
+ *
+ * The managed chat history ensures:
+ * - Recent conversation context is preserved within limits
+ * - Old messages are automatically pruned to prevent context overflow
+ * - Each exchange is self-contained within the rolling window
+ */
+import { IBuiltConfig } from "../../Types.js";
+import { ChildProcess } from "node:child_process";
+import { PM_WithGit } from "./PM_WithGit.js";
+interface ChatMessage {
+    type: "user" | "assistant";
+    content: string;
+    timestamp: string;
+}
+export declare abstract class PM_WithHelpo extends PM_WithGit {
+    aiderProcess: ChildProcess | null;
+    chatHistoryPath: string;
+    MAX_HISTORY_SIZE: number;
+    isAiderAtPrompt: boolean;
+    constructor(configs: IBuiltConfig, name: any, mode: any);
+    private initializeChatHistory;
+    private startAiderProcess;
+    private processAiderResponse;
+    private restartAiderProcess;
+    isAiderAvailable(): boolean;
+    private addToChatHistory;
+    private trimChatHistory;
+    getChatHistory(): Promise<ChatMessage[]>;
+    handleChatMessage(userMessage: string): Promise<void>;
+}
+export {};

package/dist/types/src/app/backend/PM_WithTCP.d.ts

@@ -0,0 +1,41 @@
+import { ChildProcess } from "child_process";
+import http from "http";
+import { RawData, WebSocketServer } from "ws";
+import { IBuiltConfig } from "../../Types.js";
+import { FileService } from "../FileService.js";
+import { PM_Base } from "./PM_0.js";
+export declare abstract class PM_WithTCP extends PM_Base implements FileService {
+    wss: WebSocketServer;
+    httpServer: http.Server;
+    clients: Set<any>;
+    runningProcesses: Map<string, ChildProcess | Promise<any>>;
+    allProcesses: Map<string, {
+        child?: ChildProcess;
+        promise?: Promise<any>;
+        status: "running" | "exited" | "error" | "completed";
+        exitCode?: number;
+        error?: string;
+        command: string;
+        pid?: number;
+        timestamp: string;
+        type: "process" | "promise";
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName?: string;
+        platform?: "node" | "web" | "pure" | "python" | "golang";
+    }>;
+    processLogs: Map<string, string[]>;
+    constructor(configs: IBuiltConfig, name: any, mode: any);
+    websocket(data: RawData, ws: any): void;
+    webSocketBroadcastMessage(message: any): void;
+    handleHttpRequest(req: http.IncomingMessage, res: http.ServerResponse<http.IncomingMessage> & {
+        req: http.IncomingMessage;
+    }): void;
+    writeFile(path: string, content: string): Promise<void>;
+    readFile(path: string): Promise<string>;
+    createDirectory(path: string): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    files(path: string): Promise<object>;
+    projects(project: string): Promise<string[]>;
+    tests(project: string): Promise<string[]>;
+    report(project: string, test: string): Promise<object>;
+}

package/dist/types/src/app/backend/getAllFilesRecursively.d.ts

@@ -0,0 +1 @@
+export declare function getAllFilesRecursively(directoryPath: any): Promise<string[]>;

package/dist/types/src/app/backend/main.d.ts

@@ -0,0 +1,15 @@
+import { PM_WithHelpo } from "./PM_WithHelpo.js";
+export declare class PM_Main extends PM_WithHelpo {
+    startBuildProcesses(): Promise<void>;
+    private setupTestEnvironment;
+    private cleanupPorts;
+    private createIpcServer;
+    private handleChildProcess;
+    launchPure: (src: string, dest: string) => Promise<void>;
+    launchNode: (src: string, dest: string) => Promise<void>;
+    launchWeb: (src: string, dest: string) => Promise<void>;
+    launchPython: (src: string, dest: string) => Promise<void>;
+    launchGolang: (src: string, dest: string) => Promise<void>;
+    private processGoTestOutput;
+    private generatePromptFiles;
+}

package/dist/types/src/app/backend/makePrompt.d.ts

@@ -0,0 +1,2 @@
+import { IRunTime, ISummary } from "../../Types";
+export declare const makePrompt: (summary: ISummary, name: string, entryPoint: string, addableFiles: string[], runTime: IRunTime) => Promise<void>;

package/dist/types/src/app/backend/utils.d.ts

@@ -0,0 +1,20 @@
+import { IRunnables } from "../../lib";
+import { IRunTime, IBuiltConfig, ITestTypes } from "../../Types";
+export declare const webEvaluator: (d: any, webArgz: any) => string;
+export declare const destinationOfRuntime: (f: string, r: IRunTime, configs: IBuiltConfig) => string;
+export declare const tscPather: (entryPoint: string, platform: IRunTime, projectName: string) => string;
+export declare const lintPather: (entryPoint: string, platform: IRunTime, projectName: string) => string;
+export declare const bddPather: (entryPoint: string, platform: IRunTime, projectName: string) => string;
+export declare const promptPather: (entryPoint: string, platform: IRunTime, projectName: string) => string;
+export declare const getRunnables: (tests: ITestTypes[], projectName: string, payload?: {
+    nodeEntryPoints: {};
+    nodeEntryPointSidecars: {};
+    webEntryPoints: {};
+    webEntryPointSidecars: {};
+    pureEntryPoints: {};
+    pureEntryPointSidecars: {};
+    golangEntryPoints: {};
+    golangEntryPointSidecars: {};
+    pythonEntryPoints: {};
+    pythonEntryPointSidecars: {};
+}) => IRunnables;

package/dist/types/src/app/frontend/App.d.ts

@@ -0,0 +1,14 @@
+interface TutorialModeContextType {
+    tutorialMode: boolean;
+    setTutorialMode: (mode: boolean) => void;
+}
+interface AuthContextType {
+    isAuthenticated: boolean;
+    user: any;
+    login: () => void;
+    logout: () => void;
+}
+export declare const useTutorialMode: () => TutorialModeContextType;
+export declare const useAuth: () => AuthContextType;
+export declare const App: () => JSX.Element;
+export {};

package/dist/types/src/app/frontend/DevelopmentFileService.d.ts

@@ -0,0 +1,25 @@
+import lfs from "@isomorphic-git/lightning-fs";
+import { FileService } from "../FileService";
+export declare class DevelopmentFileService extends FileService {
+    private ws;
+    fs: lfs;
+    readonly connected: boolean;
+    constructor();
+    setSocket(ws: WebSocket): void;
+    createDirectory_send(s: string): void;
+    createDirectory_receive(x: any[]): void;
+    deleteFile_send(s: string): void;
+    deleteFile_receive(s: string): void;
+    writeFile_send(f: string, c: string): void;
+    writeFile_receive(s: string, c: string): void;
+    readFile_send(f: string): void;
+    readFile_receive(f: string, c: string): void;
+    files_send(): void;
+    files_receive(files: string[]): void;
+    projects_send(): void;
+    projects_receive(tests: string[]): void;
+    tests_send(project: string): void;
+    tests_receive(tests: any[]): void;
+    report_send(project: string, test: string): void;
+    report_receive(tests: string[]): Promise<object>;
+}