@xopcai/xopc 0.0.121 → 0.0.123

package/dist/src/gateway/hono/routes/projects.js

@@ -0,0 +1,662 @@
+import { getSqliteDatabase } from "../../../storage/sqlite/transaction.js";
+import { GoalService } from "../../../goals/goal-service.js";
+import "../../../goals/index.js";
+import { getSessionMetadata } from "../../../storage/sqlite/session-repository.js";
+import { loadTranscriptRowsForSession } from "../../../storage/sqlite/transcript-repository.js";
+import { listMemoryRecords, upsertMemoryRecord } from "../../../storage/sqlite/memory-records-repository.js";
+import "../../../storage/sqlite/index.js";
+import { ProjectWorkspaceConflictError, ProjectWorkspaceMissingError } from "../../../projects/workspace-project.js";
+import { isValidProjectAgentId, normalizeProjectAgentId, resolveProjectAgentId } from "../../../projects/project-agent.js";
+import { buildProjectLoopOverview } from "../../../projects/project-loop.js";
+import "../../../projects/index.js";
+import { createGatewayRouteLogger } from "../lib/route-logger.js";
+import * as path$1 from "node:path";
+import { readdir, realpath, stat } from "node:fs/promises";
+//#region src/gateway/hono/routes/projects.ts
+const log = createGatewayRouteLogger("Projects");
+function parseProjectStatus(raw) {
+	return raw === "active" || raw === "paused" || raw === "archived" ? raw : void 0;
+}
+function parseLimit(raw, fallback = 50) {
+	if (!raw) return void 0;
+	const n = Number.parseInt(raw, 10);
+	return Number.isFinite(n) ? Math.min(500, Math.max(1, n)) : fallback;
+}
+function textField(body, key) {
+	const value = body[key];
+	return typeof value === "string" ? value : void 0;
+}
+function optionalTextField(body, key) {
+	if (!(key in body)) return void 0;
+	const value = body[key];
+	return typeof value === "string" ? value : null;
+}
+const SKIP_FILE_NAMES = new Set([".git", "node_modules"]);
+function normalizeRelativePath(raw) {
+	return (raw ?? "").trim().replaceAll("\\", "/").replace(/^\/+/, "");
+}
+function isWithinDirectory(root, target) {
+	const relativePath = path$1.relative(root, target);
+	return relativePath === "" || !relativePath.startsWith("..") && !path$1.isAbsolute(relativePath);
+}
+function textFromTranscriptContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.map((part) => {
+		if (!part || typeof part !== "object") return "";
+		const record = part;
+		return typeof record.text === "string" ? record.text : "";
+	}).filter(Boolean).join("\n");
+}
+function buildSessionSummaryMemoryContent(sessionKey, explicitSummary) {
+	const summary = explicitSummary?.trim();
+	if (summary) return summary;
+	const lines = loadTranscriptRowsForSession(sessionKey).filter((row) => {
+		if (!row || typeof row !== "object") return false;
+		const role = row.role;
+		return role === "user" || role === "assistant" || role === "compactionSummary" || role === "branchSummary";
+	}).slice(-12).map((row) => {
+		const record = row;
+		const rowRole = typeof record.role === "string" ? record.role : "message";
+		const role = rowRole === "compactionSummary" || rowRole === "branchSummary" ? "summary" : rowRole;
+		const compact = ((typeof record.summary === "string" ? record.summary : void 0) ?? textFromTranscriptContent(record.content)).trim().replace(/\s+/g, " ").slice(0, 280);
+		return compact ? `- ${role}: ${compact}` : "";
+	}).filter(Boolean);
+	return lines.length > 0 ? [`Session summary for ${sessionKey}:`, ...lines].join("\n") : `Session summary for ${sessionKey}: no transcript content available.`;
+}
+function listFailedProjectWorkflowRuns(projectId, limit = 5) {
+	return getSqliteDatabase().prepare(`SELECT run_id, definition_id, status, created_at_ms, error_message
+       FROM workflow_runs
+       WHERE project_id = ? AND status IN ('failed', 'timeout', 'cancelled')
+       ORDER BY created_at_ms DESC
+       LIMIT ?`).all(projectId, Math.max(1, Math.min(20, Math.floor(limit)))).map((row) => ({
+		runId: row.run_id,
+		definitionId: row.definition_id,
+		status: row.status,
+		createdAt: row.created_at_ms,
+		errorMessage: row.error_message ?? void 0
+	}));
+}
+function buildProjectDigestMemoryContent(input) {
+	const lines = [
+		`Project digest: ${input.projectName}`,
+		`Status: ${input.digest.summary}`,
+		input.digest.nextAction ? `Next: ${input.digest.nextAction}` : void 0
+	].filter(Boolean);
+	if (input.attentionItems.length > 0) {
+		lines.push("", "Attention:");
+		for (const item of input.attentionItems.slice(0, 8)) lines.push(`- ${item.kind}: ${item.title}${item.detail ? ` - ${item.detail}` : ""}`);
+	}
+	if (input.timeline.length > 0) {
+		lines.push("", "Recent activity:");
+		for (const item of input.timeline.slice(0, 8)) lines.push(`- ${item.kind}: ${item.title}${item.detail ? ` - ${item.detail}` : ""}`);
+	}
+	return lines.join("\n");
+}
+function projectDigestMemoryRecordId(projectId) {
+	return `project-digest:${projectId}`;
+}
+function registerProjectsRoutes(authenticated, deps) {
+	const { service } = deps;
+	const goals = new GoalService();
+	authenticated.post("/api/projects", async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const name = textField(body, "name")?.trim();
+		const workspaceRoot = textField(body, "workspaceRoot")?.trim();
+		if (!name && !workspaceRoot) return c.json({
+			ok: false,
+			error: "Missing name"
+		}, 400);
+		const defaultAgentId = normalizeProjectAgentId(textField(body, "defaultAgentId"));
+		if (!isValidProjectAgentId(service.currentConfig, defaultAgentId)) return c.json({
+			ok: false,
+			error: "Default agent not found"
+		}, 400);
+		try {
+			const project = service.projects.create({
+				name,
+				description: textField(body, "description"),
+				defaultAgentId,
+				workspaceRoot,
+				createWorkspaceRoot: body.createWorkspaceRoot === true,
+				brief: textField(body, "brief"),
+				instructions: textField(body, "instructions")
+			});
+			return c.json({
+				ok: true,
+				project
+			}, 201);
+		} catch (error) {
+			if (error instanceof ProjectWorkspaceConflictError) return c.json({
+				ok: false,
+				code: "workspace_already_bound",
+				error: error.message,
+				project: error.project
+			}, 409);
+			if (error instanceof ProjectWorkspaceMissingError) return c.json({
+				ok: false,
+				code: "workspace_root_missing",
+				error: error.message,
+				workspaceRoot: error.workspaceRoot
+			}, 409);
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	authenticated.get("/api/projects", async (c) => {
+		const status = parseProjectStatus(c.req.query("status"));
+		const result = service.projects.list({
+			...status ? { status } : {},
+			search: c.req.query("search"),
+			sortBy: c.req.query("sortBy"),
+			sortOrder: c.req.query("sortOrder"),
+			limit: parseLimit(c.req.query("limit")),
+			offset: c.req.query("offset") ? Math.max(0, Number.parseInt(c.req.query("offset"), 10) || 0) : void 0
+		});
+		return c.json({
+			ok: true,
+			...result
+		});
+	});
+	authenticated.get("/api/projects/suggestions", async (c) => {
+		const sessionKey = c.req.query("sessionKey")?.trim();
+		return c.json({
+			ok: true,
+			suggestions: sessionKey ? service.projects.suggestProjectsForSession(sessionKey) : []
+		});
+	});
+	authenticated.post("/api/projects/resolve-workspace", async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const workspacePath = textField(body, "workspacePath")?.trim();
+		if (!workspacePath) return c.json({
+			ok: false,
+			error: "Missing workspacePath"
+		}, 400);
+		const agentId = textField(body, "agentId")?.trim() || "main";
+		let match;
+		try {
+			match = service.projects.resolveOrCreateForWorkspacePath({
+				workspacePath,
+				agentId,
+				autoCreate: body.autoCreate !== false
+			});
+		} catch (error) {
+			if (error instanceof ProjectWorkspaceConflictError) match = {
+				project: error.project,
+				reason: "exact",
+				created: false
+			};
+			else throw error;
+		}
+		if (!match) return c.json({
+			ok: true,
+			project: null
+		});
+		const sessionKey = textField(body, "sessionKey")?.trim();
+		if (sessionKey) {
+			if (!getSessionMetadata(sessionKey)) await service.sessionIndexInstance.saveMessages(sessionKey, [], { metadata: {
+				sourceChannel: "tui",
+				sourceChatId: `default:direct:${sessionKey}`,
+				sessionType: "chat",
+				projectId: match.project.id,
+				routing: {
+					agentId,
+					source: "tui",
+					accountId: "default",
+					peerKind: "direct",
+					peerId: sessionKey
+				}
+			} });
+			service.projects.attachSession(sessionKey, match.project.id);
+		}
+		return c.json({
+			ok: true,
+			...match
+		});
+	});
+	authenticated.get("/api/projects/:id/overview", async (c) => {
+		const project = service.projects.getWithDetails(c.req.param("id"));
+		if (!project) return c.json({
+			ok: false,
+			error: "Project not found"
+		}, 404);
+		const loop = buildProjectLoopOverview({
+			project,
+			goals: service.projects.listGoalIds(project.id, parseLimit(c.req.query("goalLimit"), 100)).map((id) => goals.get(id)).filter((goal) => Boolean(goal)),
+			recentWorkflowRuns: project.recentWorkflowRuns,
+			failedWorkflowRuns: listFailedProjectWorkflowRuns(project.id),
+			memoryRecords: listMemoryRecords({
+				projectId: project.id,
+				status: "active",
+				limit: 5
+			})
+		});
+		return c.json({
+			ok: true,
+			overview: {
+				project,
+				stats: {
+					sessionCount: project.sessionCount,
+					goalCount: project.goalCount,
+					activeGoalCount: project.activeGoalCount,
+					recentWorkflowRunCount: project.recentWorkflowRuns.length,
+					staleGoalCount: loop.staleGoals.length,
+					attentionCount: loop.attentionItems.length,
+					failedWorkflowRunCount: loop.failedWorkflowRuns.length
+				},
+				activeGoals: loop.activeGoals,
+				blockedGoals: loop.blockedGoals,
+				staleGoals: loop.staleGoals,
+				nextActions: loop.nextActions,
+				attentionItems: loop.attentionItems,
+				timeline: loop.timeline,
+				digest: loop.digest,
+				failedWorkflowRuns: loop.failedWorkflowRuns,
+				recentSessions: project.recentSessions,
+				recentWorkflowRuns: project.recentWorkflowRuns,
+				recommendedAction: loop.recommendedAction
+			}
+		});
+	});
+	authenticated.post("/api/projects/:id/digest-memory", async (c) => {
+		const project = service.projects.getWithDetails(c.req.param("id"));
+		if (!project) return c.json({
+			ok: false,
+			error: "Project not found"
+		}, 404);
+		const loop = buildProjectLoopOverview({
+			project,
+			goals: service.projects.listGoalIds(project.id, 100).map((id) => goals.get(id)).filter((goal) => Boolean(goal)),
+			recentWorkflowRuns: project.recentWorkflowRuns,
+			failedWorkflowRuns: listFailedProjectWorkflowRuns(project.id),
+			memoryRecords: listMemoryRecords({
+				projectId: project.id,
+				status: "active",
+				limit: 5
+			})
+		});
+		const record = upsertMemoryRecord({
+			id: projectDigestMemoryRecordId(project.id),
+			providerId: "local",
+			kind: "daily_note",
+			agentId: resolveProjectAgentId({
+				config: service.currentConfig,
+				projects: service.projects,
+				projectId: project.id
+			}),
+			workspaceId: project.workspaceRoot,
+			projectId: project.id,
+			content: buildProjectDigestMemoryContent({
+				...loop,
+				projectName: project.name
+			}),
+			source: { provider: "project-digest" },
+			confidence: .75,
+			tags: [
+				"project",
+				"project-digest",
+				project.slug
+			],
+			status: "active",
+			sensitivity: "normal"
+		});
+		return c.json({
+			ok: true,
+			record
+		}, 201);
+	});
+	authenticated.post("/api/projects/:id/blockers", async (c) => {
+		const project = service.projects.getWithDetails(c.req.param("id"));
+		if (!project) return c.json({
+			ok: false,
+			error: "Project not found"
+		}, 404);
+		const body = await c.req.json().catch(() => ({}));
+		const title = typeof body.title === "string" ? body.title.trim() : "";
+		if (!title) return c.json({
+			ok: false,
+			error: "Missing title"
+		}, 400);
+		const reason = typeof body.reason === "string" ? body.reason.trim() : "";
+		const goal = goals.create({
+			title,
+			description: reason || void 0,
+			agentId: resolveProjectAgentId({
+				config: service.currentConfig,
+				projects: service.projects,
+				projectId: project.id
+			}),
+			priority: body.priority === "low" || body.priority === "normal" || body.priority === "high" ? body.priority : "high",
+			source: "api",
+			projectId: project.id
+		});
+		const blocked = goals.setStatus(goal.id, "blocked", { reason: reason || title });
+		if (reason) goals.setContextMessage({
+			goalId: goal.id,
+			text: reason
+		});
+		return c.json({
+			ok: true,
+			goal: blocked ?? goals.get(goal.id)
+		}, 201);
+	});
+	authenticated.get("/api/projects/:id", async (c) => {
+		const project = service.projects.getWithDetails(c.req.param("id"));
+		if (!project) return c.json({
+			ok: false,
+			error: "Project not found"
+		}, 404);
+		return c.json({
+			ok: true,
+			project
+		});
+	});
+	authenticated.patch("/api/projects/:id", async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const status = parseProjectStatus(body.status);
+		const defaultAgentPatch = optionalTextField(body, "defaultAgentId");
+		const defaultAgentId = defaultAgentPatch === void 0 ? void 0 : normalizeProjectAgentId(defaultAgentPatch);
+		if (defaultAgentId && !isValidProjectAgentId(service.currentConfig, defaultAgentId)) return c.json({
+			ok: false,
+			error: "Default agent not found"
+		}, 400);
+		try {
+			const project = service.projects.update(c.req.param("id"), {
+				...textField(body, "name") !== void 0 ? { name: textField(body, "name") } : {},
+				...optionalTextField(body, "description") !== void 0 ? { description: optionalTextField(body, "description") } : {},
+				...status ? { status } : {},
+				...defaultAgentPatch !== void 0 ? { defaultAgentId: defaultAgentId ?? null } : {},
+				...optionalTextField(body, "workspaceRoot") !== void 0 ? { workspaceRoot: optionalTextField(body, "workspaceRoot") } : {},
+				createWorkspaceRoot: body.createWorkspaceRoot === true,
+				...optionalTextField(body, "brief") !== void 0 ? { brief: optionalTextField(body, "brief") } : {},
+				...optionalTextField(body, "instructions") !== void 0 ? { instructions: optionalTextField(body, "instructions") } : {}
+			});
+			return c.json({
+				ok: true,
+				project
+			});
+		} catch (error) {
+			if (error instanceof ProjectWorkspaceConflictError) return c.json({
+				ok: false,
+				code: "workspace_already_bound",
+				error: error.message,
+				project: error.project
+			}, 409);
+			if (error instanceof ProjectWorkspaceMissingError) return c.json({
+				ok: false,
+				code: "workspace_root_missing",
+				error: error.message,
+				workspaceRoot: error.workspaceRoot
+			}, 409);
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 404);
+		}
+	});
+	authenticated.delete("/api/projects/:id", async (c) => {
+		service.projects.delete(c.req.param("id"));
+		return c.json({ ok: true });
+	});
+	authenticated.get("/api/projects/:id/sessions", async (c) => {
+		try {
+			const keys = service.projects.listSessionKeys(c.req.param("id"), parseLimit(c.req.query("limit"), 100));
+			const sessions = await Promise.all(keys.map((key) => service.sessions.getSession(key)));
+			return c.json({
+				ok: true,
+				sessions: sessions.filter(Boolean)
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 404);
+		}
+	});
+	authenticated.get("/api/projects/:id/goals", async (c) => {
+		try {
+			const ids = service.projects.listGoalIds(c.req.param("id"), parseLimit(c.req.query("limit"), 100));
+			return c.json({
+				ok: true,
+				goals: ids.map((id) => goals.get(id)).filter(Boolean)
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 404);
+		}
+	});
+	authenticated.get("/api/projects/:id/files", async (c) => {
+		const project = service.projects.get(c.req.param("id"));
+		if (!project) return c.json({
+			ok: false,
+			error: "Project not found"
+		}, 404);
+		if (!project.workspaceRoot?.trim()) return c.json({
+			ok: false,
+			error: "Project workspace root is not set"
+		}, 400);
+		let root;
+		try {
+			root = await realpath(project.workspaceRoot);
+			if (!(await stat(root)).isDirectory()) return c.json({
+				ok: false,
+				error: "Project workspace root is not a directory"
+			}, 400);
+		} catch (err) {
+			log.warn({
+				err,
+				projectId: project.id,
+				path: project.workspaceRoot
+			}, "project workspace root unavailable");
+			return c.json({
+				ok: false,
+				error: "Project workspace root is unavailable"
+			}, 404);
+		}
+		const requestedPath = normalizeRelativePath(c.req.query("path"));
+		const candidate = path$1.resolve(root, requestedPath);
+		if (!isWithinDirectory(root, candidate)) return c.json({
+			ok: false,
+			error: "Path is outside project workspace"
+		}, 400);
+		let currentPath;
+		try {
+			currentPath = await realpath(candidate);
+			if (!isWithinDirectory(root, currentPath)) return c.json({
+				ok: false,
+				error: "Path is outside project workspace"
+			}, 400);
+			if (!(await stat(currentPath)).isDirectory()) return c.json({
+				ok: false,
+				error: "Path is not a directory"
+			}, 400);
+		} catch (err) {
+			log.warn({
+				err,
+				projectId: project.id,
+				path: candidate
+			}, "project file path unavailable");
+			return c.json({
+				ok: false,
+				error: "Path not found"
+			}, 404);
+		}
+		try {
+			const dirents = await readdir(currentPath, { withFileTypes: true });
+			const entries = await Promise.all(dirents.filter((entry) => !SKIP_FILE_NAMES.has(entry.name)).map(async (entry) => {
+				const absolutePath = path$1.join(currentPath, entry.name);
+				const entryStat = await stat(absolutePath).catch(() => null);
+				const relativePath = path$1.relative(root, absolutePath).split(path$1.sep).join("/");
+				return {
+					name: entry.name,
+					path: relativePath,
+					type: entry.isDirectory() ? "directory" : "file",
+					size: entryStat?.isFile() ? entryStat.size : void 0,
+					updatedAt: entryStat?.mtime.toISOString()
+				};
+			}));
+			entries.sort((left, right) => {
+				if (left.type !== right.type) return left.type === "directory" ? -1 : 1;
+				return left.name.localeCompare(right.name);
+			});
+			const relativeCurrentPath = path$1.relative(root, currentPath).split(path$1.sep).join("/");
+			const parentRelativePath = relativeCurrentPath ? path$1.dirname(relativeCurrentPath).replaceAll("\\", "/") : null;
+			return c.json({
+				ok: true,
+				root,
+				path: relativeCurrentPath === "." ? "" : relativeCurrentPath,
+				parentPath: parentRelativePath === "." ? "" : parentRelativePath,
+				entries
+			});
+		} catch (err) {
+			log.warn({
+				err,
+				projectId: project.id,
+				path: currentPath
+			}, "project file list failed");
+			if (err?.code === "EACCES") return c.json({
+				ok: false,
+				error: "Permission denied"
+			}, 403);
+			return c.json({
+				ok: false,
+				error: "Failed to read project files"
+			}, 500);
+		}
+	});
+	authenticated.post("/api/projects/:id/sessions/:sessionKey", async (c) => {
+		try {
+			service.projects.attachSession(c.req.param("sessionKey"), c.req.param("id"));
+			const session = await service.sessions.getSession(c.req.param("sessionKey"));
+			return c.json({
+				ok: true,
+				session
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 404);
+		}
+	});
+	authenticated.delete("/api/projects/:id/sessions/:sessionKey", async (c) => {
+		try {
+			const projectId = c.req.param("id");
+			const sessionKey = c.req.param("sessionKey");
+			if (!service.projects.get(projectId)) return c.json({
+				ok: false,
+				error: "Project not found"
+			}, 404);
+			const session = await service.sessions.getSession(sessionKey);
+			if (!session) return c.json({
+				ok: false,
+				error: "Session not found"
+			}, 404);
+			if (session.projectId !== projectId) return c.json({
+				ok: false,
+				error: "Session is not attached to this project"
+			}, 409);
+			service.projects.detachSession(sessionKey);
+			return c.json({ ok: true });
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 404);
+		}
+	});
+	authenticated.post("/api/projects/:id/sessions/:sessionKey/summary-memory", async (c) => {
+		const projectId = c.req.param("id");
+		const sessionKey = c.req.param("sessionKey");
+		const project = service.projects.get(projectId);
+		if (!project) return c.json({
+			ok: false,
+			error: "Project not found"
+		}, 404);
+		const session = getSessionMetadata(sessionKey);
+		if (!session) return c.json({
+			ok: false,
+			error: "Session not found"
+		}, 404);
+		if (session.projectId !== projectId) return c.json({
+			ok: false,
+			error: "Session is not attached to this project"
+		}, 409);
+		const body = await c.req.json().catch(() => ({}));
+		const content = buildSessionSummaryMemoryContent(sessionKey, typeof body.summary === "string" ? body.summary : void 0);
+		const record = upsertMemoryRecord({
+			providerId: "local",
+			kind: "session_summary",
+			agentId: session.routing?.agentId ?? "main",
+			workspaceId: session.cwd,
+			sessionKey,
+			projectId,
+			content,
+			source: {
+				provider: "project-summary",
+				sessionEntryId: sessionKey
+			},
+			confidence: typeof body.confidence === "number" ? body.confidence : .7,
+			tags: [
+				"project",
+				"session-summary",
+				project.slug
+			],
+			status: "active",
+			sensitivity: "normal",
+			evidence: [{ sessionKey }]
+		});
+		return c.json({
+			ok: true,
+			record
+		}, 201);
+	});
+	authenticated.post("/api/projects/:id/goals/:goalId", async (c) => {
+		try {
+			service.projects.attachGoal(c.req.param("goalId"), c.req.param("id"));
+			return c.json({
+				ok: true,
+				goal: goals.get(c.req.param("goalId"))
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 404);
+		}
+	});
+	authenticated.delete("/api/projects/:id/goals/:goalId", async (c) => {
+		try {
+			const projectId = c.req.param("id");
+			const goalId = c.req.param("goalId");
+			if (!service.projects.get(projectId)) return c.json({
+				ok: false,
+				error: "Project not found"
+			}, 404);
+			const goal = goals.get(goalId);
+			if (!goal) return c.json({
+				ok: false,
+				error: "Goal not found"
+			}, 404);
+			if (goal.projectId !== projectId) return c.json({
+				ok: false,
+				error: "Goal is not attached to this project"
+			}, 409);
+			service.projects.detachGoal(goalId);
+			return c.json({ ok: true });
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 404);
+		}
+	});
+}
+//#endregion
+export { registerProjectsRoutes };
+
+//# sourceMappingURL=projects.js.map