agentplane 0.3.23 → 0.3.26

package/dist/commands/doctor/archive.js

@@ -1,212 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { execFileAsync } from "@agentplaneorg/core/process";
-import { gitEnv } from "@agentplaneorg/core/git";
-import { normalizeTaskStatus } from "@agentplaneorg/core/tasks";
-const DEFAULT_RECENT_DONE_TASK_LIMIT = 200;
-function pluralize(count, singular, plural = `${singular}s`) {
-    return count === 1 ? singular : plural;
-}
-function formatIdExamples(ids, maxExamples = 3) {
-    const shown = ids.slice(0, maxExamples);
-    const remainder = ids.length - shown.length;
-    return remainder > 0 ? `${shown.join(", ")}; +${remainder} more` : shown.join(", ");
-}
-function taskShortId(taskId) {
-    const shortId = taskId.split("-").at(-1) ?? taskId;
-    return shortId.trim().toUpperCase();
-}
-function textOrEmpty(value) {
-    return typeof value === "string" ? value.trim() : "";
-}
-function collectTaskEvidenceText(task) {
-    const chunks = [
-        textOrEmpty(task.title),
-        textOrEmpty(task.result_summary),
-        textOrEmpty(task.verification?.note),
-        textOrEmpty(task.commit?.message),
-        ...(Array.isArray(task.comments)
-            ? task.comments.map((entry) => textOrEmpty(entry?.body)).filter(Boolean)
-            : []),
-        ...(Array.isArray(task.tags) ? task.tags.filter((tag) => typeof tag === "string") : []),
-    ];
-    return chunks.filter(Boolean).join("\n");
-}
-function classifyUnknownHistoricalHash(task) {
-    void task;
-    return "INFO";
-}
-function classifyCloseCommitReference(task, subject) {
-    if (/\bclose:\s*record task doc\b/iu.test(subject)) {
-        return "INFO";
-    }
-    const evidence = collectTaskEvidenceText(task);
-    if (/(no-op|already implemented|already fixed|already present|without changes|task deemed not актуальна|obsolete|no changes)/iu.test(evidence)) {
-        return "INFO";
-    }
-    const subjectTaskId = /^\s*✅\s+([A-Z0-9]{6})\s+close:/u.exec(subject)?.[1] ?? "";
-    const currentTaskId = typeof task.id === "string" ? taskShortId(task.id) : "";
-    if (subjectTaskId && currentTaskId && subjectTaskId !== currentTaskId) {
-        return "INFO";
-    }
-    if (/\b(epic|roadmap|spike|meta)\b/iu.test(evidence)) {
-        return "INFO";
-    }
-    return "WARN";
-}
-function summarizeHistoricalFindings(findings, opts) {
-    if (findings.length === 0)
-        return [];
-    const prefix = `[${opts.severity}]`;
-    if (findings.length === 1) {
-        const [finding] = findings;
-        const subjectSuffix = opts.includeSubject && finding.subject ? ` (${finding.subject})` : "";
-        return [`${prefix} ${opts.singlePrefix}: ${finding.id} -> ${finding.hash}${subjectSuffix}`];
-    }
-    const grouped = new Map();
-    for (const finding of findings) {
-        const existing = grouped.get(finding.hash);
-        if (existing) {
-            existing.ids.push(finding.id);
-            if (!existing.subject && finding.subject)
-                existing.subject = finding.subject;
-            continue;
-        }
-        grouped.set(finding.hash, {
-            hash: finding.hash,
-            ids: [finding.id],
-            subject: finding.subject,
-        });
-    }
-    const groups = [...grouped.values()].toSorted((left, right) => {
-        const countDelta = right.ids.length - left.ids.length;
-        if (countDelta !== 0)
-            return countDelta;
-        return left.hash.localeCompare(right.hash);
-    });
-    const exampleGroups = groups.slice(0, 3).map((group) => {
-        const subjectSuffix = opts.includeSubject && group.subject ? `; subject: ${group.subject}` : "";
-        return `${group.hash} (${group.ids.length} ${pluralize(group.ids.length, "task")}: ${formatIdExamples(group.ids)}${subjectSuffix})`;
-    });
-    const remainingGroups = groups.length - exampleGroups.length;
-    const groupedSuffix = remainingGroups > 0 ? `; +${remainingGroups} more hash groups` : "";
-    return [
-        `${prefix} Historical task archive contains ${findings.length} DONE tasks with ${opts.summaryLabel} across ${groups.length} distinct commit ${opts.groupLabel}. Examples: ${exampleGroups.join("; ")}${groupedSuffix}`,
-    ];
-}
-export async function checkDoneTaskCommitInvariants(repoRoot, opts = {}) {
-    const tasksPath = path.join(repoRoot, ".agentplane", "tasks.json");
-    let raw = "";
-    try {
-        raw = await fs.readFile(tasksPath, "utf8");
-    }
-    catch {
-        return [];
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return [`Invalid JSON snapshot: ${path.relative(repoRoot, tasksPath)}`];
-    }
-    const all = Array.isArray(parsed.tasks) ? parsed.tasks : [];
-    const allDone = all.filter((t) => {
-        return normalizeTaskStatus(t.status) === "DONE";
-    });
-    const done = opts.fullArchive ? allDone : allDone.slice(-DEFAULT_RECENT_DONE_TASK_LIMIT);
-    if (done.length === 0)
-        return [];
-    const problems = [];
-    const unknownHashFindings = [];
-    const closeCommitWarnFindings = [];
-    const closeCommitInfoFindings = [];
-    const hashes = new Set();
-    for (const task of done) {
-        const id = typeof task.id === "string" ? task.id : "<unknown>";
-        const hash = typeof task.commit?.hash === "string" ? task.commit.hash.trim() : "";
-        if (!hash) {
-            problems.push(`DONE task is missing implementation commit hash: ${id} (finish with --commit <hash>).`);
-            continue;
-        }
-        hashes.add(hash);
-    }
-    if (hashes.size === 0)
-        return problems;
-    const subjectByHash = await resolveCommitSubjects(repoRoot, [...hashes]);
-    for (const task of done) {
-        const id = typeof task.id === "string" ? task.id : "<unknown>";
-        const hash = typeof task.commit?.hash === "string" ? task.commit.hash.trim() : "";
-        if (!hash)
-            continue;
-        const subject = subjectByHash.get(hash) ?? "";
-        if (!subject) {
-            unknownHashFindings.push({
-                id,
-                hash,
-                severity: classifyUnknownHistoricalHash(task),
-            });
-            continue;
-        }
-        if (/\bclose:/iu.test(subject)) {
-            const severity = classifyCloseCommitReference(task, subject);
-            const finding = { id, hash, subject, severity };
-            if (severity === "WARN")
-                closeCommitWarnFindings.push(finding);
-            else
-                closeCommitInfoFindings.push(finding);
-        }
-    }
-    problems.push(...summarizeHistoricalFindings(unknownHashFindings, {
-        singlePrefix: "DONE task references unknown historical commit hash",
-        groupLabel: "hashes",
-        summaryLabel: "unknown implementation commit hashes",
-        includeSubject: false,
-        severity: "INFO",
-    }), ...summarizeHistoricalFindings(closeCommitInfoFindings, {
-        singlePrefix: "DONE task implementation commit resolves to a historical close commit reference",
-        groupLabel: "hashes",
-        summaryLabel: "historical close-commit references that were classified as non-actionable archive records",
-        includeSubject: true,
-        severity: "INFO",
-    }), ...summarizeHistoricalFindings(closeCommitWarnFindings, {
-        singlePrefix: "DONE task implementation commit points to a close commit",
-        groupLabel: "hashes",
-        summaryLabel: "implementation commits that point to close commits",
-        includeSubject: true,
-        severity: "WARN",
-    }));
-    return problems;
-}
-async function resolveCommitSubjects(repoRoot, hashes) {
-    const subjectByHash = new Map();
-    if (hashes.length === 0)
-        return subjectByHash;
-    for (const chunk of chunked(hashes, 200)) {
-        try {
-            const { stdout } = await execFileAsync("git", ["show", "-s", "--no-patch", "--format=%H%x00%s%x00", "--ignore-missing", ...chunk], {
-                cwd: repoRoot,
-                env: gitEnv(),
-            });
-            const parts = String(stdout ?? "").split("\u0000");
-            for (let i = 0; i + 1 < parts.length; i += 2) {
-                const hash = parts[i]?.trim() ?? "";
-                const subject = parts[i + 1]?.trim() ?? "";
-                if (!hash)
-                    continue;
-                subjectByHash.set(hash, subject);
-            }
-        }
-        catch {
-            // Preserve old behavior: unknown/unreadable hashes are reported later as empty subject.
-        }
-    }
-    return subjectByHash;
-}
-function chunked(items, size) {
-    const chunks = [];
-    for (let i = 0; i < items.length; i += size) {
-        chunks.push(items.slice(i, i + size));
-    }
-    return chunks;
-}

package/dist/commands/doctor/branch-pr.d.ts

@@ -1,4 +0,0 @@
-import { type CommandContext } from "../shared/task-backend.js";
-export declare function checkBranchPrShippedTaskDrift(ctx?: CommandContext): Promise<string[]>;
-export declare function checkBranchPrDoneTaskOpenPrDrift(ctx?: CommandContext): Promise<string[]>;
-//# sourceMappingURL=branch-pr.d.ts.map

package/dist/commands/doctor/branch-pr.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"branch-pr.d.ts","sourceRoot":"","sources":["../../../src/commands/doctor/branch-pr.ts"],"names":[],"mappings":"AAKA,OAAO,EAA6B,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAM3F,wBAAsB,6BAA6B,CAAC,GAAG,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAyC3F;AAED,wBAAsB,gCAAgC,CAAC,GAAG,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAoC9F"}

package/dist/commands/doctor/branch-pr.js

@@ -1,99 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { renderDiagnosticFinding } from "../shared/diagnostics.js";
-import { backendUsesLocalTaskStore } from "../shared/task-backend.js";
-import { findDoneBranchPrTasksWithOpenPrArtifacts, findLocallyShippedBranchPrTasks, } from "../task/hosted-merge-sync.js";
-export async function checkBranchPrShippedTaskDrift(ctx) {
-    if (!ctx || !backendUsesLocalTaskStore(ctx) || ctx.config.workflow_mode !== "branch_pr") {
-        return [];
-    }
-    let tasks = [];
-    try {
-        tasks = await ctx.taskBackend.listTasks();
-    }
-    catch {
-        return [];
-    }
-    if (tasks.length === 0)
-        return [];
-    const matches = await findLocallyShippedBranchPrTasks({ ctx, tasks });
-    if (matches.length === 0)
-        return [];
-    const examples = matches
-        .slice(0, 5)
-        .map((entry) => `${entry.taskId}@${entry.base}:${entry.commitHash.slice(0, 12)} verified_via=${entry.verificationSource}`)
-        .join(", ");
-    return [
-        renderDiagnosticFinding({
-            severity: "WARN",
-            state: "branch_pr tasks appear shipped on the base branch but remain open",
-            likelyCause: "the verified task commit already landed on the base branch, but canonical task closure artifacts were never reconciled",
-            nextAction: {
-                command: "agentplane task normalize --sync-branch-pr-state",
-                reason: "mark locally shipped branch_pr tasks as DONE in the task projection before committing the reconciled task artifacts on the base branch",
-            },
-            details: [
-                `Affected tasks: ${matches.length}`,
-                examples ? `Examples: ${examples}` : "Examples unavailable.",
-            ],
-        }),
-    ];
-}
-export async function checkBranchPrDoneTaskOpenPrDrift(ctx) {
-    if (!ctx || !backendUsesLocalTaskStore(ctx) || ctx.config.workflow_mode !== "branch_pr") {
-        return [];
-    }
-    const tasks = await readDoneTaskSnapshot(ctx);
-    if (tasks.length === 0)
-        return [];
-    const matches = await findDoneBranchPrTasksWithOpenPrArtifacts({ ctx, tasks });
-    if (matches.length === 0)
-        return [];
-    const examples = matches
-        .slice(0, 5)
-        .map((entry) => `${entry.taskId}@${entry.base}:${entry.commitHash.slice(0, 12)} branch=${entry.branch}`)
-        .join(", ");
-    return [
-        renderDiagnosticFinding({
-            severity: "WARN",
-            state: "DONE branch_pr tasks still have open or unmerged PR artifacts",
-            likelyCause: "the task was marked DONE, but its branch_pr PR artifacts were never reconciled to MERGED and the task branch still exists",
-            nextAction: {
-                command: "agentplane task normalize --sync-branch-pr-state --task-id <task-id>",
-                reason: "reconcile the shipped task's local branch_pr state and PR artifacts to MERGED without scanning unrelated task history",
-            },
-            details: [
-                `Affected tasks: ${matches.length}`,
-                examples ? `Examples: ${examples}` : "Examples unavailable.",
-            ],
-        }),
-    ];
-}
-async function readDoneTaskSnapshot(ctx) {
-    try {
-        const tasks = await ctx.taskBackend.listTasks();
-        if (tasks.length > 0) {
-            return tasks;
-        }
-    }
-    catch {
-        // Fall back to the legacy export snapshot when the live backend read is unavailable.
-    }
-    const tasksJsonPath = path.join(ctx.resolvedProject.agentplaneDir, "tasks.json");
-    try {
-        const raw = await readFile(tasksJsonPath, "utf8");
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed.tasks))
-            return [];
-        return parsed.tasks.filter((task) => isTaskDataLike(task));
-    }
-    catch {
-        return [];
-    }
-}
-function isTaskDataLike(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const record = value;
-    return typeof record.id === "string" && typeof record.status === "string";
-}

package/dist/commands/doctor/fixes.d.ts

@@ -1,9 +0,0 @@
-export declare function safeFixGitignore(repoRoot: string): Promise<{
-    changed: boolean;
-    note: string;
-}>;
-export declare function safeFixTaskIndex(repoRoot: string): Promise<{
-    changed: boolean;
-    note: string;
-}>;
-//# sourceMappingURL=fixes.d.ts.map

package/dist/commands/doctor/fixes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fixes.d.ts","sourceRoot":"","sources":["../../../src/commands/doctor/fixes.ts"],"names":[],"mappings":"AAMA,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAyB7C;AAED,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAQ7C"}

package/dist/commands/doctor/fixes.js

@@ -1,40 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { RUNTIME_GITIGNORE_LINES } from "../../runtime/shared/runtime-artifacts.js";
-import { loadCommandContext } from "../shared/task-backend.js";
-export async function safeFixGitignore(repoRoot) {
-    const gitignorePath = path.join(repoRoot, ".gitignore");
-    let existing = "";
-    try {
-        existing = await fs.readFile(gitignorePath, "utf8");
-    }
-    catch {
-        return { changed: false, note: "Skip: .gitignore not found." };
-    }
-    const lines = existing.split(/\r?\n/);
-    const existingSet = new Set(lines.map((line) => line.trimEnd()));
-    const missing = RUNTIME_GITIGNORE_LINES.filter((line) => !existingSet.has(line));
-    if (missing.length === 0) {
-        return { changed: false, note: "OK: .gitignore already contains agentplane runtime ignores." };
-    }
-    const nextLines = [...lines];
-    if (nextLines.length > 0 && nextLines.at(-1) !== "")
-        nextLines.push("");
-    nextLines.push(...missing, "");
-    const next = `${nextLines.join("\n")}`.replaceAll(/\n{2,}$/g, "\n");
-    await fs.writeFile(gitignorePath, next, "utf8");
-    return {
-        changed: true,
-        note: `Fixed: added agentplane runtime ignores to .gitignore (${missing.length} lines).`,
-    };
-}
-export async function safeFixTaskIndex(repoRoot) {
-    try {
-        const ctx = await loadCommandContext({ cwd: repoRoot, rootOverride: null });
-        await ctx.taskBackend.listTasks();
-        return { changed: true, note: "OK: rebuilt tasks index cache (best-effort)." };
-    }
-    catch {
-        return { changed: false, note: "Skip: could not rebuild tasks index cache." };
-    }
-}

package/dist/commands/doctor/hook-readiness.d.ts

@@ -1,2 +0,0 @@
-export declare function checkManagedHookShimReadiness(repoRoot: string): Promise<string[]>;
-//# sourceMappingURL=hook-readiness.d.ts.map

package/dist/commands/doctor/hook-readiness.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hook-readiness.d.ts","sourceRoot":"","sources":["../../../src/commands/doctor/hook-readiness.ts"],"names":[],"mappings":"AA4EA,wBAAsB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAyIvF"}

package/dist/commands/doctor/hook-readiness.js

@@ -1,171 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { renderDiagnosticFinding } from "../shared/diagnostics.js";
-import { fileIsManaged, HOOK_MARKER, HOOK_NAMES, resolveGitHooksDir, SHIM_MARKER, } from "../hooks/shared.js";
-async function pathExists(absPath) {
-    try {
-        await fs.access(absPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function readTextIfExists(absPath) {
-    try {
-        return await fs.readFile(absPath, "utf8");
-    }
-    catch {
-        return null;
-    }
-}
-function unquoteShellSingleQuoted(value) {
-    return value.replaceAll(String.raw `'\''`, "'");
-}
-function extractInstallBinFromShim(shimText) {
-    const match = /\nINSTALL_BIN='((?:'\\''|[^'])*)'/.exec(shimText);
-    if (!match)
-        return null;
-    return unquoteShellSingleQuoted(match[1] ?? "").trim() || null;
-}
-async function resolveManagedHookNames(repoRoot) {
-    let hooksDir;
-    try {
-        hooksDir = await resolveGitHooksDir(repoRoot);
-    }
-    catch {
-        return { hooksDir: null, managedHooks: [], unmanagedHooks: [] };
-    }
-    const managedHooks = [];
-    const unmanagedHooks = [];
-    for (const hook of HOOK_NAMES) {
-        const hookPath = path.join(hooksDir, hook);
-        if (!(await pathExists(hookPath)))
-            continue;
-        if (await fileIsManaged(hookPath, HOOK_MARKER))
-            managedHooks.push(hook);
-        else
-            unmanagedHooks.push(hook);
-    }
-    return { hooksDir, managedHooks, unmanagedHooks };
-}
-function renderUnmanagedHooksFinding(unmanagedHooks) {
-    return renderDiagnosticFinding({
-        severity: "INFO",
-        state: "unmanaged git hooks are present and will not be overwritten by AgentPlane",
-        likelyCause: "the repository has custom hook files outside the AgentPlane managed hook set",
-        nextAction: {
-            command: "agentplane hooks install",
-            reason: "refresh managed hooks only after manually reconciling custom hook files that should remain custom",
-        },
-        details: [`Unmanaged hooks: ${unmanagedHooks.join(", ")}`],
-    });
-}
-export async function checkManagedHookShimReadiness(repoRoot) {
-    const findings = [];
-    const { managedHooks, unmanagedHooks } = await resolveManagedHookNames(repoRoot);
-    const shimRelPath = ".agentplane/bin/agentplane";
-    const shimPath = path.join(repoRoot, shimRelPath);
-    const shimText = await readTextIfExists(shimPath);
-    const managedShim = shimText?.includes(SHIM_MARKER) === true;
-    if (managedHooks.length === 0 && unmanagedHooks.length === 0 && !shimText)
-        return findings;
-    if (managedHooks.length > 0 && !shimText) {
-        findings.push(renderDiagnosticFinding({
-            severity: "WARN",
-            state: "managed git hooks are installed but the AgentPlane hook shim is missing",
-            likelyCause: "the repository hook files still call .agentplane/bin/agentplane, but that shim was deleted or never committed",
-            nextAction: {
-                command: "agentplane hooks install",
-                reason: "recreate the managed hook shim and refresh hook files",
-            },
-            details: [`Managed hooks: ${managedHooks.join(", ")}`],
-        }));
-        return findings;
-    }
-    if (shimText && !managedShim) {
-        findings.push(renderDiagnosticFinding({
-            severity: "WARN",
-            state: "AgentPlane hook shim path exists but is not managed by AgentPlane",
-            likelyCause: "a custom .agentplane/bin/agentplane file is shadowing the managed hook runner shim",
-            nextAction: {
-                command: "inspect .agentplane/bin/agentplane, remove the custom file if unintended, then run agentplane hooks install",
-                reason: "restore the managed shim without overwriting custom executable content silently",
-            },
-            details: [`Shim path: ${shimRelPath}`],
-        }));
-        return findings;
-    }
-    if (!shimText) {
-        if (unmanagedHooks.length > 0) {
-            findings.push(renderUnmanagedHooksFinding(unmanagedHooks));
-        }
-        return findings;
-    }
-    const installedBin = extractInstallBinFromShim(shimText);
-    if (!installedBin) {
-        findings.push(renderDiagnosticFinding({
-            severity: "WARN",
-            state: "managed AgentPlane hook shim uses a stale format without an installed runner fallback",
-            likelyCause: "the shim was generated by an older AgentPlane release before installed-binary fallback was embedded",
-            nextAction: {
-                command: "agentplane hooks install",
-                reason: "rewrite the managed shim with the current installed-runtime fallback contract",
-            },
-            details: [`Shim path: ${shimRelPath}`],
-        }));
-    }
-    else if (!(await pathExists(installedBin))) {
-        findings.push(renderDiagnosticFinding({
-            severity: "WARN",
-            state: "managed AgentPlane hook shim points to a missing installed runner",
-            likelyCause: "AgentPlane was reinstalled, removed, or moved after hooks were installed in this repository",
-            nextAction: {
-                command: "agentplane hooks install",
-                reason: "refresh the embedded installed runner path after reinstalling or updating AgentPlane",
-            },
-            details: [`Embedded runner: ${installedBin}`, `Shim path: ${shimRelPath}`],
-        }));
-    }
-    const hasEnvFallback = shimText.includes("AGENTPLANE_HOOK_RUNNER");
-    const hasNpxFallback = shimText.includes("AGENTPLANE_HOOK_ALLOW_NPX");
-    if (!hasEnvFallback || !hasNpxFallback) {
-        findings.push(renderDiagnosticFinding({
-            severity: "WARN",
-            state: "managed AgentPlane hook shim is missing current fallback branches",
-            likelyCause: "the repository still has an older managed shim that cannot use env-runner or explicit npx fallback recovery",
-            nextAction: {
-                command: "agentplane hooks install",
-                reason: "rewrite the shim with the current fallback chain",
-            },
-            details: [
-                `Shim path: ${shimRelPath}`,
-                `AGENTPLANE_HOOK_RUNNER fallback: ${hasEnvFallback ? "present" : "missing"}`,
-                `AGENTPLANE_HOOK_ALLOW_NPX fallback: ${hasNpxFallback ? "present" : "missing"}`,
-            ],
-        }));
-    }
-    if (managedHooks.includes("pre-push")) {
-        const repoPrePushScript = path.join(repoRoot, "scripts", "run-pre-push-hook.mjs");
-        const packageJsonText = await readTextIfExists(path.join(repoRoot, "package.json"));
-        if (!(await pathExists(repoPrePushScript)) && packageJsonText) {
-            findings.push(renderDiagnosticFinding({
-                severity: "INFO",
-                state: "managed pre-push hook will use installed clean-project fallback checks",
-                likelyCause: "this project does not ship a repository-local scripts/run-pre-push-hook.mjs",
-                nextAction: {
-                    command: "add project-local package scripts such as format:check or test, or keep the installed fallback",
-                    reason: "make pre-push behavior explicit when the project needs stricter repository-specific checks",
-                },
-                details: [
-                    "Missing repository script: scripts/run-pre-push-hook.mjs",
-                    "Installed fallback skips package scripts that are not declared by the clean project.",
-                ],
-            }));
-        }
-    }
-    if (unmanagedHooks.length > 0) {
-        findings.push(renderUnmanagedHooksFinding(unmanagedHooks));
-    }
-    return findings;
-}

package/dist/commands/doctor/layering.d.ts

@@ -1,2 +0,0 @@
-export declare function checkLayering(repoRoot: string): Promise<string[]>;
-//# sourceMappingURL=layering.d.ts.map

package/dist/commands/doctor/layering.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layering.d.ts","sourceRoot":"","sources":["../../../src/commands/doctor/layering.ts"],"names":[],"mappings":"AA6CA,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAmDvE"}

package/dist/commands/doctor/layering.js

@@ -1,87 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-async function listTsFiles(rootDir) {
-    const out = [];
-    async function walk(absDir) {
-        const entries = await fs.readdir(absDir, { withFileTypes: true });
-        for (const ent of entries) {
-            if (ent.name.startsWith("."))
-                continue;
-            if (ent.name === "__snapshots__")
-                continue;
-            if (ent.name === "node_modules")
-                continue;
-            const abs = path.join(absDir, ent.name);
-            if (ent.isDirectory()) {
-                await walk(abs);
-                continue;
-            }
-            if (ent.isFile() && ent.name.endsWith(".ts")) {
-                out.push({ absPath: abs, relPath: path.relative(rootDir, abs) });
-            }
-        }
-    }
-    await walk(rootDir);
-    return out;
-}
-function extractImports(source) {
-    const imports = [];
-    const re = /^\s*import\s+(?:type\s+)?(?:[^"']*?\s+from\s+)?["']([^"']+)["']\s*;?/gm;
-    for (const match of source.matchAll(re)) {
-        imports.push(match[1] ?? "");
-    }
-    return imports.filter(Boolean);
-}
-async function isDirectory(absPath) {
-    try {
-        const st = await fs.stat(absPath);
-        return st.isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-export async function checkLayering(repoRoot) {
-    const problems = [];
-    const agentplaneSrcRoot = path.join(repoRoot, "packages", "agentplane", "src");
-    if (!(await isDirectory(agentplaneSrcRoot))) {
-        problems.push("Dev source checks requested but packages/agentplane/src was not found in this workspace.");
-        return problems;
-    }
-    const cliRoot = path.join(agentplaneSrcRoot, "cli");
-    const cliFiles = await listTsFiles(cliRoot);
-    for (const f of cliFiles) {
-        const src = await fs.readFile(f.absPath, "utf8");
-        const imports = extractImports(src);
-        const hits = imports.filter((s) => s.includes("/adapters/") ||
-            s.includes("../adapters") ||
-            s.includes("../../adapters") ||
-            s.includes("../../../adapters"));
-        if (hits.length > 0) {
-            problems.push(`${f.relPath} imports adapters directly: ${hits.join(", ")}`);
-        }
-    }
-    const roots = [path.join(agentplaneSrcRoot, "usecases"), path.join(agentplaneSrcRoot, "ports")];
-    const banned = [
-        "node:fs",
-        "node:fs/promises",
-        "fs",
-        "fs/promises",
-        "node:path",
-        "path",
-        "simple-git",
-        "isomorphic-git",
-    ];
-    for (const root of roots) {
-        const files = await listTsFiles(root);
-        for (const f of files) {
-            const src = await fs.readFile(f.absPath, "utf8");
-            const imports = extractImports(src);
-            const hits = imports.filter((s) => banned.some((b) => s === b || s.startsWith(`${b}/`)));
-            if (hits.length > 0) {
-                problems.push(`${f.relPath} imports banned modules: ${hits.join(", ")}`);
-            }
-        }
-    }
-    return problems;
-}

package/dist/commands/doctor/runtime.d.ts

@@ -1,4 +0,0 @@
-import type { AgentplaneConfig } from "@agentplaneorg/core/config";
-export declare function checkRuntimeSourceFacts(cwd: string, config?: AgentplaneConfig): string[];
-export declare function findingSeverity(problem: string): "ERROR" | "WARN" | "INFO";
-//# sourceMappingURL=runtime.d.ts.map

package/dist/commands/doctor/runtime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/commands/doctor/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAyBnE,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,MAAM,EAAE,CA+BxF;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAM1E"}