godot-daedalus_backend 1.0.0

package/src/workflow/runner.ts

@@ -0,0 +1,141 @@
+import type { AiChatParams } from "../protocol/types.js";
+import type {
+	WorkflowPhase,
+	WorkflowPhaseOutput,
+	WorkflowPlan,
+	WorkflowTodoItem,
+	WorkflowTodoSnapshot,
+	WorkflowTodoStatus
+} from "./types.js";
+
+const MAX_PHASE_OUTPUT_CHARS: number = 5000;
+
+export function createWorkflowTodoSnapshot(plan: WorkflowPlan): WorkflowTodoSnapshot {
+	return {
+		workflowId: plan.id,
+		title: plan.title,
+		source: plan.source,
+		revision: plan.revision,
+		phases: plan.phases.map((phase: WorkflowPhase) => ({
+			id: phase.id,
+			title: phase.title,
+			status: getPhaseStatus(plan, phase.id)
+		})),
+		todos: plan.todos.map((todo: WorkflowTodoItem) => ({ ...todo }))
+	};
+}
+
+export function updateWorkflowPhaseStatus(plan: WorkflowPlan, phaseId: string, status: WorkflowTodoStatus): WorkflowPlan {
+	return {
+		...plan,
+		todos: plan.todos.map((todo: WorkflowTodoItem): WorkflowTodoItem => (
+			todo.phaseId === phaseId ? { ...todo, status } : todo
+		))
+	};
+}
+
+export function markRemainingWorkflowTodos(plan: WorkflowPlan, status: WorkflowTodoStatus): WorkflowPlan {
+	return {
+		...plan,
+		todos: plan.todos.map((todo: WorkflowTodoItem): WorkflowTodoItem => (
+			todo.status === "done" ? todo : { ...todo, status }
+		))
+	};
+}
+
+export function createPhaseMessage(
+	originalParams: AiChatParams,
+	plan: WorkflowPlan,
+	phase: WorkflowPhase,
+	phaseOutputs: WorkflowPhaseOutput[]
+): string {
+	const previousResults: string = phaseOutputs.length > 0
+		? phaseOutputs.map(formatPhaseOutput).join("\n\n")
+		: "（暂无上一阶段结果）";
+
+	return [
+		`当前执行工作流：${plan.title}`,
+		`当前阶段：${phase.title}（${phase.id}）`,
+		"",
+		"## 用户原始需求",
+		originalParams.message,
+		"",
+		"## 当前阶段指令",
+		phase.instruction,
+		"",
+		"## 上一阶段结果",
+		previousResults,
+		"",
+		"请只完成当前阶段。不要跳过后续阶段，不要输出最终交付总结，除非当前阶段是最后一步或阶段指令明确要求总结。"
+	].join("\n");
+}
+
+export function createPhaseParams(originalParams: AiChatParams, phase: WorkflowPhase, message: string, stream: boolean): AiChatParams {
+	return {
+		...originalParams,
+		message,
+		promptId: phase.promptId ?? originalParams.promptId,
+		skillId: phase.skillId,
+		options: {
+			...(originalParams.options ?? {}),
+			stream,
+			toolBudget: phase.toolBudget,
+			workflow: "single"
+		}
+	};
+}
+
+export function createPhasePrompt(phase: WorkflowPhase, skillPrompt: string, mcpSystemContext: string): string {
+	return [
+		"## 工作流阶段约束",
+		`- 当前阶段：${phase.title}（${phase.id}）`,
+		`- 阶段目标：${phase.instruction}`,
+		"- 只完成当前阶段，不要提前总结整个任务。",
+		"- 如果需要写入或执行审批工具，按现有审批流程暂停。",
+		"- 当前阶段实际可用工具：",
+		...phase.allowedTools.map((toolName: string): string => `  - ${toolName}`),
+		"",
+		skillPrompt,
+		mcpSystemContext
+	].filter((part: string): boolean => part.length > 0).join("\n\n");
+}
+
+export function appendPhaseOutput(outputs: WorkflowPhaseOutput[], phase: WorkflowPhase, text: string): WorkflowPhaseOutput[] {
+	const clippedText: string = text.length > MAX_PHASE_OUTPUT_CHARS
+		? `${text.slice(0, MAX_PHASE_OUTPUT_CHARS)}\n\n[阶段输出已截断，原始长度 ${text.length} 字符]`
+		: text;
+
+	return [
+		...outputs,
+		{
+			phaseId: phase.id,
+			title: phase.title,
+			text: clippedText
+		}
+	];
+}
+
+function formatPhaseOutput(output: WorkflowPhaseOutput): string {
+	return [
+		`### ${output.title}`,
+		output.text
+	].join("\n");
+}
+
+function getPhaseStatus(plan: WorkflowPlan, phaseId: string): WorkflowTodoStatus {
+	const phaseTodos: WorkflowTodoItem[] = plan.todos.filter((todo: WorkflowTodoItem): boolean => todo.phaseId === phaseId);
+	if (phaseTodos.some((todo: WorkflowTodoItem): boolean => todo.status === "failed")) {
+		return "failed";
+	}
+	if (phaseTodos.some((todo: WorkflowTodoItem): boolean => todo.status === "paused")) {
+		return "paused";
+	}
+	if (phaseTodos.some((todo: WorkflowTodoItem): boolean => todo.status === "running")) {
+		return "running";
+	}
+	if (phaseTodos.length > 0 && phaseTodos.every((todo: WorkflowTodoItem): boolean => todo.status === "done")) {
+		return "done";
+	}
+
+	return "pending";
+}

package/src/workflow/types.ts

@@ -0,0 +1,69 @@
+import type { AiChatParams, ChatMessage, PromptId } from "../protocol/types.js";
+import type { SkillId } from "../skills/registry.js";
+import type { ToolBudgetLevel } from "../tools/llm-tools.js";
+
+export type WorkflowPhaseId = string;
+
+export type WorkflowTodoStatus = "pending" | "running" | "done" | "failed" | "paused";
+
+export type WorkflowSource = "fixed" | "llm";
+
+export type WorkflowToolGroup = "read" | "write" | "verify" | "summarize";
+
+export type WorkflowPhase = {
+	id: WorkflowPhaseId;
+	title: string;
+	toolGroup?: WorkflowToolGroup | undefined;
+	skillId?: SkillId | undefined;
+	promptId?: PromptId | undefined;
+	toolBudget: ToolBudgetLevel;
+	allowedTools: string[];
+	instruction: string;
+};
+
+export type WorkflowTodoItem = {
+	id: string;
+	phaseId: WorkflowPhaseId;
+	text: string;
+	status: WorkflowTodoStatus;
+};
+
+export type WorkflowPlan = {
+	id: string;
+	title: string;
+	phases: WorkflowPhase[];
+	todos: WorkflowTodoItem[];
+	source?: WorkflowSource | undefined;
+	revision?: number | undefined;
+	maxRevisions?: number | undefined;
+};
+
+export type WorkflowPhaseOutput = {
+	phaseId: WorkflowPhaseId;
+	title: string;
+	text: string;
+};
+
+export type WorkflowRunState = {
+	plan: WorkflowPlan;
+	phaseIndex: number;
+	phaseOutputs: WorkflowPhaseOutput[];
+	originalParams: AiChatParams;
+	history: ChatMessage[];
+	historyBudgetTokens: number;
+	planningContext?: string | undefined;
+	guidePromptSection?: string | undefined;
+};
+
+export type WorkflowTodoSnapshot = {
+	workflowId: string;
+	title: string;
+	source?: WorkflowSource | undefined;
+	revision?: number | undefined;
+	phases: Array<{
+		id: WorkflowPhaseId;
+		title: string;
+		status: WorkflowTodoStatus;
+	}>;
+	todos: WorkflowTodoItem[];
+};

package/src/workspace/registry.ts

@@ -0,0 +1,104 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { getDefaultWorkspaceConfigPath } from "../app-paths.js";
+import type { WorkspaceConfig } from "./types.js";
+
+let configuredWorkspaceCache: WorkspaceConfig[] | null = null;
+const runtimeWorkspaces: Map<string, WorkspaceConfig> = new Map();
+
+function loadConfiguredWorkspaces(): WorkspaceConfig[] {
+	if (configuredWorkspaceCache) {
+		return configuredWorkspaceCache;
+	}
+
+	const path: string = getDefaultWorkspaceConfigPath();
+
+	if (!existsSync(path)) {
+		console.warn(`[workspace] Config file not found: ${path}`);
+		configuredWorkspaceCache = [];
+		return configuredWorkspaceCache;
+	}
+
+	const raw: string = readFileSync(path, "utf8");
+	const parsed: unknown = JSON.parse(raw) as unknown;
+
+	if (!Array.isArray(parsed)) {
+		throw new Error(`Workspace config must be a JSON array: ${path}`);
+	}
+
+	configuredWorkspaceCache = parsed as WorkspaceConfig[];
+	return configuredWorkspaceCache;
+}
+
+export function createRuntimeWorkspace(rootPath: string, godotExecutablePath?: string | undefined): WorkspaceConfig {
+	const normalizedRootPath: string = resolve(rootPath);
+	const hash: string = createHash("sha1").update(normalizedRootPath.toLowerCase()).digest("hex").slice(0, 10);
+	const name: string = basename(normalizedRootPath) || normalizedRootPath;
+
+	return {
+		id: `runtime-${hash}`,
+		name,
+		kind: "godot",
+		rootPath: normalizedRootPath,
+		godotExecutablePath
+	};
+}
+
+export function upsertRuntimeWorkspace(workspace: WorkspaceConfig): WorkspaceConfig {
+	const existing: WorkspaceConfig | undefined = runtimeWorkspaces.get(workspace.id);
+	const next: WorkspaceConfig = {
+		...existing,
+		...workspace,
+		godotExecutablePath: workspace.godotExecutablePath ?? existing?.godotExecutablePath
+	};
+	runtimeWorkspaces.set(next.id, next);
+	return next;
+}
+
+function getEnvironmentWorkspace(): WorkspaceConfig | undefined {
+	if (!process.env.GODOT_PROJECT_PATH) {
+		return undefined;
+	}
+
+	return createRuntimeWorkspace(process.env.GODOT_PROJECT_PATH, process.env.GODOT_EXECUTABLE_PATH);
+}
+
+export function loadWorkspaces(): WorkspaceConfig[] {
+	const byId: Map<string, WorkspaceConfig> = new Map();
+
+	for (const workspace of loadConfiguredWorkspaces()) {
+		byId.set(workspace.id, workspace);
+	}
+
+	const environmentWorkspace: WorkspaceConfig | undefined = getEnvironmentWorkspace();
+	if (environmentWorkspace && !byId.has(environmentWorkspace.id)) {
+		byId.set(environmentWorkspace.id, environmentWorkspace);
+	}
+
+	for (const workspace of runtimeWorkspaces.values()) {
+		if (!byId.has(workspace.id)) {
+			byId.set(workspace.id, workspace);
+		}
+	}
+
+	return Array.from(byId.values());
+}
+
+export function findWorkspace(workspaceId: string): WorkspaceConfig | undefined {
+	return loadWorkspaces().find((w: WorkspaceConfig): boolean => w.id === workspaceId);
+}
+
+export function getDefaultWorkspace(): WorkspaceConfig | undefined {
+	const workspaces: WorkspaceConfig[] = loadWorkspaces();
+	const defaultId: string | undefined = process.env.DEFAULT_WORKSPACE;
+
+	if (defaultId) {
+		const found: WorkspaceConfig | undefined = workspaces.find((w: WorkspaceConfig): boolean => w.id === defaultId);
+		if (found) {
+			return found;
+		}
+	}
+
+	return workspaces[0];
+}

package/src/workspace/types.ts

@@ -0,0 +1,7 @@
+export type WorkspaceConfig = {
+	id: string;
+	name: string;
+	kind: "godot";
+	rootPath: string;
+	godotExecutablePath?: string | undefined;
+};