agentplane 0.3.1 → 0.3.3

package/dist/commands/task/shared/dependencies.js

@@ -0,0 +1,143 @@
+import { CliError } from "../../../shared/errors.js";
+import { dedupeStrings } from "../../../shared/strings.js";
+import { toStringArray } from "./tags.js";
+function hasDependsOnCycle(dependsOnMap) {
+    const visiting = new Set();
+    const visited = new Set();
+    const stack = [];
+    function dfs(taskId) {
+        if (visited.has(taskId))
+            return null;
+        if (visiting.has(taskId)) {
+            const start = stack.indexOf(taskId);
+            return start === -1 ? [taskId] : [...stack.slice(start), taskId];
+        }
+        visiting.add(taskId);
+        stack.push(taskId);
+        const deps = dependsOnMap.get(taskId) ?? [];
+        for (const depId of deps) {
+            const cycle = dfs(depId);
+            if (cycle)
+                return cycle;
+        }
+        stack.pop();
+        visiting.delete(taskId);
+        visited.add(taskId);
+        return null;
+    }
+    for (const taskId of dependsOnMap.keys()) {
+        const cycle = dfs(taskId);
+        if (cycle)
+            return cycle;
+    }
+    return null;
+}
+export async function ensureTaskDependsOnGraphIsAcyclic(opts) {
+    const nextDepends = dedupeStrings(opts.dependsOn);
+    if (nextDepends.includes(opts.taskId)) {
+        throw new CliError({
+            exitCode: 2,
+            code: "E_USAGE",
+            message: `depends_on cannot include task itself (${opts.taskId})`,
+        });
+    }
+    const allTasks = await opts.backend.listTasks();
+    const depMap = new Map();
+    for (const task of allTasks) {
+        const taskId = String(task.id || "").trim();
+        if (!taskId)
+            continue;
+        if (taskId === opts.taskId)
+            continue;
+        depMap.set(taskId, dedupeStrings(toStringArray(task.depends_on)));
+    }
+    depMap.set(opts.taskId, nextDepends);
+    const cycle = hasDependsOnCycle(depMap);
+    if (!cycle)
+        return;
+    throw new CliError({
+        exitCode: 2,
+        code: "E_USAGE",
+        message: `depends_on cycle detected: ${cycle.join(" -> ")}`,
+    });
+}
+export async function resolveTaskDependencyState(task, backend) {
+    const dependsOn = dedupeStrings(toStringArray(task.depends_on));
+    if (dependsOn.length === 0) {
+        return { dependsOn, missing: [], incomplete: [] };
+    }
+    const loaded = backend.getTasks
+        ? await backend.getTasks(dependsOn)
+        : await Promise.all(dependsOn.map(async (depId) => await backend.getTask(depId)));
+    const missing = [];
+    const incomplete = [];
+    for (const [idx, depId] of dependsOn.entries()) {
+        const dep = loaded[idx] ?? null;
+        if (!dep) {
+            missing.push(depId);
+            continue;
+        }
+        const status = String(dep.status || "TODO").toUpperCase();
+        if (status !== "DONE")
+            incomplete.push(depId);
+    }
+    return { dependsOn, missing, incomplete };
+}
+export function buildDependencyState(tasks) {
+    const byId = new Map(tasks.map((task) => [task.id, task]));
+    const state = new Map();
+    for (const task of tasks) {
+        const dependsOn = dedupeStrings(toStringArray(task.depends_on));
+        const missing = [];
+        const incomplete = [];
+        for (const depId of dependsOn) {
+            const dep = byId.get(depId);
+            if (!dep) {
+                missing.push(depId);
+                continue;
+            }
+            const status = String(dep.status || "TODO").toUpperCase();
+            if (status !== "DONE") {
+                incomplete.push(depId);
+            }
+        }
+        state.set(task.id, { dependsOn, missing, incomplete });
+    }
+    return state;
+}
+function formatDepsSummary(dep) {
+    if (!dep)
+        return null;
+    if (dep.dependsOn.length === 0)
+        return "deps=none";
+    if (dep.missing.length === 0 && dep.incomplete.length === 0)
+        return "deps=ready";
+    const parts = [];
+    if (dep.missing.length > 0) {
+        parts.push(`missing:${dep.missing.join(",")}`);
+    }
+    if (dep.incomplete.length > 0) {
+        parts.push(`wait:${dep.incomplete.join(",")}`);
+    }
+    return `deps=${parts.join(",")}`;
+}
+export function formatTaskLine(task, depState) {
+    const status = String(task.status || "TODO").toUpperCase();
+    const extras = [];
+    if (task.owner?.trim())
+        extras.push(`owner=${task.owner.trim()}`);
+    if (task.priority !== undefined && String(task.priority).trim()) {
+        extras.push(`prio=${String(task.priority).trim()}`);
+    }
+    const depsSummary = formatDepsSummary(depState);
+    if (depsSummary)
+        extras.push(depsSummary);
+    const tags = dedupeStrings(toStringArray(task.tags));
+    if (tags.length > 0)
+        extras.push(`tags=${tags.join(",")}`);
+    const verify = dedupeStrings(toStringArray(task.verify));
+    if (verify.length > 0)
+        extras.push(`verify=${verify.length}`);
+    const suffix = extras.length > 0 ? ` (${extras.join(", ")})` : "";
+    return `${task.id} [${status}] ${task.title?.trim() || "(untitled task)"}${suffix}`;
+}

package/dist/commands/task/shared/docs.d.ts

@@ -0,0 +1,21 @@
+import type { AgentplaneConfig } from "@agentplaneorg/core";
+import type { TaskData } from "../../../backends/task-backend.js";
+export declare function nowIso(): string;
+export declare const VERIFY_STEPS_PLACEHOLDER = "<!-- TODO: REPLACE WITH TASK-SPECIFIC ACCEPTANCE STEPS -->";
+export declare const VERIFICATION_RESULTS_BEGIN = "<!-- BEGIN VERIFICATION RESULTS -->";
+export declare const VERIFICATION_RESULTS_END = "<!-- END VERIFICATION RESULTS -->";
+export type TaskDocVersion = 2 | 3;
+export declare function extractDocSection(doc: string, sectionName: string): string | null;
+export declare function isVerifyStepsFilled(sectionText: string | null): boolean;
+export declare function normalizeTaskDocVersion(value: unknown, fallback?: TaskDocVersion): TaskDocVersion;
+export declare function normalizeVerificationSectionLayout(sectionText: string | null, version: TaskDocVersion): string;
+export declare function taskObservationSectionName(version: TaskDocVersion): "Notes" | "Findings";
+export declare function extractTaskObservationSection(doc: string, version: TaskDocVersion): string | null;
+export declare function isDocSectionFilled(sectionText: string | null): boolean;
+export declare function ensureAgentFilledRequiredDocSections(opts: {
+    task: Pick<TaskData, "id">;
+    config: AgentplaneConfig;
+    doc: string;
+    action: string;
+}): void;
+//# sourceMappingURL=docs.d.ts.map

package/dist/commands/task/shared/docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../../../src/commands/task/shared/docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAI5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AAElE,wBAAgB,MAAM,IAAI,MAAM,CAE/B;AAED,eAAO,MAAM,wBAAwB,+DACyB,CAAC;AAC/D,eAAO,MAAM,0BAA0B,wCAAwC,CAAC;AAChF,eAAO,MAAM,wBAAwB,sCAAsC,CAAC;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,CAAC,CAAC;AAEnC,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiBjF;AAED,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAKvE;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,OAAO,EACd,QAAQ,GAAE,cAAkB,GAC3B,cAAc,CAEhB;AAED,wBAAgB,kCAAkC,CAChD,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,OAAO,EAAE,cAAc,GACtB,MAAM,CAyCR;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,GAAG,UAAU,CAExF;AAED,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI,CAIjG;AAMD,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAKtE;AAED,wBAAgB,oCAAoC,CAAC,IAAI,EAAE;IACzD,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAC3B,MAAM,EAAE,gBAAgB,CAAC;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,IAAI,CA6BP"}

package/dist/commands/task/shared/docs.js

@@ -0,0 +1,121 @@
+import { CliError } from "../../../shared/errors.js";
+import { dedupeStrings } from "../../../shared/strings.js";
+export function nowIso() {
+    return new Date().toISOString();
+}
+export const VERIFY_STEPS_PLACEHOLDER = "<!-- TODO: REPLACE WITH TASK-SPECIFIC ACCEPTANCE STEPS -->";
+export const VERIFICATION_RESULTS_BEGIN = "<!-- BEGIN VERIFICATION RESULTS -->";
+export const VERIFICATION_RESULTS_END = "<!-- END VERIFICATION RESULTS -->";
+export function extractDocSection(doc, sectionName) {
+    const lines = doc.replaceAll("\r\n", "\n").split("\n");
+    let capturing = false;
+    const out = [];
+    for (const line of lines) {
+        const match = /^##\s+(.*)$/.exec(line.trim());
+        if (match) {
+            if (capturing)
+                break;
+            capturing = (match[1] ?? "").trim() === sectionName;
+            continue;
+        }
+        if (capturing)
+            out.push(line);
+    }
+    if (!capturing)
+        return null;
+    return out.join("\n").trimEnd();
+}
+export function isVerifyStepsFilled(sectionText) {
+    const normalized = (sectionText ?? "").trim();
+    if (!normalized)
+        return false;
+    if (normalized.includes(VERIFY_STEPS_PLACEHOLDER))
+        return false;
+    return true;
+}
+export function normalizeTaskDocVersion(value, fallback = 2) {
+    return value === 3 ? 3 : value === 2 ? 2 : fallback;
+}
+export function normalizeVerificationSectionLayout(sectionText, version) {
+    const normalized = (sectionText ?? "").replaceAll("\r\n", "\n").trimEnd();
+    if (version === 3) {
+        const stripped = normalized
+            .split("\n")
+            .filter((line) => {
+            const trimmed = line.trim();
+            return trimmed !== "### Plan" && trimmed !== "### Results";
+        })
+            .join("\n")
+            .replaceAll(/\n{3,}/g, "\n\n")
+            .trim();
+        if (!stripped)
+            return [VERIFICATION_RESULTS_BEGIN, VERIFICATION_RESULTS_END].join("\n");
+        const hasBegin = stripped.includes(VERIFICATION_RESULTS_BEGIN);
+        const hasEnd = stripped.includes(VERIFICATION_RESULTS_END);
+        if (hasBegin && hasEnd)
+            return stripped;
+        return [stripped, "", VERIFICATION_RESULTS_BEGIN, VERIFICATION_RESULTS_END].join("\n");
+    }
+    if (!normalized) {
+        return [
+            "### Plan",
+            "",
+            "",
+            "### Results",
+            "",
+            "",
+            VERIFICATION_RESULTS_BEGIN,
+            VERIFICATION_RESULTS_END,
+        ].join("\n");
+    }
+    const hasBegin = normalized.includes(VERIFICATION_RESULTS_BEGIN);
+    const hasEnd = normalized.includes(VERIFICATION_RESULTS_END);
+    if (hasBegin && hasEnd)
+        return normalized;
+    return [normalized, "", VERIFICATION_RESULTS_BEGIN, VERIFICATION_RESULTS_END].join("\n");
+}
+export function taskObservationSectionName(version) {
+    return version === 3 ? "Findings" : "Notes";
+}
+export function extractTaskObservationSection(doc, version) {
+    const primary = taskObservationSectionName(version);
+    const fallback = primary === "Findings" ? "Notes" : "Findings";
+    return extractDocSection(doc, primary) ?? extractDocSection(doc, fallback);
+}
+const DOC_PLACEHOLDER_RE = /<!--\s*TODO\b/i;
+const DOC_SECTIONS_AUTO_MANAGED = new Set(["verification"]);
+const DOC_SECTIONS_CONDITIONAL = new Set(["verify steps", "notes"]);
+export function isDocSectionFilled(sectionText) {
+    const normalized = (sectionText ?? "").trim();
+    if (!normalized)
+        return false;
+    if (DOC_PLACEHOLDER_RE.test(normalized))
+        return false;
+    return true;
+}
+export function ensureAgentFilledRequiredDocSections(opts) {
+    const required = dedupeStrings((opts.config.tasks.doc.required_sections ?? [])
+        .map((section) => String(section ?? "").trim())
+        .filter(Boolean));
+    const missing = [];
+    for (const section of required) {
+        const normalizedSection = section.trim().toLowerCase();
+        if (DOC_SECTIONS_AUTO_MANAGED.has(normalizedSection))
+            continue;
+        if (DOC_SECTIONS_CONDITIONAL.has(normalizedSection))
+            continue;
+        const sectionText = extractDocSection(opts.doc, section);
+        if (!isDocSectionFilled(sectionText)) {
+            missing.push(section);
+        }
+    }
+    if (missing.length === 0)
+        return;
+    const sectionList = missing.map((section) => `## ${section}`).join(", ");
+    throw new CliError({
+        exitCode: 3,
+        code: "E_VALIDATION",
+        message: `${opts.task.id}: cannot ${opts.action}: required task doc sections are missing/empty: ${sectionList} ` +
+            `(fill via \`agentplane task doc set ${opts.task.id} --section <name> --text "..."\`)`,
+    });
+}

package/dist/commands/task/shared/listing.d.ts

@@ -0,0 +1,20 @@
+import type { TaskData } from "../../../backends/task-backend.js";
+export type TaskListFilters = {
+    status: string[];
+    owner: string[];
+    tag: string[];
+    limit?: number;
+    quiet: boolean;
+    strictRead?: boolean;
+};
+export declare function parseTaskListFilters(args: string[], opts?: {
+    allowLimit?: boolean;
+}): TaskListFilters;
+export declare function handleTaskListWarnings(opts: {
+    backend: {
+        getLastListWarnings?: () => string[];
+    };
+    strictRead?: boolean;
+}): void;
+export declare function taskTextBlob(task: TaskData): string;
+//# sourceMappingURL=listing.d.ts.map

package/dist/commands/task/shared/listing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listing.d.ts","sourceRoot":"","sources":["../../../../src/commands/task/shared/listing.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AAIlE,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,GAC9B,eAAe,CAkFjB;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,OAAO,EAAE;QAAE,mBAAmB,CAAC,EAAE,MAAM,MAAM,EAAE,CAAA;KAAE,CAAC;IAClD,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,GAAG,IAAI,CAcP;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAiBnD"}

package/dist/commands/task/shared/listing.js

@@ -0,0 +1,127 @@
+import { invalidValueForFlag, missingValueMessage, warnMessage } from "../../../cli/output.js";
+import { exitCodeForError } from "../../../cli/exit-codes.js";
+import { CliError } from "../../../shared/errors.js";
+import { toStringArray } from "./tags.js";
+export function parseTaskListFilters(args, opts) {
+    const out = { status: [], owner: [], tag: [], quiet: false, strictRead: false };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg)
+            continue;
+        if (arg === "--quiet") {
+            out.quiet = true;
+            continue;
+        }
+        if (arg === "--strict-read") {
+            out.strictRead = true;
+            continue;
+        }
+        if (arg === "--status") {
+            const next = args[i + 1];
+            if (!next) {
+                throw new CliError({
+                    exitCode: exitCodeForError("E_USAGE"),
+                    code: "E_USAGE",
+                    message: missingValueMessage("--status"),
+                });
+            }
+            out.status.push(next);
+            i++;
+            continue;
+        }
+        if (arg === "--owner") {
+            const next = args[i + 1];
+            if (!next) {
+                throw new CliError({
+                    exitCode: exitCodeForError("E_USAGE"),
+                    code: "E_USAGE",
+                    message: missingValueMessage("--owner"),
+                });
+            }
+            out.owner.push(next);
+            i++;
+            continue;
+        }
+        if (arg === "--tag") {
+            const next = args[i + 1];
+            if (!next) {
+                throw new CliError({
+                    exitCode: exitCodeForError("E_USAGE"),
+                    code: "E_USAGE",
+                    message: missingValueMessage("--tag"),
+                });
+            }
+            out.tag.push(next);
+            i++;
+            continue;
+        }
+        if (opts?.allowLimit && arg === "--limit") {
+            const next = args[i + 1];
+            if (!next) {
+                throw new CliError({
+                    exitCode: exitCodeForError("E_USAGE"),
+                    code: "E_USAGE",
+                    message: missingValueMessage("--limit"),
+                });
+            }
+            const parsed = Number.parseInt(next, 10);
+            if (!Number.isFinite(parsed)) {
+                throw new CliError({
+                    exitCode: exitCodeForError("E_USAGE"),
+                    code: "E_USAGE",
+                    message: invalidValueForFlag("--limit", next, "integer"),
+                });
+            }
+            out.limit = parsed;
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            throw new CliError({
+                exitCode: exitCodeForError("E_USAGE"),
+                code: "E_USAGE",
+                message: `Unknown flag: ${arg}`,
+            });
+        }
+    }
+    return out;
+}
+export function handleTaskListWarnings(opts) {
+    const warnings = opts.backend.getLastListWarnings?.() ?? [];
+    if (warnings.length === 0)
+        return;
+    const preview = warnings.slice(0, 3).join("; ");
+    const suffix = warnings.length > 3 ? `; +${warnings.length - 3} more` : "";
+    const message = `skipped ${warnings.length} task files during scan (${preview}${suffix})`;
+    if (opts.strictRead) {
+        throw new CliError({
+            exitCode: exitCodeForError("E_VALIDATION"),
+            code: "E_VALIDATION",
+            message: `task scan strict mode failed: ${message}`,
+        });
+    }
+    process.stderr.write(`${warnMessage(message)}\n`);
+}
+export function taskTextBlob(task) {
+    const parts = [];
+    for (const key of ["id", "title", "description", "status", "priority", "owner"]) {
+        const value = task[key];
+        if (typeof value === "string" && value.trim())
+            parts.push(value.trim());
+    }
+    const tags = toStringArray(task.tags);
+    parts.push(...tags.filter(Boolean));
+    const comments = Array.isArray(task.comments) ? task.comments : [];
+    for (const comment of comments) {
+        if (comment && typeof comment.author === "string")
+            parts.push(comment.author);
+        if (comment && typeof comment.body === "string")
+            parts.push(comment.body);
+    }
+    const commit = task.commit ?? null;
+    if (commit && typeof commit.hash === "string")
+        parts.push(commit.hash);
+    if (commit && typeof commit.message === "string")
+        parts.push(commit.message);
+    return parts.join("\n");
+}

package/dist/commands/task/shared/tags.d.ts

@@ -0,0 +1,24 @@
+import type { AgentplaneConfig } from "@agentplaneorg/core";
+import type { CommandContext } from "../../shared/task-backend.js";
+export declare function normalizeDependsOnInput(value: string): string[];
+export declare function normalizeTaskStatus(value: string): string;
+export declare function toStringArray(value: unknown): string[];
+export declare function requiresVerify(tags: string[], requiredTags: string[]): boolean;
+export type PrimaryTagResolution = {
+    primary: string;
+    matched: string[];
+    usedFallback: boolean;
+};
+export type TaskTagPolicy = {
+    primaryAllowlist: string[];
+    strictPrimary: boolean;
+    fallbackPrimary: string;
+    lockPrimaryOnUpdate: boolean;
+};
+export declare function readTaskTagPolicy(input: CommandContext | AgentplaneConfig): TaskTagPolicy;
+export declare function resolvePrimaryTagFromConfig(tags: string[], config: AgentplaneConfig): PrimaryTagResolution;
+export declare function requiresVerifyStepsByPrimary(tags: string[], config: AgentplaneConfig): boolean;
+export declare function requiresVerificationByPrimary(tags: string[], config: AgentplaneConfig): boolean;
+export declare function resolvePrimaryTag(tags: string[], ctx: CommandContext): PrimaryTagResolution;
+export declare function warnIfUnknownOwner(ctx: CommandContext, owner: string): Promise<void>;
+//# sourceMappingURL=tags.d.ts.map

package/dist/commands/task/shared/tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../../../../src/commands/task/shared/tags.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAQ5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAiBnE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAI/D;AAID,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAczD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAKtD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAI9E;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,OAAO,CAAC;CAC9B,CAAC;AAsCF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,cAAc,GAAG,gBAAgB,GAAG,aAAa,CAkBzF;AAoCD,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,gBAAgB,GACvB,oBAAoB,CA+CtB;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAG9F;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAG/F;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,cAAc,GAAG,oBAAoB,CAE3F;AAED,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAe1F"}

package/dist/commands/task/shared/tags.js

@@ -0,0 +1,177 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { fileExists } from "../../../cli/fs-utils.js";
+import { exitCodeForError } from "../../../cli/exit-codes.js";
+import { invalidValueMessage } from "../../../cli/output.js";
+import { CliError } from "../../../shared/errors.js";
+import { dedupeStrings } from "../../../shared/strings.js";
+import { isRecord } from "../../../shared/guards.js";
+async function listAgentIdsMemo(ctx) {
+    ctx.memo.agentIds ??= (async () => {
+        const agentsDir = path.join(ctx.resolvedProject.gitRoot, ctx.config.paths.agents_dir);
+        if (!(await fileExists(agentsDir)))
+            return [];
+        const entries = await readdir(agentsDir);
+        return entries
+            .filter((name) => name.endsWith(".json"))
+            .map((name) => name.slice(0, -".json".length))
+            .map((id) => id.trim())
+            .filter((id) => id.length > 0);
+    })();
+    return await ctx.memo.agentIds;
+}
+export function normalizeDependsOnInput(value) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === "[]")
+        return [];
+    return [trimmed];
+}
+const ALLOWED_TASK_STATUSES = new Set(["TODO", "DOING", "DONE", "BLOCKED"]);
+export function normalizeTaskStatus(value) {
+    const normalized = value.trim().toUpperCase();
+    if (!ALLOWED_TASK_STATUSES.has(normalized)) {
+        throw new CliError({
+            exitCode: 2,
+            code: "E_USAGE",
+            message: invalidValueMessage("status", value, `one of ${[...ALLOWED_TASK_STATUSES].join(", ")}`),
+        });
+    }
+    return normalized;
+}
+export function toStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim());
+}
+export function requiresVerify(tags, requiredTags) {
+    const required = new Set(requiredTags.map((tag) => tag.trim().toLowerCase()).filter(Boolean));
+    if (required.size === 0)
+        return false;
+    return tags.some((tag) => required.has(tag.trim().toLowerCase()));
+}
+function readStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}
+function readBoolean(value, fallback) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function readString(value, fallback) {
+    if (typeof value !== "string")
+        return fallback;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : fallback;
+}
+function configFromInput(input) {
+    return "config" in input ? input.config : input;
+}
+export function readTaskTagPolicy(input) {
+    const config = configFromInput(input);
+    const tasks = isRecord(config.tasks) ? config.tasks : {};
+    const rawTagsCandidate = tasks.tags;
+    const rawTags = isRecord(rawTagsCandidate) ? rawTagsCandidate : {};
+    const fallbackAllowlist = ["code", "data", "research", "docs", "ops", "product", "meta"];
+    const normalizedAllowlist = dedupeStrings(readStringArray(rawTags.primary_allowlist)
+        .map((tag) => tag.toLowerCase())
+        .filter(Boolean));
+    return {
+        primaryAllowlist: normalizedAllowlist.length > 0 ? normalizedAllowlist : fallbackAllowlist,
+        strictPrimary: readBoolean(rawTags.strict_primary, false),
+        fallbackPrimary: readString(rawTags.fallback_primary, "meta").toLowerCase(),
+        lockPrimaryOnUpdate: readBoolean(rawTags.lock_primary_on_update, true),
+    };
+}
+function readVerifyPrimaryPolicy(config) {
+    const tasks = isRecord(config.tasks) ? config.tasks : {};
+    const rawVerifyCandidate = tasks.verify;
+    const rawVerify = isRecord(rawVerifyCandidate)
+        ? rawVerifyCandidate
+        : {};
+    const explicitSteps = dedupeStrings(readStringArray(rawVerify.require_steps_for_primary)
+        .map((tag) => tag.toLowerCase())
+        .filter(Boolean));
+    const legacySteps = dedupeStrings(readStringArray(rawVerify.require_steps_for_tags ?? rawVerify.required_tags)
+        .map((tag) => tag.toLowerCase())
+        .filter(Boolean));
+    const requireStepsForPrimary = new Set(explicitSteps.length > 0 ? explicitSteps : legacySteps);
+    const explicitVerification = dedupeStrings(readStringArray(rawVerify.require_verification_for_primary)
+        .map((tag) => tag.toLowerCase())
+        .filter(Boolean));
+    const requireVerificationForPrimary = new Set(explicitVerification.length > 0 ? explicitVerification : [...requireStepsForPrimary.values()]);
+    return { requireStepsForPrimary, requireVerificationForPrimary };
+}
+export function resolvePrimaryTagFromConfig(tags, config) {
+    const policy = readTaskTagPolicy(config);
+    const allowlist = policy.primaryAllowlist;
+    if (allowlist.length === 0) {
+        throw new CliError({
+            exitCode: 3,
+            code: "E_VALIDATION",
+            message: "tasks.tags.primary_allowlist must contain at least one tag.",
+        });
+    }
+    const normalizedTags = dedupeStrings(tags.map((t) => t.trim().toLowerCase()).filter(Boolean));
+    const matched = normalizedTags.filter((tag) => allowlist.includes(tag));
+    if (matched.length > 1) {
+        throw new CliError({
+            exitCode: exitCodeForError("E_USAGE"),
+            code: "E_USAGE",
+            message: `Task must include exactly one primary tag from allowlist (${allowlist.join(", ")}); ` +
+                `found multiple: ${matched.join(", ")}`,
+        });
+    }
+    if (matched.length === 1) {
+        return { primary: matched[0], matched, usedFallback: false };
+    }
+    if (policy.strictPrimary) {
+        throw new CliError({
+            exitCode: exitCodeForError("E_USAGE"),
+            code: "E_USAGE",
+            message: `Task must include exactly one primary tag from allowlist (${allowlist.join(", ")}); ` +
+                "none found and strict_primary=true",
+        });
+    }
+    const fallback = policy.fallbackPrimary;
+    if (!fallback || !allowlist.includes(fallback)) {
+        throw new CliError({
+            exitCode: 3,
+            code: "E_VALIDATION",
+            message: `tasks.tags.fallback_primary=${JSON.stringify(policy.fallbackPrimary)} ` +
+                `must be present in tasks.tags.primary_allowlist (${allowlist.join(", ")}).`,
+        });
+    }
+    return { primary: fallback, matched, usedFallback: true };
+}
+export function requiresVerifyStepsByPrimary(tags, config) {
+    const primary = resolvePrimaryTagFromConfig(tags, config).primary;
+    return readVerifyPrimaryPolicy(config).requireStepsForPrimary.has(primary);
+}
+export function requiresVerificationByPrimary(tags, config) {
+    const primary = resolvePrimaryTagFromConfig(tags, config).primary;
+    return readVerifyPrimaryPolicy(config).requireVerificationForPrimary.has(primary);
+}
+export function resolvePrimaryTag(tags, ctx) {
+    return resolvePrimaryTagFromConfig(tags, ctx.config);
+}
+export async function warnIfUnknownOwner(ctx, owner) {
+    const trimmed = owner.trim();
+    if (!trimmed)
+        return;
+    const ids = await listAgentIdsMemo(ctx);
+    if (ids.length === 0)
+        return;
+    if (ids.includes(trimmed))
+        return;
+    throw new CliError({
+        exitCode: 3,
+        code: "E_VALIDATION",
+        message: `unknown task owner id: ${trimmed} (not found under ${ctx.config.paths.agents_dir}; ` +
+            `pick an existing agent id or create ${ctx.config.paths.agents_dir}/${trimmed}.json)`,
+    });
+}