@tea-agent/loop-agent 0.11.0 → 0.13.0-alpha.0

package/dist/worker/observe/spec-evidence.js

@@ -0,0 +1,281 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
+const DAG_RUN_LIFECYCLE_DIRS = ["active", "completed", "paused"];
+/**
+ * Known knowledge-base connector tool names.
+ */
+const KB_CONNECTOR_TOOLS = new Set([
+    "knowledge-base-query",
+    "kb_query",
+    "kb-search",
+    "knowledge_base_search",
+    "rag_search",
+    "vector_search",
+    "mcp__knowledge",
+    "mcp__kb",
+]);
+/**
+ * Pattern for detecting spec-related files:
+ * - openSpec/** files
+ * - *.spec.md / *.spec.ts / *.spec.tsx
+ * - project-specs/**
+ * - design-spec.md, code-standards.md, review-checklist.md, etc.
+ * - SKILL.md files
+ * - docs/** specification files
+ */
+const SPEC_FILE_PATTERNS = [
+    /openspec\//i,
+    /\/openSpec\//i,
+    /\/project-specs\//i,
+    /\/spec\//i,
+    /\.spec\.(md|tsx?|jsx?)$/i,
+    /\bdesign-spec\b/i,
+    /\bcode-standards\b/i,
+    /\breview-checklist\b/i,
+    /\bverification-checklist\b/i,
+    /\bnode-contracts\b/i,
+    /\breview-findings\b/i,
+    /\bSKILL\.md$/i,
+    /\bskills\//i,
+    /\bdocs\/design\//i,
+    /\bdocs\/templates\//i,
+];
+function isSpecFilePath(filePath) {
+    return SPEC_FILE_PATTERNS.some((pattern) => pattern.test(filePath));
+}
+function isKnowledgeBaseTool(toolName) {
+    return KB_CONNECTOR_TOOLS.has(toolName);
+}
+function resolveSessionEventsPath(repoRoot, dagRunId, nodeId) {
+    if (!isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId)) {
+        return null;
+    }
+    const dagRunsRoot = path.resolve(repoRoot, ".harness", "dag-runs");
+    const candidates = [];
+    for (const lifecycle of DAG_RUN_LIFECYCLE_DIRS) {
+        candidates.push(path.join(dagRunsRoot, lifecycle, dagRunId, nodeId, "session-events.jsonl"));
+    }
+    for (const candidate of candidates) {
+        const resolved = path.resolve(candidate);
+        if (!isPathInside(dagRunsRoot, resolved))
+            continue;
+        if (!isExpectedSessionEventsRelativePath(dagRunsRoot, resolved, dagRunId, nodeId)) {
+            continue;
+        }
+        if (existsSync(resolved))
+            return resolved;
+    }
+    return null;
+}
+function isExpectedSessionEventsRelativePath(dagRunsRoot, resolvedPath, dagRunId, nodeId) {
+    const relative = path.relative(dagRunsRoot, resolvedPath);
+    const parts = relative.split(path.sep).filter(Boolean);
+    return (parts.length === 4 &&
+        DAG_RUN_LIFECYCLE_DIRS.includes(parts[0]) &&
+        parts[1] === dagRunId &&
+        parts[2] === nodeId &&
+        parts[3] === "session-events.jsonl");
+}
+function isPathInside(root, target) {
+    const normalizedRoot = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
+    const normalizedTarget = path.normalize(target);
+    return normalizedTarget === root || normalizedTarget.startsWith(normalizedRoot);
+}
+function resolveToolName(event) {
+    return (event.toolName ?? "").toLowerCase();
+}
+function eventTimestamp(event) {
+    return event.timestamp ?? event.at;
+}
+/**
+ * Parse a tool input path to a repo-relative path.
+ * Handles both absolute paths and paths that are already repo-relative.
+ */
+function toRepoRelative(repoRoot, filePath) {
+    if (!filePath)
+        return null;
+    try {
+        const resolved = path.resolve(repoRoot, filePath);
+        const rel = path.relative(repoRoot, resolved);
+        if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) {
+            return null;
+        }
+        return rel.replaceAll(path.sep, "/");
+    }
+    catch {
+        return null;
+    }
+}
+async function readSessionEvents(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        return raw
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((event) => event !== null);
+    }
+    catch {
+        return [];
+    }
+}
+export async function extractSpecEvidence(repoRoot, dagRunId, nodeId) {
+    if (!isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId)) {
+        return null;
+    }
+    const eventsPath = resolveSessionEventsPath(repoRoot, dagRunId, nodeId);
+    if (!eventsPath) {
+        return null;
+    }
+    const events = await readSessionEvents(eventsPath);
+    // Track successful read calls with their paths (dedup by path)
+    const readPaths = new Map();
+    const searches = [];
+    const kbQueries = [];
+    // Track tool_execution_start events by toolCallId for pairing.
+    // Only tool_execution_end events with a matching start are counted as reads.
+    const startMap = new Map();
+    // Scan events for tool calls
+    for (const event of events) {
+        const type = event.type;
+        const toolName = resolveToolName(event);
+        const toolCallId = event.toolCallId;
+        const toolInput = event.toolInput ?? event.input ?? {};
+        const ts = eventTimestamp(event);
+        // Collect tool_execution_start events by toolCallId
+        if (type === "tool_execution_start" && toolCallId) {
+            startMap.set(toolCallId, { toolName, input: toolInput });
+            continue;
+        }
+        // Process tool_execution_end events
+        if (type === "tool_execution_end") {
+            // Successful read calls: must have matching start event and no error
+            if (toolName === "read") {
+                const isErrored = event.isError === true ||
+                    event.toolResult?.error != null ||
+                    event.toolResult?.ok === false;
+                if (isErrored)
+                    continue;
+                let filePath;
+                // Only paired read calls qualify: must have toolCallId, matching start
+                // with same toolName, and start must be a "read" tool.
+                if (toolCallId) {
+                    const start = startMap.get(toolCallId);
+                    if (start && start.toolName === "read") {
+                        const startInput = start.input ?? {};
+                        filePath = typeof startInput.path === "string" ? startInput.path : undefined;
+                        startMap.delete(toolCallId);
+                    }
+                    // No fallback: unmatched end, mismatched toolName, or missing start → skip
+                }
+                // No legacy path: toolCallId-less read ends never qualify as spec reads
+                if (filePath) {
+                    const relPath = toRepoRelative(repoRoot, filePath);
+                    if (relPath && isSpecFilePath(relPath) && !readPaths.has(relPath)) {
+                        readPaths.set(relPath, ts ?? "");
+                    }
+                }
+            }
+            // Search/scan tool calls (grep, find, ls, glob)
+            if (["grep", "find", "ls", "glob"].includes(toolName)) {
+                const query = typeof toolInput.pattern === "string"
+                    ? toolInput.pattern
+                    : typeof toolInput.query === "string"
+                        ? toolInput.query
+                        : typeof toolInput.path === "string"
+                            ? toolInput.path
+                            : toolName;
+                searches.push({
+                    tool: toolName,
+                    query,
+                    timestamp: ts,
+                });
+            }
+            // Knowledge base connector calls
+            if (isKnowledgeBaseTool(toolName)) {
+                kbQueries.push({
+                    connector: toolName,
+                    timestamp: ts,
+                });
+            }
+        }
+    }
+    // Determine status
+    let status;
+    const specReads = Array.from(readPaths.entries()).map(([p, t]) => ({
+        path: p,
+        timestamp: t || undefined,
+    }));
+    const hasInjection = true; // DAG nodes always have skills/resolved instructions injected
+    if (specReads.length > 0) {
+        status = "spec-read";
+    }
+    else if (kbQueries.length > 0) {
+        status = "kb-queried";
+    }
+    else if (searches.length > 0) {
+        status = "search-only";
+    }
+    else if (hasInjection) {
+        status = "spec-injected";
+    }
+    else {
+        status = "no-evidence";
+    }
+    // Build summary
+    const summaryLines = [];
+    if (status === "spec-read") {
+        summaryLines.push(`已读取 ${specReads.length} 个规范文件：${specReads.map((r) => r.path).join("、")}`);
+    }
+    if (searches.length > 0) {
+        summaryLines.push(`已执行 ${searches.length} 次检索操作。`);
+    }
+    if (kbQueries.length > 0) {
+        summaryLines.push(`已观察到 ${kbQueries.length} 次知识库查询。`);
+    }
+    if (status === "spec-injected") {
+        summaryLines.push("规范 skill 已注入但未观察到规范文件读取或知识库查询。");
+    }
+    if (status === "no-evidence") {
+        summaryLines.push("未观察到任何规范证据：无 skill 注入、无文件读取、无检索操作。");
+    }
+    return {
+        dagRunId,
+        nodeId,
+        status,
+        skillInjection: {
+            skills: [],
+            references: [],
+        },
+        specReads,
+        specSearches: searches,
+        knowledgeBaseQueries: kbQueries,
+        summary: summaryLines.join(" "),
+    };
+}
+export async function extractSpecEvidenceWithSkills(repoRoot, dagRunId, nodeId, skillInjection) {
+    const base = await extractSpecEvidence(repoRoot, dagRunId, nodeId);
+    if (!base)
+        return null;
+    base.skillInjection = skillInjection;
+    // Recompute status considering skill injection knowledge
+    if (base.status === "no-evidence" && skillInjection.skills.length > 0) {
+        base.status = "spec-injected";
+        base.summary = "规范 skill 已注入但未观察到规范文件读取或知识库查询。";
+    }
+    else if (base.status === "spec-injected" ||
+        (base.status === "no-evidence" && skillInjection.skills.length === 0)) {
+        base.summary = base.summary || "规范 skill 已注入但未观察到规范文件读取或知识库查询。";
+    }
+    return base;
+}

package/dist/worker/observe/static/api.js

@@ -0,0 +1,46 @@
+/** Fetch and artifact helpers (Observe UI R5). */
+
+export async function fetchJson(url) {
+	try {
+		const res = await fetch(url);
+		if (!res.ok) return null;
+		return await res.json();
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Read-only JSON fetch that preserves HTTP status so callers can distinguish
+ * 404 (missing) from 409 (ambiguous task identity). Body is parsed best-effort.
+ */
+export async function fetchJsonResult(url) {
+	try {
+		const res = await fetch(url);
+		let body = null;
+		try {
+			body = await res.json();
+		} catch {
+			body = null;
+		}
+		return { ok: res.ok, status: res.status, body };
+	} catch {
+		return { ok: false, status: 0, body: null };
+	}
+}
+
+export function artifactUrl(artifactPath) {
+	return `/api/artifacts?path=${encodeURIComponent(artifactPath)}&tail=200`;
+}
+
+export function parseArtifactPreviewResponse(text) {
+	const parsed = JSON.parse(text);
+	if (!parsed || typeof parsed.content !== "string") {
+		throw new Error("Artifact preview response is invalid");
+	}
+	return {
+		content: parsed.content,
+		truncated: parsed.truncated === true,
+	};
+}
+