summer-engine 1.0.1 → 1.1.0

package/dist/bin/summer.js

@@ -11,6 +11,7 @@ import { installCommand } from "../commands/install.js";
 import { createCommand } from "../commands/create.js";
 import { listCommand } from "../commands/list.js";
 import { skillsCommand } from "../commands/skills.js";
+import { orchestratorCommand } from "../commands/orchestrator.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../../package.json");
 const program = new Command();
@@ -28,6 +29,7 @@ program.addCommand(createCommand);
 program.addCommand(listCommand);
 program.addCommand(skillsCommand);
 program.addCommand(mcpCommand);
+program.addCommand(orchestratorCommand);
 program.parseAsync().catch((err) => {
     console.error(err instanceof Error ? err.message : String(err));
     process.exit(1);

package/dist/commands/orchestrator.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CLI command: summer agent
+ * Launches the web app locally with direct engine execution enabled.
+ * The web app handles all AI logic (prompts, tools, RAG, billing).
+ * This command just starts it with LOCAL_ENGINE_PORT set.
+ */
+import { Command } from "commander";
+export declare const orchestratorCommand: Command;

package/dist/commands/orchestrator.js

@@ -0,0 +1,143 @@
+/**
+ * CLI command: summer agent
+ * Launches the web app locally with direct engine execution enabled.
+ * The web app handles all AI logic (prompts, tools, RAG, billing).
+ * This command just starts it with LOCAL_ENGINE_PORT set.
+ */
+import { Command } from "commander";
+import { spawn } from "node:child_process";
+import { readFile, access, writeFile } from "node:fs/promises";
+import { join, resolve, dirname } from "node:path";
+import { homedir } from "node:os";
+import { getApiToken, getApiPort, checkEngineHealth } from "../lib/engine.js";
+import { getSummerDir } from "../lib/auth.js";
+async function findWebAppPath() {
+    // 1. Check env var
+    if (process.env.SUMMER_WEB_APP_PATH) {
+        return process.env.SUMMER_WEB_APP_PATH;
+    }
+    // 2. Check ~/.summer/web-app-path
+    try {
+        const stored = (await readFile(join(getSummerDir(), "web-app-path"), "utf-8")).trim();
+        if (stored) {
+            await access(join(stored, "package.json"));
+            return stored;
+        }
+    }
+    catch {
+        // Not stored yet
+    }
+    // 3. Search common sibling locations
+    const cliDir = dirname(dirname(dirname(new URL(import.meta.url).pathname)));
+    const searchPaths = [
+        resolve(cliDir, "../../publicsummerengine"), // sibling in development/
+        resolve(cliDir, "../../../publicsummerengine"), // one level up
+        resolve(homedir(), "development/publicsummerengine"),
+    ];
+    for (const candidate of searchPaths) {
+        try {
+            await access(join(candidate, "package.json"));
+            const pkg = JSON.parse(await readFile(join(candidate, "package.json"), "utf-8"));
+            if (pkg.name && pkg.name.includes("summer")) {
+                // Store for future use
+                try {
+                    await writeFile(join(getSummerDir(), "web-app-path"), candidate, "utf-8");
+                }
+                catch {
+                    // Non-critical
+                }
+                return candidate;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+async function loadEnvFile() {
+    const envVars = {};
+    try {
+        const envPath = join(getSummerDir(), "env");
+        const content = await readFile(envPath, "utf-8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            const eqIdx = trimmed.indexOf("=");
+            if (eqIdx > 0) {
+                envVars[trimmed.slice(0, eqIdx)] = trimmed.slice(eqIdx + 1);
+            }
+        }
+    }
+    catch {
+        // No env file — user will need to have env vars set
+    }
+    return envVars;
+}
+export const orchestratorCommand = new Command("agent")
+    .description("Start the web app locally with direct engine execution. " +
+    "Tools call localhost:6550 instead of the Redis bridge.")
+    .option("-p, --port <number>", "Web app port", "3000")
+    .option("--web-path <path>", "Path to publicsummerengine (auto-detected if not set)")
+    .option("--dev", "Run in dev mode (pnpm dev) instead of production")
+    .action(async (opts) => {
+    const port = parseInt(opts.port, 10);
+    // 1. Verify engine is running
+    const enginePort = await getApiPort();
+    const engineToken = await getApiToken();
+    const health = await checkEngineHealth(enginePort);
+    if (!health) {
+        console.error("Summer Engine is not running. Open Summer Engine first.");
+        process.exit(1);
+    }
+    console.log(`Engine running on port ${enginePort} | project: ${health.project_name ?? "unknown"}`);
+    // 2. Find web app
+    const webAppPath = opts.webPath ?? (await findWebAppPath());
+    if (!webAppPath) {
+        console.error("Could not find publicsummerengine. Set --web-path or SUMMER_WEB_APP_PATH.");
+        process.exit(1);
+    }
+    console.log(`Web app: ${webAppPath}`);
+    // 3. Load env vars from ~/.summer/env
+    const storedEnv = await loadEnvFile();
+    // 4. Build env for the web app
+    const childEnv = {
+        ...process.env,
+        ...storedEnv,
+        LOCAL_ENGINE_PORT: String(enginePort),
+        LOCAL_ENGINE_TOKEN: engineToken ?? "",
+        PORT: String(port),
+    };
+    // 5. Start the web app
+    const cmd = opts.dev ? "pnpm" : "pnpm";
+    const args = opts.dev ? ["dev", "--port", String(port)] : ["start", "--port", String(port)];
+    console.log(`\nStarting web app (${opts.dev ? "dev" : "production"} mode) on port ${port}...`);
+    console.log(`  LOCAL_ENGINE_PORT=${enginePort}`);
+    console.log(`  Tools will execute via localhost:${enginePort} (direct, no bridge)\n`);
+    const child = spawn(cmd, args, {
+        cwd: webAppPath,
+        env: childEnv,
+        stdio: "inherit",
+    });
+    // Write agent port for engine to discover
+    try {
+        await writeFile(join(getSummerDir(), "agent-port"), String(port), "utf-8");
+    }
+    catch {
+        // Non-critical
+    }
+    child.on("error", (err) => {
+        console.error("Failed to start web app:", err.message);
+        process.exit(1);
+    });
+    child.on("exit", (code) => {
+        process.exit(code ?? 0);
+    });
+    // Graceful shutdown
+    const shutdown = () => {
+        child.kill("SIGTERM");
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+});

package/dist/commands/run.js

@@ -8,6 +8,7 @@ const MAC_PATHS = [
     `${process.env.HOME}/Applications/Summer.app/Contents/MacOS/Summer`,
 ];
 const WIN_PATHS = [
+    `${process.env.LOCALAPPDATA}\\SummerEngine\\current\\Summer.exe`,
     `${process.env.LOCALAPPDATA}\\Programs\\Summer Engine\\Summer.exe`,
     `${process.env.PROGRAMFILES}\\Summer Engine\\Summer.exe`,
 ];

package/dist/lib/api-client.d.ts

@@ -14,4 +14,10 @@ export declare class EngineApiClient {
     getScriptErrors(path: string): Promise<unknown>;
     play(scene?: string): Promise<unknown>;
     stop(): Promise<unknown>;
+    readFile(path: string, maxBytes?: number): Promise<unknown>;
+    getFsTree(root?: string, limit?: number): Promise<unknown>;
+    getSelection(): Promise<unknown>;
+    viewportSnapshot(): Promise<Buffer>;
+    gameSnapshot(): Promise<Buffer>;
+    getPort(): number;
 }

package/dist/lib/api-client.js

@@ -66,4 +66,43 @@ export class EngineApiClient {
     async stop() {
         return this.request("POST", "/api/stop");
     }
+    async readFile(path, maxBytes) {
+        const params = new URLSearchParams({ path });
+        if (maxBytes)
+            params.set("maxBytes", String(maxBytes));
+        return this.request("GET", `/api/state/read-file?${params}`);
+    }
+    async getFsTree(root = "res://", limit = 2000) {
+        const params = new URLSearchParams({
+            root,
+            limit: String(limit),
+        });
+        return this.request("GET", `/api/state/fs-tree?${params}`);
+    }
+    async getSelection() {
+        return this.request("GET", "/api/state/selection");
+    }
+    async viewportSnapshot() {
+        const url = `http://127.0.0.1:${this.port}/api/snapshot/viewport`;
+        const res = await fetch(url, {
+            headers: { Authorization: `Bearer ${this.token}` },
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!res.ok)
+            throw new Error(`Viewport snapshot failed: ${res.status}`);
+        return Buffer.from(await res.arrayBuffer());
+    }
+    async gameSnapshot() {
+        const url = `http://127.0.0.1:${this.port}/api/snapshot/game`;
+        const res = await fetch(url, {
+            headers: { Authorization: `Bearer ${this.token}` },
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!res.ok)
+            throw new Error(`Game snapshot failed: ${res.status}`);
+        return Buffer.from(await res.arrayBuffer());
+    }
+    getPort() {
+        return this.port;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "summer-engine",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "CLI and MCP tools for Summer Engine — the AI-native game engine",
   "keywords": [
     "game-engine",
@@ -37,12 +37,16 @@
     "node": ">=18"
   },
   "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "ai": "^6.0.0",
     "commander": "^12.0.0",
+    "diff": "^7.0.0",
     "open": "^10.0.0",
     "zod": "^3.23.0"
   },
   "devDependencies": {
+    "@types/diff": "^7.0.0",
     "@types/node": "^20.0.0",
     "typescript": "^5.5.0"
   }