fission-worker 0.2.1 → 0.3.0

package/runner/modules/pipeline/pipeline-helpers.service.js

@@ -0,0 +1,318 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var PipelineHelpersService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineHelpersService = exports.COMMAND_TIMEOUT_MS = void 0;
+const common_1 = require("@nestjs/common");
+const child_process_1 = require("child_process");
+const promises_1 = require("fs/promises");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const common_2 = require("@nestjs/common");
+/** 20 minutes in milliseconds — hard ceiling for any single claude -p invocation. */
+exports.COMMAND_TIMEOUT_MS = 20 * 60 * 1000;
+let PipelineHelpersService = PipelineHelpersService_1 = class PipelineHelpersService {
+    data;
+    logger = new common_1.Logger(PipelineHelpersService_1.name);
+    /** Track what each worker slot is doing (slot index → task title). */
+    workerTasks = new Map();
+    /** Track slot 3 (shared by Tech Lead / CTO). */
+    slot3Info = null;
+    constructor(data) {
+        this.data = data;
+    }
+    /** Emit current agent slot state to all SSE listeners for a project. */
+    emitAgentState(projectId) {
+        this.data.emit(projectId, "work_state", {
+            plannedTasks: 0,
+            backlogFindings: 0,
+            userDirections: 0,
+            iteration: 0,
+            activeWorkers: this.workerTasks.size,
+            techLeadActive: this.slot3Info?.role === "Tech Lead",
+            ctoActive: this.slot3Info?.role === "CTO",
+            agents: {
+                worker1: this.workerTasks.has(0) ? { taskTitle: this.workerTasks.get(0), status: "building" } : null,
+                worker2: this.workerTasks.has(1) ? { taskTitle: this.workerTasks.get(1), status: "building" } : null,
+                slot3: this.slot3Info ? { role: this.slot3Info.role, taskTitle: this.slot3Info.task, status: "working" } : null,
+            },
+        });
+    }
+    // ------------------------------------------------------------------ //
+    //  Claude spawn                                                       //
+    // ------------------------------------------------------------------ //
+    spawnClaude(prompt, cwd, model, timeoutMs, streamContext, options) {
+        return new Promise((resolve, reject) => {
+            const args = ["-p", prompt, "--verbose"];
+            if (model)
+                args.push("--model", model);
+            if (options?.resumeSessionId)
+                args.push("--resume", options.resumeSessionId);
+            if (options?.jsonOutput)
+                args.push("--output-format", "json");
+            const child = (0, child_process_1.spawn)("claude", args, { cwd, env: { ...process.env }, stdio: ["ignore", "pipe", "pipe"] });
+            let stdout = "";
+            let stderr = "";
+            // stdout = final answer (captured for JSON parsing, NOT streamed to SSE)
+            child.stdout?.on("data", (chunk) => {
+                stdout += chunk.toString();
+            });
+            // stderr = real-time activity (tool calls, file reads, thinking) — stream to SSE
+            child.stderr?.on("data", (chunk) => {
+                stderr += chunk.toString();
+                if (streamContext) {
+                    this.data.emit(streamContext.projectId, "claude_output", {
+                        text: chunk.toString(),
+                        phase: streamContext.phase,
+                    });
+                }
+            });
+            const timeout = timeoutMs ?? exports.COMMAND_TIMEOUT_MS;
+            const timer = setTimeout(() => {
+                child.kill("SIGTERM");
+                reject(new Error(`claude -p timed out after ${timeout / 1000}s`));
+            }, timeout);
+            child.on("close", (code) => {
+                clearTimeout(timer);
+                // Extract session_id and result from JSON output format
+                let sessionId;
+                if (options?.jsonOutput) {
+                    try {
+                        const json = JSON.parse(stdout.trim());
+                        sessionId = json.session_id;
+                        // Replace stdout with just the result text for downstream parsing
+                        stdout = json.result ?? stdout;
+                    }
+                    catch {
+                        // JSON parse failed — leave stdout as-is
+                    }
+                }
+                resolve({ stdout, stderr, exitCode: code ?? 1, sessionId });
+            });
+            child.on("error", (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+        });
+    }
+    // ------------------------------------------------------------------ //
+    //  JSON parsing                                                       //
+    // ------------------------------------------------------------------ //
+    /**
+     * Attempt to parse Claude's stdout as JSON.
+     * Without --output-format json, Claude returns plain text. The response
+     * might be pure JSON, JSON with surrounding prose, or just text.
+     */
+    parseClaudeJson(output) {
+        const trimmed = output.trim();
+        if (!trimmed) {
+            this.logger.warn("Empty Claude output — nothing to parse");
+            return null;
+        }
+        // First try: the entire output is valid JSON
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            // ignore
+        }
+        // Second try: extract the first JSON array or object from the text.
+        const arrayStart = trimmed.indexOf("[");
+        const objectStart = trimmed.indexOf("{");
+        const starts = [];
+        if (arrayStart !== -1)
+            starts.push(arrayStart);
+        if (objectStart !== -1)
+            starts.push(objectStart);
+        for (const start of starts.sort((a, b) => a - b)) {
+            const closing = start === arrayStart ? "]" : "}";
+            const lastClose = trimmed.lastIndexOf(closing);
+            if (lastClose > start) {
+                try {
+                    return JSON.parse(trimmed.slice(start, lastClose + 1));
+                }
+                catch {
+                    // ignore — try next candidate
+                }
+            }
+        }
+        this.logger.warn("Failed to parse Claude output as JSON");
+        return null;
+    }
+    // ------------------------------------------------------------------ //
+    //  Git helpers                                                        //
+    // ------------------------------------------------------------------ //
+    /** Validate that a string is a 40-character lowercase hex SHA. */
+    isValidSha(sha) {
+        return /^[0-9a-f]{40}$/.test(sha);
+    }
+    /**
+     * Validate that a repo path exists and is within an allowed directory prefix.
+     * Prevents path traversal and arbitrary directory access in shell commands.
+     */
+    validateRepoPath(repoPath) {
+        if (!repoPath) {
+            throw new Error("Repository path is required");
+        }
+        // Block path traversal
+        if (repoPath.includes("..")) {
+            throw new Error("Path traversal is not allowed in repo path");
+        }
+        const normalized = (0, path_1.normalize)((0, path_1.resolve)(repoPath));
+        // Must actually exist on disk
+        if (!(0, fs_1.existsSync)(normalized)) {
+            throw new Error(`Repository path does not exist: ${normalized}`);
+        }
+    }
+    /** Get the current git HEAD SHA for a directory. */
+    gitRevParse(cwd) {
+        this.validateRepoPath(cwd);
+        return (0, child_process_1.execSync)("git rev-parse HEAD", { cwd, encoding: "utf-8" }).trim();
+    }
+    /** Get the full diff between two commits. */
+    gitDiff(cwd, oldHead, newHead) {
+        if (!this.isValidSha(oldHead) || !this.isValidSha(newHead)) {
+            this.logger.warn(`Invalid SHA detected, skipping diff`);
+            return "";
+        }
+        this.validateRepoPath(cwd);
+        try {
+            return (0, child_process_1.execSync)(`git diff ${oldHead}..${newHead}`, {
+                cwd,
+                encoding: "utf-8",
+                maxBuffer: 5 * 1024 * 1024,
+            });
+        }
+        catch {
+            return "";
+        }
+    }
+    /** Get the diff stat summary between two commits. */
+    gitDiffStat(cwd, oldHead, newHead) {
+        if (!this.isValidSha(oldHead) || !this.isValidSha(newHead)) {
+            this.logger.warn(`Invalid SHA detected, skipping diff stat`);
+            return "";
+        }
+        this.validateRepoPath(cwd);
+        try {
+            return (0, child_process_1.execSync)(`git diff ${oldHead}..${newHead} --stat`, {
+                cwd,
+                encoding: "utf-8",
+            });
+        }
+        catch {
+            return "";
+        }
+    }
+    // ------------------------------------------------------------------ //
+    //  Filesystem helpers                                                 //
+    // ------------------------------------------------------------------ //
+    /** Read a directory listing, returning [] if the directory does not exist. */
+    async safeReadDir(dir) {
+        try {
+            return await (0, promises_1.readdir)(dir);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Parse YAML-style frontmatter from a markdown file.
+     * Handles the block between leading `---` fences.
+     */
+    parseFrontmatter(content) {
+        const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+        if (!match)
+            return {};
+        const result = {};
+        for (const line of match[1].split(/\r?\n/)) {
+            const idx = line.indexOf(":");
+            if (idx === -1)
+                continue;
+            const key = line.slice(0, idx).trim();
+            const value = line.slice(idx + 1).trim();
+            if (key)
+                result[key] = value;
+        }
+        return result;
+    }
+    /** Return the markdown body (everything after the frontmatter block). */
+    extractBody(content) {
+        const stripped = content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
+        return stripped.trim();
+    }
+    // ------------------------------------------------------------------ //
+    //  Enum mappers (lenient — default to safe values)                    //
+    // ------------------------------------------------------------------ //
+    toFindingSeverity(raw) {
+        const upper = raw?.toUpperCase();
+        if (upper === "CRITICAL" || upper === "HIGH" || upper === "MEDIUM" || upper === "LOW") {
+            return upper;
+        }
+        return "MEDIUM";
+    }
+    toFindingCategory(raw) {
+        const upper = raw?.toUpperCase();
+        if (upper === "BUG" ||
+            upper === "SECURITY" ||
+            upper === "PERFORMANCE" ||
+            upper === "UX" ||
+            upper === "FEATURE" ||
+            upper === "MARKET") {
+            return upper;
+        }
+        return "FEATURE";
+    }
+    toFindingStatus(raw) {
+        const upper = raw?.toUpperCase();
+        if (upper === "NEW" ||
+            upper === "TRIAGED" ||
+            upper === "PLANNING" ||
+            upper === "TASKED" ||
+            upper === "DEFERRED" ||
+            upper === "DISMISSED") {
+            return upper;
+        }
+        return "NEW";
+    }
+    toTaskPriority(raw) {
+        const upper = raw?.toUpperCase();
+        if (upper === "CRITICAL" || upper === "HIGH" || upper === "MEDIUM" || upper === "LOW") {
+            return upper;
+        }
+        return "MEDIUM";
+    }
+    toTaskStatus(raw) {
+        const upper = raw?.toUpperCase();
+        if (upper === "PLANNED" ||
+            upper === "READY_TO_START" ||
+            upper === "IN_PROGRESS" ||
+            upper === "COMPLETED" ||
+            upper === "FAILED" ||
+            upper === "ARCHIVED") {
+            return upper;
+        }
+        // Map legacy PLANNING to READY_TO_START
+        if (upper === "PLANNING")
+            return "READY_TO_START";
+        return "PLANNED";
+    }
+};
+exports.PipelineHelpersService = PipelineHelpersService;
+exports.PipelineHelpersService = PipelineHelpersService = PipelineHelpersService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_2.Optional)()),
+    __param(0, (0, common_2.Inject)("PIPELINE_DATA")),
+    __metadata("design:paramtypes", [Object])
+], PipelineHelpersService);