cortex-agents 2.3.1 → 4.0.0

package/dist/tools/quality-gate.js

@@ -0,0 +1,233 @@
+/**
+ * Quality Gate Summary Tool
+ *
+ * Aggregates sub-agent findings into a unified report with severity sorting,
+ * go/no-go recommendation, and PR body content.
+ */
+import { tool } from "@opencode-ai/plugin";
+import * as fs from "fs";
+import * as path from "path";
+const CORTEX_DIR = ".cortex";
+const QUALITY_GATE_FILE = "quality-gate.json";
+// ─── Severity ordering ───────────────────────────────────────────────────────
+const SEVERITY_ORDER = {
+    CRITICAL: 0,
+    HIGH: 1,
+    MEDIUM: 2,
+    LOW: 3,
+    INFO: 4,
+};
+// ─── quality_gate_summary ────────────────────────────────────────────────────
+export const qualityGateSummary = tool({
+    description: "Aggregate sub-agent quality gate findings into a unified report. " +
+        "Parses findings from @testing, @security, @audit, @perf, @devops, and @docs-writer, " +
+        "sorts by severity, provides a go/no-go recommendation, and generates PR body content. " +
+        "Pass each agent's raw report text as a separate entry.",
+    args: {
+        scope: tool.schema
+            .string()
+            .optional()
+            .describe("Change scope classification: trivial, low, standard, high"),
+        testing: tool.schema
+            .string()
+            .optional()
+            .describe("Raw report from @testing sub-agent"),
+        security: tool.schema
+            .string()
+            .optional()
+            .describe("Raw report from @security sub-agent"),
+        audit: tool.schema
+            .string()
+            .optional()
+            .describe("Raw report from @audit sub-agent"),
+        perf: tool.schema
+            .string()
+            .optional()
+            .describe("Raw report from @perf sub-agent"),
+        devops: tool.schema
+            .string()
+            .optional()
+            .describe("Raw report from @devops sub-agent"),
+        docsWriter: tool.schema
+            .string()
+            .optional()
+            .describe("Raw report from @docs-writer sub-agent"),
+    },
+    async execute(args, context) {
+        const cwd = context.worktree;
+        const reports = [];
+        // Parse each provided report
+        const agentEntries = [
+            ["testing", args.testing],
+            ["security", args.security],
+            ["audit", args.audit],
+            ["perf", args.perf],
+            ["devops", args.devops],
+            ["docs-writer", args.docsWriter],
+        ];
+        for (const [agent, raw] of agentEntries) {
+            if (!raw)
+                continue;
+            reports.push(parseReport(agent, raw));
+        }
+        if (reports.length === 0) {
+            return `\u2717 No sub-agent reports provided. Pass at least one agent report to aggregate.`;
+        }
+        // Collect all findings and sort by severity
+        const allFindings = reports.flatMap((r) => r.findings);
+        allFindings.sort((a, b) => (SEVERITY_ORDER[a.severity] ?? 99) - (SEVERITY_ORDER[b.severity] ?? 99));
+        // Determine recommendation
+        const hasCritical = allFindings.some((f) => f.severity === "CRITICAL");
+        const hasHigh = allFindings.some((f) => f.severity === "HIGH");
+        const hasMedium = allFindings.some((f) => f.severity === "MEDIUM");
+        let recommendation;
+        if (hasCritical || hasHigh) {
+            recommendation = "NO-GO";
+        }
+        else if (hasMedium) {
+            recommendation = "GO-WITH-WARNINGS";
+        }
+        else {
+            recommendation = "GO";
+        }
+        // Build state for persistence
+        const state = {
+            timestamp: new Date().toISOString(),
+            scope: args.scope ?? "unknown",
+            reports,
+            recommendation,
+        };
+        // Persist state
+        persistState(cwd, state);
+        // Format output
+        const lines = [];
+        lines.push(`\u2713 Quality Gate Summary`);
+        lines.push("");
+        lines.push(`**Recommendation: ${recommendation}**`);
+        lines.push(`Scope: ${args.scope ?? "unknown"}`);
+        lines.push(`Agents: ${reports.map((r) => r.agent).join(", ")}`);
+        lines.push(`Total findings: ${allFindings.length}`);
+        lines.push("");
+        // Per-agent verdicts
+        lines.push("## Agent Results");
+        for (const report of reports) {
+            const agentFindings = report.findings;
+            const counts = countBySeverity(agentFindings);
+            lines.push(`- **@${report.agent}**: ${report.verdict} — ${formatCounts(counts)}`);
+        }
+        // All findings sorted by severity
+        if (allFindings.length > 0) {
+            lines.push("");
+            lines.push("## Findings (sorted by severity)");
+            for (const finding of allFindings) {
+                const loc = finding.location ? ` (${finding.location})` : "";
+                lines.push(`- **[${finding.severity}]** @${finding.agent}: ${finding.title}${loc}`);
+                if (finding.description) {
+                    lines.push(`  ${finding.description.substring(0, 200)}`);
+                }
+            }
+        }
+        // Blockers
+        const blockers = allFindings.filter((f) => f.severity === "CRITICAL" || f.severity === "HIGH");
+        if (blockers.length > 0) {
+            lines.push("");
+            lines.push("## Blockers (must fix before merge)");
+            for (const b of blockers) {
+                lines.push(`- **[${b.severity}]** @${b.agent}: ${b.title}`);
+            }
+        }
+        // PR body section
+        lines.push("");
+        lines.push("## PR Body Quality Gate Section");
+        lines.push("```");
+        lines.push("## Quality Gate");
+        for (const report of reports) {
+            const counts = countBySeverity(report.findings);
+            lines.push(`- ${capitalize(report.agent)}: ${report.verdict} — ${formatCounts(counts)}`);
+        }
+        lines.push(`- **Recommendation: ${recommendation}**`);
+        lines.push("```");
+        return lines.join("\n");
+    },
+});
+// ─── Parsing helpers ─────────────────────────────────────────────────────────
+function parseReport(agent, raw) {
+    const findings = [];
+    // Extract verdict
+    let verdict = "Unknown";
+    const verdictMatch = raw.match(/\*\*Verdict\*\*:\s*(.+)/i)
+        ?? raw.match(/Verdict:\s*(.+)/i);
+    if (verdictMatch) {
+        verdict = verdictMatch[1].trim();
+    }
+    // Extract findings by severity markers
+    const findingRegex = /####?\s*\[(CRITICAL|HIGH|MEDIUM|LOW|INFO|BLOCKING|WARNING|ERROR|SUGGESTION|NITPICK|PRAISE)\]\s*(.+)/gi;
+    let match;
+    while ((match = findingRegex.exec(raw)) !== null) {
+        const rawSeverity = match[1].toUpperCase();
+        const title = match[2].trim();
+        // Normalize severity
+        let severity;
+        switch (rawSeverity) {
+            case "CRITICAL":
+            case "BLOCKING":
+            case "ERROR":
+                severity = "CRITICAL";
+                break;
+            case "HIGH":
+                severity = "HIGH";
+                break;
+            case "MEDIUM":
+            case "WARNING":
+            case "SUGGESTION":
+                severity = "MEDIUM";
+                break;
+            case "LOW":
+            case "NITPICK":
+                severity = "LOW";
+                break;
+            default:
+                severity = "INFO";
+        }
+        // Try to extract location from lines following the finding
+        const afterMatch = raw.substring(match.index + match[0].length, match.index + match[0].length + 500);
+        const locationMatch = afterMatch.match(/\*\*Location\*\*:\s*`?([^`\n]+)/i)
+            ?? afterMatch.match(/\*\*File\*\*:\s*`?([^`\n]+)/i);
+        const descMatch = afterMatch.match(/\*\*Description\*\*:\s*(.+)/i);
+        findings.push({
+            agent,
+            severity,
+            title,
+            location: locationMatch?.[1]?.trim(),
+            description: descMatch?.[1]?.trim() ?? "",
+        });
+    }
+    return { agent, verdict, findings, raw };
+}
+function countBySeverity(findings) {
+    const counts = {};
+    for (const f of findings) {
+        counts[f.severity] = (counts[f.severity] ?? 0) + 1;
+    }
+    return counts;
+}
+function formatCounts(counts) {
+    const parts = [];
+    for (const sev of ["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO"]) {
+        if (counts[sev]) {
+            parts.push(`${counts[sev]} ${sev.toLowerCase()}`);
+        }
+    }
+    return parts.length > 0 ? parts.join(", ") : "no findings";
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function persistState(cwd, state) {
+    const dir = path.join(cwd, CORTEX_DIR);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const filepath = path.join(dir, QUALITY_GATE_FILE);
+    fs.writeFileSync(filepath, JSON.stringify(state, null, 2));
+}

package/dist/tools/repl.d.ts

@@ -0,0 +1,55 @@
+/**
+ * REPL Loop Tools
+ *
+ * Four tools for the implement agent's iterative task-by-task development loop:
+ *   - repl_init    — Initialize a loop from a plan
+ *   - repl_status  — Get current progress and next task
+ *   - repl_report  — Report task outcome (pass/fail/skip)
+ *   - repl_summary — Generate markdown summary for PR body
+ */
+export declare const init: {
+    description: string;
+    args: {
+        planFilename: import("zod").ZodString;
+        buildCommand: import("zod").ZodOptional<import("zod").ZodString>;
+        testCommand: import("zod").ZodOptional<import("zod").ZodString>;
+        maxRetries: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    execute(args: {
+        planFilename: string;
+        buildCommand?: string | undefined;
+        testCommand?: string | undefined;
+        maxRetries?: number | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const status: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const report: {
+    description: string;
+    args: {
+        result: import("zod").ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            skip: "skip";
+        }>;
+        detail: import("zod").ZodString;
+    };
+    execute(args: {
+        result: "pass" | "fail" | "skip";
+        detail: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const resume: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const summary: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+//# sourceMappingURL=repl.d.ts.map

package/dist/tools/repl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repl.d.ts","sourceRoot":"","sources":["../../src/tools/repl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA0BH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;CAwGf,CAAC;AAIH,eAAO,MAAM,MAAM;;;;CA0BjB,CAAC;AAIH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;CAwCjB,CAAC;AAkFH,eAAO,MAAM,MAAM;;;;CA+CjB,CAAC;AAIH,eAAO,MAAM,OAAO;;;;CAclB,CAAC"}

package/dist/tools/repl.js

@@ -0,0 +1,291 @@
+/**
+ * REPL Loop Tools
+ *
+ * Four tools for the implement agent's iterative task-by-task development loop:
+ *   - repl_init    — Initialize a loop from a plan
+ *   - repl_status  — Get current progress and next task
+ *   - repl_report  — Report task outcome (pass/fail/skip)
+ *   - repl_summary — Generate markdown summary for PR body
+ */
+import { tool } from "@opencode-ai/plugin";
+import * as fs from "fs";
+import * as path from "path";
+import { parseTasksWithAC, detectCommands, readCortexConfig, readReplState, writeReplState, getNextTask, getCurrentTask, isLoopComplete, detectIncompleteState, formatProgress, formatSummary, } from "../utils/repl.js";
+const CORTEX_DIR = ".cortex";
+const PLANS_DIR = "plans";
+// ─── repl_init ───────────────────────────────────────────────────────────────
+export const init = tool({
+    description: "Initialize a REPL implementation loop from a plan. Parses plan tasks, " +
+        "auto-detects build/test commands, and creates .cortex/repl-state.json " +
+        "for tracking progress through each task iteratively.",
+    args: {
+        planFilename: tool.schema
+            .string()
+            .describe("Plan filename from .cortex/plans/ to load tasks from"),
+        buildCommand: tool.schema
+            .string()
+            .optional()
+            .describe("Override auto-detected build command (e.g., 'npm run build')"),
+        testCommand: tool.schema
+            .string()
+            .optional()
+            .describe("Override auto-detected test command (e.g., 'npm test')"),
+        maxRetries: tool.schema
+            .number()
+            .optional()
+            .describe("Max retries per failing task before escalating to user (default: 3)"),
+    },
+    async execute(args, context) {
+        const cwd = context.worktree;
+        const config = readCortexConfig(cwd);
+        const { planFilename, buildCommand, testCommand, maxRetries = config.maxRetries ?? 3 } = args;
+        // 1. Validate plan filename
+        if (!planFilename || planFilename === "." || planFilename === "..") {
+            return `\u2717 Error: Invalid plan filename.`;
+        }
+        const plansDir = path.join(cwd, CORTEX_DIR, PLANS_DIR);
+        const planPath = path.resolve(plansDir, planFilename);
+        const resolvedPlansDir = path.resolve(plansDir);
+        // Prevent path traversal — resolved path must be strictly inside plans dir
+        if (!planPath.startsWith(resolvedPlansDir + path.sep)) {
+            return `\u2717 Error: Invalid plan filename.`;
+        }
+        if (!fs.existsSync(planPath)) {
+            return `\u2717 Error: Plan not found: ${planFilename}\n\nUse plan_list to see available plans.`;
+        }
+        const planContent = fs.readFileSync(planPath, "utf-8");
+        // 2. Parse tasks from plan (with acceptance criteria)
+        const parsedTasks = parseTasksWithAC(planContent);
+        if (parsedTasks.length === 0) {
+            return `\u2717 Error: No tasks found in plan: ${planFilename}\n\nThe plan must contain unchecked checkbox items (- [ ] ...) in a ## Tasks section.`;
+        }
+        // 3. Auto-detect commands (or use overrides)
+        const detected = await detectCommands(cwd);
+        const finalBuild = buildCommand ?? detected.buildCommand;
+        const finalTest = testCommand ?? detected.testCommand;
+        // 4. Build initial state
+        const tasks = parsedTasks.map((parsed, i) => ({
+            index: i,
+            description: parsed.description,
+            acceptanceCriteria: parsed.acceptanceCriteria,
+            status: "pending",
+            retries: 0,
+            iterations: [],
+        }));
+        const state = {
+            planFilename,
+            startedAt: new Date().toISOString(),
+            buildCommand: finalBuild,
+            testCommand: finalTest,
+            lintCommand: detected.lintCommand,
+            maxRetries,
+            currentTaskIndex: -1,
+            tasks,
+        };
+        // 5. Write state
+        writeReplState(cwd, state);
+        // 6. Format output
+        const cmdInfo = detected.detected
+            ? `Auto-detected (${detected.framework})`
+            : "Not detected \u2014 provide overrides if needed";
+        return `\u2713 REPL loop initialized
+
+Plan: ${planFilename}
+Tasks: ${tasks.length}
+Detection: ${cmdInfo}
+
+Build: ${finalBuild || "(none)"}
+Test:  ${finalTest || "(none)"}
+${detected.lintCommand ? `Lint:  ${detected.lintCommand}` : ""}
+Max retries: ${maxRetries}
+
+First task (#1):
+  "${tasks[0].description}"
+
+Run \`repl_status\` to begin, then implement the task and run build/tests.`;
+    },
+});
+// ─── repl_status ─────────────────────────────────────────────────────────────
+export const status = tool({
+    description: "Get the current REPL loop progress \u2014 which task is active, " +
+        "what\u2019s been completed, retry counts, and detected build/test commands. " +
+        "Call this to decide what to implement next.",
+    args: {},
+    async execute(args, context) {
+        const state = readReplState(context.worktree);
+        if (!state) {
+            return `\u2717 No REPL loop active.\n\nRun repl_init with a plan filename to start a loop.`;
+        }
+        // Auto-advance: if no task is in_progress, promote the next pending task
+        const current = getCurrentTask(state);
+        if (!current && !isLoopComplete(state)) {
+            const next = getNextTask(state);
+            if (next) {
+                next.status = "in_progress";
+                next.startedAt = new Date().toISOString();
+                state.currentTaskIndex = next.index;
+                writeReplState(context.worktree, state);
+            }
+        }
+        return `\u2713 REPL Loop Status\n\n${formatProgress(state)}`;
+    },
+});
+// ─── repl_report ─────────────────────────────────────────────────────────────
+export const report = tool({
+    description: "Report the outcome of the current task iteration. " +
+        "After implementing a task and running build/tests, report whether it passed, " +
+        "failed, or should be skipped. The loop will auto-advance on pass, " +
+        "retry on fail (up to max), or escalate to user when retries exhausted.",
+    args: {
+        result: tool.schema
+            .enum(["pass", "fail", "skip"])
+            .describe("Task result: 'pass' (build+tests green), 'fail' (something broke), 'skip' (defer task)"),
+        detail: tool.schema
+            .string()
+            .describe("Result details: test output summary, error message, or skip reason"),
+    },
+    async execute(args, context) {
+        const { result, detail } = args;
+        const state = readReplState(context.worktree);
+        if (!state) {
+            return `\u2717 No REPL loop active. Run repl_init first.`;
+        }
+        // Find the current in_progress task
+        const current = getCurrentTask(state);
+        if (!current) {
+            // Try to find the task at currentTaskIndex
+            if (state.currentTaskIndex >= 0 && state.currentTaskIndex < state.tasks.length) {
+                const task = state.tasks[state.currentTaskIndex];
+                if (task.status === "pending") {
+                    task.status = "in_progress";
+                }
+                return processReport(state, task, result, detail, context.worktree);
+            }
+            return `\u2717 No task is currently in progress.\n\nRun repl_status to advance to the next task.`;
+        }
+        return processReport(state, current, result, detail, context.worktree);
+    },
+});
+/**
+ * Process a report for a task and update state.
+ */
+function processReport(state, task, result, detail, cwd) {
+    // Record iteration
+    task.iterations.push({
+        at: new Date().toISOString(),
+        result,
+        detail: detail.substring(0, 2000), // Cap detail length
+    });
+    const taskNum = task.index + 1;
+    const taskDesc = task.description;
+    let output;
+    switch (result) {
+        case "pass": {
+            task.status = "passed";
+            task.completedAt = new Date().toISOString();
+            const attempt = task.iterations.length;
+            const suffix = attempt === 1 ? "1st" : attempt === 2 ? "2nd" : attempt === 3 ? "3rd" : `${attempt}th`;
+            output = `\u2713 Task #${taskNum} PASSED (${suffix} attempt)\n  "${taskDesc}"\n  Detail: ${detail.substring(0, 200)}`;
+            break;
+        }
+        case "fail": {
+            task.retries += 1;
+            const attempt = task.iterations.length;
+            if (task.retries >= state.maxRetries) {
+                // Retries exhausted
+                task.status = "failed";
+                task.completedAt = new Date().toISOString();
+                output = `\u2717 Task #${taskNum} FAILED \u2014 retries exhausted (${attempt}/${state.maxRetries} attempts)\n  "${taskDesc}"\n  Detail: ${detail.substring(0, 200)}\n\n\u2192 ASK THE USER how to proceed. Suggest: fix manually, skip task, or abort loop.`;
+            }
+            else {
+                // Retries remaining — stay in_progress
+                const remaining = state.maxRetries - task.retries;
+                output = `\u26A0 Task #${taskNum} FAILED (attempt ${attempt}/${state.maxRetries})\n  "${taskDesc}"\n  Detail: ${detail.substring(0, 200)}\n\n\u2192 Fix the issue and run build/tests again. ${remaining} retr${remaining > 1 ? "ies" : "y"} remaining.`;
+                // Don't advance — keep task in_progress
+                writeReplState(cwd, state);
+                return output;
+            }
+            break;
+        }
+        case "skip": {
+            task.status = "skipped";
+            task.completedAt = new Date().toISOString();
+            output = `\u2298 Task #${taskNum} SKIPPED\n  "${taskDesc}"\n  Reason: ${detail.substring(0, 200)}`;
+            break;
+        }
+    }
+    // Advance to next task
+    const next = getNextTask(state);
+    if (next) {
+        next.status = "in_progress";
+        next.startedAt = new Date().toISOString();
+        state.currentTaskIndex = next.index;
+        output += `\n\n\u2192 Next: Task #${next.index + 1} "${next.description}"`;
+    }
+    else {
+        // All tasks done
+        state.currentTaskIndex = -1;
+        state.completedAt = new Date().toISOString();
+        output += "\n\n\u2713 All tasks complete. Run repl_summary to generate the results report, then proceed to the quality gate (Step 7).";
+    }
+    writeReplState(cwd, state);
+    return output;
+}
+// ─── repl_resume ─────────────────────────────────────────────────────────────
+export const resume = tool({
+    description: "Detect and resume an interrupted REPL loop. Checks for incomplete state " +
+        "in .cortex/repl-state.json and offers to continue from where it left off. " +
+        "Call this at the start of a session to recover from crashes or context loss.",
+    args: {},
+    async execute(args, context) {
+        const state = detectIncompleteState(context.worktree);
+        if (!state) {
+            return `\u2717 No interrupted REPL loop found.\n\nEither no loop has been started, or the previous loop completed normally.`;
+        }
+        const total = state.tasks.length;
+        const passed = state.tasks.filter((t) => t.status === "passed").length;
+        const failed = state.tasks.filter((t) => t.status === "failed").length;
+        const skipped = state.tasks.filter((t) => t.status === "skipped").length;
+        const done = passed + failed + skipped;
+        const current = getCurrentTask(state);
+        const next = getNextTask(state);
+        const lines = [];
+        lines.push(`\u2713 Interrupted REPL loop detected`);
+        lines.push("");
+        lines.push(`Plan: ${state.planFilename}`);
+        lines.push(`Progress: ${done}/${total} tasks completed (${passed} passed, ${failed} failed, ${skipped} skipped)`);
+        lines.push(`Started: ${state.startedAt}`);
+        if (current) {
+            lines.push("");
+            lines.push(`Interrupted task (#${current.index + 1}):`);
+            lines.push(`  "${current.description}"`);
+            lines.push(`  Status: in_progress (${current.retries} retries so far)`);
+            if (current.iterations.length > 0) {
+                const lastIter = current.iterations[current.iterations.length - 1];
+                lines.push(`  Last attempt: ${lastIter.result} — ${lastIter.detail.substring(0, 100)}`);
+            }
+        }
+        else if (next) {
+            lines.push("");
+            lines.push(`Next pending task (#${next.index + 1}):`);
+            lines.push(`  "${next.description}"`);
+        }
+        lines.push("");
+        lines.push(`\u2192 Run repl_status to continue the loop from where it left off.`);
+        return lines.join("\n");
+    },
+});
+// ─── repl_summary ────────────────────────────────────────────────────────────
+export const summary = tool({
+    description: "Generate a formatted summary of the REPL loop results for inclusion in " +
+        "the quality gate report and PR body. Call after all tasks are complete " +
+        "or when the loop is terminated.",
+    args: {},
+    async execute(args, context) {
+        const state = readReplState(context.worktree);
+        if (!state) {
+            return `\u2717 No REPL loop data found.\n\nRun repl_init to start a loop, or this may have been cleaned up already.`;
+        }
+        return formatSummary(state);
+    },
+});

package/dist/tools/task.d.ts

@@ -7,6 +7,7 @@ export declare const finalize: {
         baseBranch: import("zod").ZodOptional<import("zod").ZodString>;
         planFilename: import("zod").ZodOptional<import("zod").ZodString>;
         draft: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        issueRefs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
     };
     execute(args: {
         commitMessage: string;
@@ -15,6 +16,7 @@ export declare const finalize: {
         baseBranch?: string | undefined;
         planFilename?: string | undefined;
         draft?: boolean | undefined;
+        issueRefs?: number[] | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
 //# sourceMappingURL=task.d.ts.map

package/dist/tools/task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/tools/task.ts"],"names":[],"mappings":"AAyGA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;CAqNnB,CAAC"}
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/tools/task.ts"],"names":[],"mappings":"AA+EA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;CA0OnB,CAAC"}