spawnfile 0.1.33 → 0.1.35

package/dist/runtime/pi/appAgentConfig.js

@@ -1,264 +0,0 @@
-import path from "node:path";
-import { listEffectiveExecutionModelTargets, resolveModelProviderEnvName } from "../../compiler/modelEnv.js";
-import { createShortHash, slugify, stableStringify } from "../../compiler/helpers.js";
-import { SpawnfileError } from "../../shared/index.js";
-import { resolveScriptedEngineStagedPath } from "./appScriptedEngine.js";
-import { PI_BUILTIN_TOOLS, PI_ENGINE_KINDS, PI_HARNESS_SYSTEM_PROMPT, PI_THINKING_FORMATS, PI_THINKING_LEVELS } from "./appTemplateTypes.js";
-const serializeJson = (value) => `${JSON.stringify(value, null, 2)}\n`;
-export const isPiEveryScheduleValue = (value) => /^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/u.test(value.trim());
-const isPiEngineKind = (value) => typeof value === "string" && PI_ENGINE_KINDS.includes(value);
-const isPiThinkingLevel = (value) => typeof value === "string" && PI_THINKING_LEVELS.includes(value);
-const isPiThinkingFormat = (value) => typeof value === "string" && PI_THINKING_FORMATS.includes(value);
-const formatDocumentInstructions = (node) => node.docs
-    .map((document) => `# ${document.role}\n\n${document.content}`)
-    .join("\n\n");
-const createCustomProviderId = (target) => {
-    const base = slugify(`${target.provider}-${target.endpoint?.compatibility ?? "builtin"}-${target.name}`);
-    return `${base || "model"}-${createShortHash(stableStringify({
-        auth: target.auth,
-        endpoint: target.endpoint,
-        name: target.name,
-        provider: target.provider
-    }))}`;
-};
-const resolveEndpointApi = (compatibility) => compatibility === "anthropic" ? "anthropic-messages" : "openai-completions";
-const OPENAI_THINKING_LEVEL_MAP = Object.freeze({
-    high: "high",
-    low: "low",
-    medium: "medium",
-    minimal: "low",
-    off: "none",
-    xhigh: "max"
-});
-const resolveEndpointApiKey = (target) => target.auth.method === "api_key"
-    ? `$${target.auth.key ?? resolveModelProviderEnvName(target.provider)}`
-    : "ollama";
-const resolvePiModel = (node) => {
-    const [target] = listEffectiveExecutionModelTargets(node.execution);
-    if (!target) {
-        return {
-            auth_method: "codex",
-            name: "gpt-5.4-mini",
-            provider: "openai-codex"
-        };
-    }
-    if (target.endpoint) {
-        return {
-            auth_method: target.auth.method,
-            name: target.name,
-            provider: createCustomProviderId(target)
-        };
-    }
-    if (target.provider === "openai" && target.auth.method === "codex") {
-        return {
-            auth_method: target.auth.method,
-            name: target.name,
-            provider: "openai-codex"
-        };
-    }
-    return {
-        auth_method: target.auth.method,
-        name: target.name,
-        provider: target.provider
-    };
-};
-export const resolvePiEngine = (node) => {
-    const value = node.runtime.options.engine;
-    if (value === undefined) {
-        return { kind: "pi" };
-    }
-    if (isPiEngineKind(value)) {
-        return { kind: value };
-    }
-    throw new SpawnfileError("validation_error", `Pi runtime option engine must be one of ${PI_ENGINE_KINDS.join(", ")}`);
-};
-export const resolvePiThinkingLevel = (node) => {
-    const value = node.runtime.options.thinking;
-    if (value === undefined)
-        return undefined;
-    if (isPiThinkingLevel(value))
-        return value;
-    throw new SpawnfileError("validation_error", `Pi runtime option thinking must be one of ${PI_THINKING_LEVELS.join(", ")}`);
-};
-export const resolvePiTools = (node) => {
-    const value = node.runtime.options.tools;
-    if (value === undefined)
-        return [...PI_BUILTIN_TOOLS];
-    if (Array.isArray(value)
-        && value.every((item) => typeof item === "string"
-            && PI_BUILTIN_TOOLS.includes(item))
-        && new Set(value).size === value.length) {
-        return [...value];
-    }
-    throw new SpawnfileError("validation_error", `Pi runtime option tools must contain unique values from ${PI_BUILTIN_TOOLS.join(", ")}`);
-};
-export const resolvePiThinkingFormat = (node) => {
-    const value = node.runtime.options.thinking_format;
-    if (value === undefined)
-        return undefined;
-    if (isPiThinkingFormat(value))
-        return value;
-    throw new SpawnfileError("validation_error", `Pi runtime option thinking_format must be one of ${PI_THINKING_FORMATS.join(", ")}`);
-};
-export const resolvePiRawTrainingCapture = (node) => {
-    const value = node.runtime.options.raw_training_capture_turns;
-    if (value === undefined)
-        return undefined;
-    if (Number.isSafeInteger(value)
-        && typeof value === "number"
-        && value >= 1
-        && value <= 100_000) {
-        return {
-            enabled: true,
-            retention: { maxTurns: value }
-        };
-    }
-    throw new SpawnfileError("validation_error", "Pi runtime option raw_training_capture_turns must be an integer between 1 and 100000");
-};
-export const renderPiModelsConfig = (nodes) => {
-    const providers = new Map();
-    for (const node of nodes) {
-        for (const target of listEffectiveExecutionModelTargets(node.execution)) {
-            if (!target.endpoint) {
-                continue;
-            }
-            const providerId = createCustomProviderId(target);
-            const api = resolveEndpointApi(target.endpoint.compatibility);
-            const provider = providers.get(providerId) ?? {
-                api,
-                apiKey: resolveEndpointApiKey(target),
-                baseUrl: target.endpoint.base_url,
-                models: []
-            };
-            if (!provider.models.some((model) => model.id === target.name)) {
-                const explicitOpenAiThinking = target.endpoint.compatibility === "openai"
-                    && node.runtime.options.thinking !== undefined;
-                const thinkingFormat = resolvePiThinkingFormat(node);
-                provider.models.push({
-                    api,
-                    baseUrl: target.endpoint.base_url,
-                    contextWindow: 128000,
-                    cost: {
-                        cacheRead: 0,
-                        cacheWrite: 0,
-                        input: 0,
-                        output: 0
-                    },
-                    id: target.name,
-                    input: ["text"],
-                    maxTokens: 16384,
-                    name: target.name,
-                    reasoning: explicitOpenAiThinking,
-                    ...(thinkingFormat === undefined || thinkingFormat === "openai"
-                        ? {}
-                        : { compat: { thinkingFormat } }),
-                    ...(explicitOpenAiThinking
-                        ? { thinkingLevelMap: OPENAI_THINKING_LEVEL_MAP }
-                        : {})
-                });
-            }
-            providers.set(providerId, provider);
-        }
-    }
-    return serializeJson({
-        providers: Object.fromEntries([...providers.entries()].sort(([left], [right]) => left.localeCompare(right)))
-    });
-};
-const resolveSchedule = (node) => {
-    if (!node.schedule || node.schedule.kind === "disabled") {
-        return node.schedule ? { kind: "disabled" } : undefined;
-    }
-    if (node.schedule.kind === "every") {
-        return {
-            every: node.schedule.every,
-            kind: "every",
-            ...(node.schedule.prompt ? { prompt: node.schedule.prompt } : {})
-        };
-    }
-    return undefined;
-};
-const resolveMemoryRuntimeHomePath = (node) => {
-    const [access] = [...(node.memoryAccess ?? [])].sort((left, right) => `${left.source}:${left.bank.id}`.localeCompare(`${right.source}:${right.bank.id}`));
-    if (!access) {
-        return undefined;
-    }
-    const store = access.bank.store;
-    if (store.kind === "postgres") {
-        return undefined;
-    }
-    const vector = access.bank.index?.vector;
-    const embedding = vector?.enabled && vector.model && (!vector.provider || vector.provider === "ollama")
-        ? {
-            ...(vector.base_url ? { base_url: vector.base_url } : {}),
-            ...(vector.dimensions ? { dimensions: vector.dimensions } : {}),
-            model: vector.model,
-            provider: "ollama",
-            ...(vector.timeout_ms ? { timeout_ms: vector.timeout_ms } : {})
-        }
-        : undefined;
-    if (store.kind === "memory") {
-        return {
-            bank_id: access.bank.id,
-            ...(resolveMemoryConsolidation(access) ? { consolidation: resolveMemoryConsolidation(access) } : {}),
-            ...(embedding ? { embedding } : {}),
-            runtime_home_path: `/var/lib/spawnfile/memory/${slugify(access.bank.declaredName) || "memory"}/${access.bank.id}`,
-            source: `spawnfile:${access.declaringKind}:${access.bank.id}`
-        };
-    }
-    const runtimeHomePath = store.persistence?.mount ?? path.posix.dirname(store.path ?? "");
-    if (!runtimeHomePath) {
-        return undefined;
-    }
-    return {
-        bank_id: access.bank.id,
-        ...(resolveMemoryConsolidation(access) ? { consolidation: resolveMemoryConsolidation(access) } : {}),
-        ...(embedding ? { embedding } : {}),
-        runtime_home_path: runtimeHomePath,
-        source: `spawnfile:${access.declaringKind}:${access.bank.id}`
-    };
-};
-const resolveMemoryConsolidation = (access) => {
-    if (access.bank.consolidation.mode !== "scheduled" || !access.bank.consolidation.schedule) {
-        return undefined;
-    }
-    if (!isPiEveryScheduleValue(access.bank.consolidation.schedule)) {
-        return undefined;
-    }
-    return {
-        every: access.bank.consolidation.schedule,
-        kind: "every",
-        prompt: [
-            `Dream over Mneme memory bank ${access.bank.id}.`,
-            "Search the active dream scope and read-only global scope for stale, duplicate, noisy, or important memories.",
-            "Use memory_summarize, memory_register, or memory_forget only when consolidation is evidence-backed."
-        ].join(" ")
-    };
-};
-export const createPiAgentConfig = (node, slug, id, worldBinding) => {
-    const engineCommand = resolveScriptedEngineStagedPath(node);
-    const engine = resolvePiEngine(node);
-    const thinkingLevel = resolvePiThinkingLevel(node);
-    const rawTrainingCapture = resolvePiRawTrainingCapture(node);
-    return {
-        engine,
-        ...(engineCommand ? { engine_command: engineCommand } : {}),
-        id,
-        instructions: [
-            `You are ${node.name}.`,
-            node.description,
-            formatDocumentInstructions(node),
-            PI_HARNESS_SYSTEM_PROMPT
-        ].filter((part) => part.trim().length > 0).join("\n\n"),
-        model: resolvePiModel(node),
-        ...(resolveMemoryRuntimeHomePath(node) ? { memory: resolveMemoryRuntimeHomePath(node) } : {}),
-        name: node.name,
-        ...(rawTrainingCapture ? { raw_training_capture: rawTrainingCapture } : {}),
-        ...(resolveSchedule(node) ? { schedule: resolveSchedule(node) } : {}),
-        slug,
-        ...(thinkingLevel ? { thinking_level: thinkingLevel } : {}),
-        tools: resolvePiTools(node),
-        ...(worldBinding && engine.kind === "pi"
-            ? { world: { url: worldBinding.json.url, tokenEnv: worldBinding.token_env } }
-            : {})
-    };
-};

package/dist/runtime/pi/appCliEnginesSource.d.ts

@@ -1 +0,0 @@
-export declare const renderPiCliEnginesSource: () => string;

package/dist/runtime/pi/appCliEnginesSource.js

@@ -1,183 +0,0 @@
-export const renderPiCliEnginesSource = () => String.raw `const runCodexEngine = async (prompt, paths) => {
-  const engineHomePath = path.join(paths.runtimeHomePath, "codex-home");
-  await mkdir(path.join(engineHomePath, ".codex"), { recursive: true });
-  try {
-    const authSource = path.join(paths.homePath, ".codex", "auth.json");
-    const authTarget = path.join(engineHomePath, ".codex", "auth.json");
-    await writeFile(authTarget, await readFile(authSource, "utf8"));
-  } catch {}
-  const outputPath = path.join(paths.runtimeHomePath, "codex-" + Date.now() + ".txt");
-  const args = [
-    "exec",
-    "--sandbox",
-    process.env.SPAWNFILE_CODEX_SANDBOX ?? "danger-full-access",
-    "--ephemeral",
-    "--skip-git-repo-check",
-    "--ignore-rules",
-    "--color",
-    "never",
-    "-C",
-    paths.workspacePath,
-    "--output-last-message",
-    outputPath,
-    "-m",
-    process.env.DAIMON_CODEX_MODEL ?? "gpt-5.4-mini",
-    "-"
-  ];
-  const { stderr, stdout } = await spawnWithInput("codex", args, prompt, {
-    cwd: paths.workspacePath,
-    env: createEngineEnv(paths, engineHomePath)
-  });
-  try {
-    return stripAnsi(await readFile(outputPath, "utf8"));
-  } catch {
-    return stripAnsi([stdout, stderr].filter(Boolean).join("\n"));
-  }
-};
-
-const runClaudeEngine = async (prompt, paths) => {
-  const engineHomePath = path.join(paths.runtimeHomePath, "claude-home");
-  await mkdir(path.join(engineHomePath, ".claude"), { recursive: true });
-  await copyDirectoryIfExists(path.join(paths.homePath, ".claude"), path.join(engineHomePath, ".claude"));
-  await copyDirectoryIfExists(path.join(paths.homePath, ".claude.json"), path.join(engineHomePath, ".claude.json"));
-  const env = process.env.DAIMON_CLAUDE_USE_HOST_HOME === "1"
-    ? process.env
-    : createEngineEnv(paths, engineHomePath);
-  const output = await spawnWithInput("claude", [
-    "--print",
-    "--output-format",
-    "text",
-    "--no-session-persistence",
-    "--permission-mode",
-    process.env.DAIMON_CLAUDE_PERMISSION_MODE ?? "bypassPermissions",
-    "--model",
-    process.env.DAIMON_CLAUDE_MODEL ?? "sonnet",
-    "--add-dir",
-    paths.workspacePath
-  ], prompt, {
-    cwd: paths.workspacePath,
-    env
-  });
-  return cleanCliFinalText(output.stdout);
-};
-
-const runGrokEngine = async (prompt, paths) => {
-  const engineHomePath = path.join(paths.runtimeHomePath, "grok-home");
-  await mkdir(engineHomePath, { recursive: true });
-  const sharedGrok = await getSharedGrokHome(paths);
-  const promptPath = path.join(paths.runtimeHomePath, "grok-prompt-" + Date.now() + ".txt");
-  await writeFile(promptPath, prompt);
-  const output = await execFileAsync("grok", [
-    "--prompt-file",
-    promptPath,
-    "--max-turns",
-    process.env.DAIMON_GROK_MAX_TURNS ?? "24",
-    "--no-memory",
-    "--disable-web-search",
-    "--model",
-    process.env.DAIMON_GROK_MODEL ?? "grok-composer-2.5-fast",
-    "--cwd",
-    paths.workspacePath,
-    "--output-format",
-    "plain",
-    "--always-approve",
-    "--permission-mode",
-    process.env.DAIMON_GROK_PERMISSION_MODE ?? "auto",
-    "--allow",
-    "Bash"
-  ], {
-    ...cliOutputOptions,
-    cwd: paths.workspacePath,
-    env: createEngineEnv(paths, engineHomePath, {
-      GROK_HOME: sharedGrok.grokHomePath
-    })
-  });
-  await unlink(promptPath).catch(() => undefined);
-  return cleanCliFinalText(output.stdout);
-};
-
-const runAgyEngine = async (prompt, paths) => {
-  const engineHomePath = path.join(paths.runtimeHomePath, "agy-home");
-  await mkdir(engineHomePath, { recursive: true });
-  await copyDirectoryIfExists(
-    path.join(paths.homePath, ".config", "Antigravity"),
-    path.join(engineHomePath, ".config", "Antigravity")
-  );
-  await copyDirectoryIfExists(
-    path.join(paths.homePath, ".gemini", "antigravity-cli"),
-    path.join(engineHomePath, ".gemini", "antigravity-cli")
-  );
-  const outputPath = path.join(paths.runtimeHomePath, "agy-output-" + Date.now() + ".txt");
-  const errorPath = path.join(paths.runtimeHomePath, "agy-error-" + Date.now() + ".txt");
-  await spawnToFiles("agy", [
-    "--print",
-    prompt,
-    "--print-timeout",
-    process.env.DAIMON_AGY_TIMEOUT ?? "300s",
-    "--model",
-    process.env.DAIMON_AGY_MODEL ?? "Gemini 3.5 Flash (Low)",
-    "--new-project",
-    "--add-dir",
-    paths.workspacePath,
-    "--dangerously-skip-permissions"
-  ], {
-    cwd: paths.workspacePath,
-    env: createEngineEnv(paths, engineHomePath),
-    stderrPath: errorPath,
-    stdoutPath: outputPath
-  });
-  const text = cleanCliFinalText(await readBounded(outputPath));
-  await Promise.all([unlink(outputPath), unlink(errorPath)].map((promise) => promise.catch(() => undefined)));
-  return text;
-};
-
-const runScriptedEngine = async (config, prompt, paths) => {
-  if (typeof config?.engine_command !== "string" || config.engine_command.length === 0) {
-    throw new Error("Scripted Pi engine is missing its staged engine_command path");
-  }
-  const scriptPath = path.join(paths.workspacePath, config.engine_command);
-  await mkdir(paths.runtimeHomePath, { recursive: true });
-  const promptPath = path.join(paths.runtimeHomePath, "scripted-prompt-" + Date.now() + ".txt");
-  await writeFile(promptPath, prompt);
-  const args = ["--prompt-file", promptPath, "--cwd", paths.workspacePath];
-  let output;
-  try {
-    output = await execFileAsync("node", [scriptPath, ...args], {
-      ...cliOutputOptions,
-      cwd: paths.workspacePath,
-      env: process.env
-    });
-  } finally {
-    await unlink(promptPath).catch(() => undefined);
-  }
-  appendFileSync(
-    path.join(paths.runtimeHomePath, "scripted-engine-calls.jsonl"),
-    JSON.stringify({
-      args,
-      script: scriptPath,
-      timestamp: new Date().toISOString()
-    }) + "\n"
-  );
-  return output.stdout.trim();
-};
-
-const runCliEngine = async (engine, prompt, paths, config) => {
-  const startedAt = Date.now();
-  let text;
-  if (engine === "codex") {
-    text = await runCodexEngine(prompt, paths);
-  } else if (engine === "claude") {
-    text = await runClaudeEngine(prompt, paths);
-  } else if (engine === "grok") {
-    text = await runGrokEngine(prompt, paths);
-  } else if (engine === "scripted") {
-    text = await runScriptedEngine(config, prompt, paths);
-  } else {
-    text = await runAgyEngine(prompt, paths);
-  }
-  return {
-    durationMs: Date.now() - startedAt,
-    text
-  };
-};
-`;

package/dist/runtime/pi/appCliSource.d.ts

@@ -1 +0,0 @@
-export declare const renderPiCliSource: () => string;