@pulse-editor/cli 0.1.1-beta.9 → 0.1.3

package/dist/lib/webpack/configs/preview.js

@@ -0,0 +1,117 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import CopyWebpackPlugin from "copy-webpack-plugin";
+import fs from "fs";
+import HtmlWebpackPlugin from "html-webpack-plugin";
+import MiniCssExtractPlugin from "mini-css-extract-plugin";
+import path from "path";
+import { getLocalNetworkIP, loadPulseConfig } from "./utils.js";
+class PreviewClientPlugin {
+    projectDirName;
+    pulseConfig;
+    origin;
+    constructor(pulseConfig) {
+        this.projectDirName = process.cwd();
+        this.pulseConfig = pulseConfig;
+        this.origin = getLocalNetworkIP();
+    }
+    apply(compiler) {
+        let isFirstRun = true;
+        // Before build starts
+        compiler.hooks.watchRun.tap("ReloadMessagePlugin", () => {
+            if (!isFirstRun) {
+                console.log("[client-preview] 🔄 Reloading app...");
+            }
+            else {
+                console.log("[client-preview] 🔄 Building app...");
+            }
+        });
+        // After build finishes
+        compiler.hooks.done.tap("ReloadMessagePlugin", () => {
+            if (isFirstRun) {
+                const previewStartupMessage = `
+🎉 Your Pulse extension preview \x1b[1m${this.pulseConfig.displayName}\x1b[0m is LIVE! 
+
+⚡️ Local: http://localhost:3030
+⚡️ Network: http://${this.origin}:3030
+
+✨ Try it out in your browser and let the magic happen! 🚀
+`;
+                console.log("[client-preview] ✅ Successfully built preview.");
+                const skillActions = this.pulseConfig?.actions || [];
+                const actionNames = skillActions.map((a) => a.name);
+                if (actionNames.length > 0) {
+                    console.log("\n🎯 Skill action endpoints:\n" +
+                        actionNames.map((n) => ` - /skill/${n}`).join("\n") +
+                        "\n");
+                }
+                console.log(previewStartupMessage);
+                isFirstRun = false;
+            }
+            else {
+                console.log("[client-preview] ✅ Reload finished");
+            }
+            // Write pulse config to dist
+            fs.writeFileSync(path.resolve(this.projectDirName, "dist/pulse.config.json"), JSON.stringify(this.pulseConfig, null, 2));
+        });
+    }
+}
+export async function makePreviewClientConfig(mode) {
+    const projectDirName = process.cwd();
+    const pulseConfig = await loadPulseConfig();
+    return {
+        mode: mode,
+        entry: {
+            main: "./node_modules/.pulse/server/preview/frontend/index.js",
+        },
+        output: {
+            path: path.resolve(projectDirName, "dist/client"),
+        },
+        resolve: {
+            extensions: [".ts", ".tsx", ".js"],
+        },
+        plugins: [
+            new HtmlWebpackPlugin({
+                template: "./node_modules/.pulse/server/preview/frontend/index.html",
+            }),
+            new MiniCssExtractPlugin({
+                filename: "globals.css",
+            }),
+            new CopyWebpackPlugin({
+                patterns: [{ from: "src/assets", to: "assets" }],
+            }),
+            new PreviewClientPlugin(pulseConfig),
+        ],
+        watchOptions: {
+            ignored: /src\/server-function/,
+        },
+        module: {
+            rules: [
+                {
+                    test: /\.tsx?$/,
+                    use: "ts-loader",
+                    exclude: [/node_modules/, /dist/],
+                },
+                {
+                    test: /\.css$/i,
+                    use: [
+                        MiniCssExtractPlugin.loader,
+                        "css-loader",
+                        {
+                            loader: "postcss-loader",
+                        },
+                    ],
+                },
+            ],
+        },
+        stats: {
+            all: false,
+            errors: true,
+            warnings: true,
+            logging: "warn",
+            colors: true,
+        },
+        infrastructureLogging: {
+            level: "warn",
+        },
+    };
+}

package/dist/lib/webpack/configs/utils.d.ts

@@ -0,0 +1,10 @@
+export declare function loadPulseConfig(): Promise<any>;
+export declare function getLocalNetworkIP(): string;
+export declare function readConfigFile(): Promise<any>;
+export declare function discoverServerFunctions(): {
+    [x: string]: string;
+};
+export declare function discoverAppSkillActions(): {
+    [x: string]: string;
+} | null;
+export declare function generateTempTsConfig(): void;

package/dist/lib/webpack/configs/utils.js

@@ -0,0 +1,172 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { existsSync, writeFileSync } from "fs";
+import fs from "fs/promises";
+import { globSync } from "glob";
+import { networkInterfaces } from "os";
+import path from "path";
+import { Project, SyntaxKind } from "ts-morph";
+import ts from "typescript";
+import { pathToFileURL } from "url";
+export async function loadPulseConfig() {
+    const projectDirName = process.cwd();
+    // compile to js file and import
+    const program = ts.createProgram({
+        rootNames: [path.join(projectDirName, "pulse.config.ts")],
+        options: {
+            module: ts.ModuleKind.ESNext,
+            target: ts.ScriptTarget.ES2020,
+            outDir: path.join(projectDirName, "node_modules/.pulse/config"),
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+        },
+    });
+    program.emit();
+    // Fix imports in the generated js file for all files in node_modules/.pulse/config
+    globSync("node_modules/.pulse/config/**/*.js", {
+        cwd: projectDirName,
+        absolute: true,
+    }).forEach(async (jsFile) => {
+        let content = await fs.readFile(jsFile, "utf-8");
+        content = content.replace(/(from\s+["']\.\/[^\s"']+)(["'])/g, (match, p1, p2) => {
+            // No change if the import already has any extension
+            if (p1.match(/\.(js|cjs|mjs|ts|tsx|json)$/)) {
+                return match; // No change needed
+            }
+            return `${p1}.js${p2}`;
+        });
+        await fs.writeFile(jsFile, content);
+    });
+    // Copy package.json if exists
+    const pkgPath = path.join(projectDirName, "package.json");
+    if (existsSync(pkgPath)) {
+        const destPath = path.join(projectDirName, "node_modules/.pulse/config/package.json");
+        await fs.copyFile(pkgPath, destPath);
+    }
+    const compiledConfig = path.join(projectDirName, "node_modules/.pulse/config/pulse.config.js");
+    const mod = await import(pathToFileURL(compiledConfig).href);
+    // delete the compiled config after importing
+    await fs.rm(path.join(projectDirName, "node_modules/.pulse/config"), {
+        recursive: true,
+        force: true,
+    });
+    return mod.default;
+}
+export function getLocalNetworkIP() {
+    const interfaces = networkInterfaces();
+    for (const iface of Object.values(interfaces)) {
+        if (!iface)
+            continue;
+        for (const config of iface) {
+            if (config.family === "IPv4" && !config.internal) {
+                return config.address; // Returns the first non-internal IPv4 address
+            }
+        }
+    }
+    return "localhost"; // Fallback
+}
+export async function readConfigFile() {
+    // Read pulse.config.json from dist/client
+    // Wait until dist/pulse.config.json exists
+    while (true) {
+        try {
+            await fs.access("dist/pulse.config.json");
+            break;
+        }
+        catch (err) {
+            // Wait for 100ms before trying again
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    const data = await fs.readFile("dist/pulse.config.json", "utf-8");
+    return JSON.parse(data);
+}
+export function discoverServerFunctions() {
+    // Get all .ts files under src/server-function and read use default exports as entry points
+    const files = globSync("./src/server-function/**/*.ts");
+    const entryPoints = files
+        .map((file) => file.replaceAll("\\", "/"))
+        .map((file) => {
+        return {
+            ["./" + file.replace("src/server-function/", "").replace(/\.ts$/, "")]: "./" + file,
+        };
+    })
+        .reduce((acc, curr) => {
+        return { ...acc, ...curr };
+    }, {});
+    return entryPoints;
+}
+export function discoverAppSkillActions() {
+    // Get all .ts files under src/skill and read use default exports as entry points
+    const files = globSync("./src/skill/*/action.ts");
+    const entryPoints = files
+        .map((file) => file.replaceAll("\\", "/"))
+        .map((file) => {
+        // Read default export info in the file using ts-morph to get the function name, and use the function name as the entry point key instead of the file name
+        const project = new Project({
+            tsConfigFilePath: path.join(process.cwd(), "node_modules/.pulse/tsconfig.server.json"),
+        });
+        const sourceFile = project.addSourceFileAtPath(file);
+        const defaultExportSymbol = sourceFile.getDefaultExportSymbol();
+        if (!defaultExportSymbol) {
+            console.warn(`No default export found in action file ${file}. Skipping...`);
+            return null;
+        }
+        const defaultExportDeclarations = defaultExportSymbol.getDeclarations();
+        if (defaultExportDeclarations.length === 0) {
+            console.warn(`No declarations found for default export in action file ${file}. Skipping...`);
+            return null;
+        }
+        const funcDecl = defaultExportDeclarations[0]?.asKind(SyntaxKind.FunctionDeclaration);
+        if (!funcDecl) {
+            console.warn(`Default export in action file ${file} is not a function declaration. Skipping...`);
+            return null;
+        }
+        // Match `*/src/skill/{actionName}/action.ts` and extract {actionName}
+        const pattern = /src\/skill\/([^\/]+)\/action\.ts$/;
+        const match = file.replaceAll("\\", "/").match(pattern);
+        if (!match) {
+            console.warn(`File path ${file} does not match pattern ${pattern}. Skipping...`);
+            return null;
+        }
+        const actionName = match[1];
+        if (!actionName) {
+            console.warn(`Could not extract action name from file path ${file}. Skipping...`);
+            return null;
+        }
+        return {
+            ["./skill/" + actionName]: "./" + file,
+        };
+    })
+        .reduce((acc, curr) => {
+        return { ...acc, ...curr };
+    }, {});
+    return entryPoints;
+}
+// Generate tsconfig for server functions
+export function generateTempTsConfig() {
+    const tempTsConfigPath = path.join(process.cwd(), "node_modules/.pulse/tsconfig.server.json");
+    if (existsSync(tempTsConfigPath)) {
+        return;
+    }
+    const tsConfig = {
+        compilerOptions: {
+            target: "ES2020",
+            module: "esnext",
+            moduleResolution: "bundler",
+            strict: true,
+            declaration: true,
+            outDir: path.join(process.cwd(), "dist"),
+        },
+        include: [
+            path.join(process.cwd(), "src/server-function/**/*"),
+            path.join(process.cwd(), "pulse.config.ts"),
+            path.join(process.cwd(), "global.d.ts"),
+        ],
+        exclude: [
+            path.join(process.cwd(), "node_modules"),
+            path.join(process.cwd(), "dist"),
+        ],
+    };
+    writeFileSync(tempTsConfigPath, JSON.stringify(tsConfig, null, 2));
+}

package/dist/lib/webpack/dist/pregistered-actions.d.ts

@@ -0,0 +1,2 @@
+import { Action } from "@pulse-editor/shared-utils";
+export declare const preRegisteredActions: Record<string, Action>;

package/dist/lib/webpack/dist/pulse.config.d.ts

@@ -0,0 +1,7 @@
+import { AppConfig } from "@pulse-editor/shared-utils";
+/**
+ * Pulse Editor Extension Config
+ *
+ */
+declare const config: AppConfig;
+export default config;

package/dist/lib/webpack/dist/src/lib/agents/code-modifier-agent.d.ts

@@ -0,0 +1,2 @@
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+export declare const codeModifierAgentPrompt: ChatPromptTemplate<any, any>;

package/dist/lib/webpack/dist/src/lib/agents/vibe-coding-agent.d.ts

@@ -0,0 +1,3 @@
+import { MultiServerMCPClient } from "@langchain/mcp-adapters";
+import { MessageStreamController } from "../streaming/message-stream-controller";
+export declare function runVibeCoding(mcpClient: MultiServerMCPClient, userPrompt: string, controller: MessageStreamController): Promise<void>;

package/dist/lib/webpack/dist/src/lib/mcp/utils.d.ts

@@ -0,0 +1,3 @@
+import { MultiServerMCPClient } from "@langchain/mcp-adapters";
+export declare function writeFileToFS(mcpClient: MultiServerMCPClient, uri: string, content: string): Promise<string>;
+export declare function callTerminal(mcpClient: MultiServerMCPClient, command: string): Promise<string>;

package/dist/lib/webpack/dist/src/lib/streaming/message-stream-controller.d.ts

@@ -0,0 +1,10 @@
+import { AgentTaskMessageData } from "../types";
+export declare class MessageStreamController {
+    private controller;
+    private msgCounter;
+    private messages;
+    private timeCountMap;
+    constructor(controller: ReadableStreamDefaultController);
+    enqueueNew(data: AgentTaskMessageData, isFinal: boolean): number;
+    enqueueUpdate(data: AgentTaskMessageData, isFinal: boolean): void;
+}

package/dist/lib/webpack/dist/src/lib/types.d.ts

@@ -0,0 +1,58 @@
+export type VibeDevFlowNode = {
+    id: string;
+    children: VibeDevFlowNode[];
+};
+export declare enum AgentTaskMessageType {
+    Creation = "creation",
+    Update = "update"
+}
+export declare enum AgentTaskMessageDataType {
+    Notification = "notification",
+    ToolCall = "toolCall",
+    ArtifactOutput = "artifactOutput"
+}
+/**
+ * Data associated with an AgentTaskItem.
+ * The fields included depend on the type of the task item.
+ *
+ * @property type - The type of the task item, defined by the AgentTaskItemType enum.
+ * @property title - (Optional) A brief title or summary of the task item.
+ * @property description - (Optional) A detailed description of the task item.
+ * @property toolName - (Optional) The name of the tool being called (if applicable).
+ * @property parameters - (Optional) A record of parameters associated with the tool call (if applicable).
+ * @property error - (Optional) An error message if the task item represents an error.
+ * @property result - (Optional) The result or output of the task item (if applicable).
+ */
+export type AgentTaskMessageData = {
+    type?: AgentTaskMessageDataType;
+    title?: string;
+    description?: string;
+    toolName?: string;
+    parameters?: Record<string, unknown>;
+    error?: string;
+    result?: string;
+};
+/**
+ * Represents a single task item generated by the agent.
+ * Each task item can be of different types such as tool calls, notifications, or errors.
+ *
+ * @property type - The type of the task item, defined by the AgentTaskItemType enum.
+ * @property messageId - The unique identifier for the task item.
+ * This is an incremental number representing the n-th task item.
+ * @property data - The data associated with the task item, which varies based on the type.
+ * @property isFinal - (Optional) Indicates if the task item is final and no further updates are expected.
+ */
+export type AgentTaskMessage = {
+    type: AgentTaskMessageType;
+    messageId: number;
+    data: AgentTaskMessageData;
+    isFinal?: boolean;
+};
+export type AgentTaskMessageUpdate = {
+    type: AgentTaskMessageType;
+    messageId: number;
+    updateType: "append";
+    delta: AgentTaskMessageData;
+    isFinal?: boolean;
+    timeUsedSec?: string;
+};

package/dist/lib/webpack/dist/src/server-function/generate-code/v1/generate.d.ts

@@ -0,0 +1,5 @@
+/**
+ *  An example function to echo the body of a POST request.
+ *  This route is accessible at /server-function/echo
+ */
+export default function generate(req: Request): Promise<Response>;

package/dist/lib/webpack/dist/src/server-function/generate-code/v2/generate.d.ts

@@ -0,0 +1 @@
+export default function handler(req: Request): Promise<Response>;

package/dist/lib/webpack/tsconfig.server.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "esnext",
+        "moduleResolution": "bundler",
+        "strict": true,
+        "declaration": true,
+        "outDir": "dist",
+    },
+    "include": [
+        "../../../../../../src/server-function/**/*",
+        "../../../../../../pulse.config.ts",
+        "../../../../../../global.d.ts",
+    ],
+    "exclude": [
+        "../../../../../../node_modules",
+        "../../../../../../dist",
+    ]
+}

package/dist/lib/webpack/webpack-config.d.ts

@@ -0,0 +1 @@
+export declare function createWebpackConfig(isPreview: boolean, buildTarget: "client" | "server" | "both", mode: "development" | "production"): Promise<import("webpack").Configuration[]>;

package/dist/lib/webpack/webpack-config.js

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { makeMFClientConfig } from "./configs/mf-client.js";
+import { makeMFServerConfig } from "./configs/mf-server.js";
+import { makePreviewClientConfig } from "./configs/preview.js";
+export async function createWebpackConfig(isPreview, buildTarget, mode) {
+    if (isPreview) {
+        const previewClientConfig = await makePreviewClientConfig("development");
+        const mfServerConfig = await makeMFServerConfig("development");
+        return [previewClientConfig, mfServerConfig];
+    }
+    else if (buildTarget === "server") {
+        const mfServerConfig = await makeMFServerConfig(mode);
+        return [mfServerConfig];
+    }
+    else if (buildTarget === "client") {
+        const mfClientConfig = await makeMFClientConfig(mode);
+        return [mfClientConfig];
+    }
+    else {
+        const mfClientConfig = await makeMFClientConfig(mode);
+        const mfServerConfig = await makeMFServerConfig(mode);
+        return [mfClientConfig, mfServerConfig];
+    }
+}

package/dist/lib/webpack/webpack.config.d.ts

@@ -0,0 +1,2 @@
+import wp from 'webpack';
+export declare function createWebpackConfig(isPreview: boolean, buildTarget: 'client' | 'server' | 'both', mode: 'development' | 'production'): Promise<wp.Configuration[]>;