agentweaver 0.1.11 → 0.1.13

package/dist/doctor/checks/flow-readiness.js

@@ -0,0 +1,305 @@
+import { existsSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { DoctorStatus } from "../types.js";
+import { CATEGORY } from "./category.js";
+import { BUILT_IN_COMMAND_FLOW_IDS } from "../../pipeline/flow-catalog.js";
+import { validateStructuredArtifact } from "../../structured-artifacts.js";
+import { designJsonFile, planJsonFile, scopeArtifactsDir } from "../../artifacts.js";
+const GO_BINARY_PATTERNS = ["go", "go.exe"];
+const GIT_BINARY_PATTERNS = ["git", "git.exe"];
+function findBinary(name) {
+    const envPath = process.env.PATH ?? "";
+    const pathDirs = envPath.split(path.delimiter);
+    for (const dir of pathDirs) {
+        for (const pattern of name === "go" ? GO_BINARY_PATTERNS : GIT_BINARY_PATTERNS) {
+            const fullPath = path.join(dir, pattern);
+            if (existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+    }
+    return null;
+}
+function checkBinaryPresence(flowId) {
+    const goFlows = new Set([
+        "run-go-tests-loop",
+        "run-go-linter-loop",
+        "auto-golang",
+    ]);
+    const gitFlows = new Set(["git-commit", "gitlab-review", "gitlab-diff-review", "mr-description"]);
+    if (goFlows.has(flowId)) {
+        return findBinary("go");
+    }
+    if (gitFlows.has(flowId)) {
+        return findBinary("git");
+    }
+    return null;
+}
+function isJiraConfigured() {
+    return !!(process.env.JIRA_API_KEY && process.env.JIRA_BASE_URL);
+}
+function isGitLabConfigured() {
+    return !!process.env.GITLAB_TOKEN;
+}
+function getLatestDesignIteration(scopeKey) {
+    const artifactsDir = scopeArtifactsDir(scopeKey);
+    if (!existsSync(artifactsDir)) {
+        return null;
+    }
+    const files = readdirSync(artifactsDir);
+    const designFiles = files.filter((f) => /^design-.*-\d+\.json$/.test(f));
+    if (designFiles.length === 0) {
+        return null;
+    }
+    const iterations = designFiles.map((f) => {
+        const match = f.match(/^design-.*-(\d+)\.json$/);
+        return match?.[1] ? parseInt(match[1], 10) : 0;
+    });
+    return Math.max(...iterations);
+}
+function getLatestPlanIteration(scopeKey) {
+    const artifactsDir = scopeArtifactsDir(scopeKey);
+    if (!existsSync(artifactsDir)) {
+        return null;
+    }
+    const files = readdirSync(artifactsDir);
+    const planFiles = files.filter((f) => /^plan-.*-\d+\.json$/.test(f));
+    if (planFiles.length === 0) {
+        return null;
+    }
+    const iterations = planFiles.map((f) => {
+        const match = f.match(/^plan-.*-(\d+)\.json$/);
+        return match?.[1] ? parseInt(match[1], 10) : 0;
+    });
+    return Math.max(...iterations);
+}
+function checkImplementFlowReadiness(scopeKey) {
+    const blockers = [];
+    const latestDesignIteration = getLatestDesignIteration(scopeKey);
+    const latestPlanIteration = getLatestPlanIteration(scopeKey);
+    if (latestDesignIteration === null) {
+        blockers.push("design artifact not found");
+    }
+    else {
+        const designPath = designJsonFile(scopeKey, latestDesignIteration);
+        if (!existsSync(designPath)) {
+            blockers.push(`design artifact not found at ${designPath}`);
+        }
+        else {
+            try {
+                validateStructuredArtifact(designPath, "implementation-design/v1");
+            }
+            catch (error) {
+                blockers.push(`design artifact schema invalid: ${error.message}`);
+            }
+        }
+    }
+    if (latestPlanIteration === null) {
+        blockers.push("plan artifact not found");
+    }
+    else {
+        const planPath = planJsonFile(scopeKey, latestPlanIteration);
+        if (!existsSync(planPath)) {
+            blockers.push(`plan artifact not found at ${planPath}`);
+        }
+        else {
+            try {
+                validateStructuredArtifact(planPath, "implementation-plan/v1");
+            }
+            catch (error) {
+                blockers.push(`plan artifact schema invalid: ${error.message}`);
+            }
+        }
+    }
+    return {
+        flowId: "implement",
+        status: blockers.length === 0 ? "ready" : "not_ready",
+        blockers,
+    };
+}
+function checkReviewProjectFlowReadiness(scopeKey) {
+    const blockers = [];
+    const latestDesignIteration = getLatestDesignIteration(scopeKey);
+    if (latestDesignIteration === null) {
+        blockers.push("design artifact not found");
+    }
+    else {
+        const designPath = designJsonFile(scopeKey, latestDesignIteration);
+        if (!existsSync(designPath)) {
+            blockers.push(`design artifact not found at ${designPath}`);
+        }
+    }
+    return {
+        flowId: "review",
+        mode: "project",
+        status: blockers.length === 0 ? "ready" : "not_ready",
+        blockers,
+    };
+}
+function checkReviewJiraFlowReadiness(scopeKey) {
+    const blockers = [];
+    if (!isJiraConfigured()) {
+        blockers.push("Jira not configured (JIRA_API_KEY or JIRA_BASE_URL missing)");
+    }
+    const latestDesignIteration = getLatestDesignIteration(scopeKey);
+    if (latestDesignIteration === null) {
+        blockers.push("design artifact not found");
+    }
+    else {
+        const designPath = designJsonFile(scopeKey, latestDesignIteration);
+        if (!existsSync(designPath)) {
+            blockers.push(`design artifact not found at ${designPath}`);
+        }
+    }
+    const latestPlanIteration = getLatestPlanIteration(scopeKey);
+    if (latestPlanIteration === null) {
+        blockers.push("plan artifact not found");
+    }
+    else {
+        const planPath = planJsonFile(scopeKey, latestPlanIteration);
+        if (!existsSync(planPath)) {
+            blockers.push(`plan artifact not found at ${planPath}`);
+        }
+    }
+    return {
+        flowId: "review",
+        mode: "jira",
+        status: blockers.length === 0 ? "ready" : "not_ready",
+        blockers,
+    };
+}
+function checkPlanJiraFlowReadiness(scopeKey) {
+    const blockers = [];
+    if (!isJiraConfigured()) {
+        blockers.push("Jira not configured (JIRA_API_KEY or JIRA_BASE_URL missing)");
+    }
+    if (!process.env.JIRA_ISSUE_KEY && !scopeKey.includes("@")) {
+        blockers.push("Jira issue key not available");
+    }
+    return {
+        flowId: "plan",
+        mode: "jira",
+        status: blockers.length === 0 ? "ready" : "not_ready",
+        blockers,
+    };
+}
+function checkPlanProjectFlowReadiness(scopeKey) {
+    const blockers = [];
+    const latestDesignIteration = getLatestDesignIteration(scopeKey);
+    if (latestDesignIteration === null) {
+        blockers.push("design artifact not found (task-describe output required)");
+    }
+    else {
+        const designPath = designJsonFile(scopeKey, latestDesignIteration);
+        if (!existsSync(designPath)) {
+            blockers.push("design artifact not found");
+        }
+    }
+    return {
+        flowId: "plan",
+        mode: "project",
+        status: blockers.length === 0 ? "ready" : "not_ready",
+        blockers,
+    };
+}
+function checkGenericFlowReadiness(flowId, scopeKey) {
+    const blockers = [];
+    const binaryPath = checkBinaryPresence(flowId);
+    if (binaryPath === null) {
+        const requiredBinaries = {
+            "run-go-tests-loop": "go",
+            "run-go-linter-loop": "go",
+            "auto-golang": "go",
+            "git_commit": "git",
+            "gitlab-review": "git",
+            "gitlab-diff-review": "git",
+            "mr-description": "git",
+        };
+        const required = requiredBinaries[flowId];
+        if (required) {
+            blockers.push(`${required} binary not found in PATH`);
+        }
+    }
+    const jiraFlows = new Set(["gitlab-review", "gitlab-diff-review", "mr-description"]);
+    if (jiraFlows.has(flowId) && isGitLabConfigured()) {
+        // GitLab configured - could add connectivity check here
+    }
+    return {
+        flowId,
+        status: blockers.length === 0 ? "ready" : "not_ready",
+        blockers,
+    };
+}
+function determineFlowReadiness(flowId, scopeKey) {
+    if (flowId === "implement") {
+        return [checkImplementFlowReadiness(scopeKey)];
+    }
+    if (flowId === "review") {
+        return [
+            checkReviewProjectFlowReadiness(scopeKey),
+            checkReviewJiraFlowReadiness(scopeKey),
+        ];
+    }
+    if (flowId === "plan") {
+        return [
+            checkPlanJiraFlowReadiness(scopeKey),
+            checkPlanProjectFlowReadiness(scopeKey),
+        ];
+    }
+    return [checkGenericFlowReadiness(flowId, scopeKey)];
+}
+function getScopeKey() {
+    const cwd = process.cwd();
+    const scopesRoot = path.join(cwd, ".agentweaver", "scopes");
+    if (!existsSync(scopesRoot)) {
+        return "unknown";
+    }
+    const entries = readdirSync(scopesRoot);
+    if (entries.length === 0) {
+        return "unknown";
+    }
+    return entries[0];
+}
+function performFlowReadinessCheck() {
+    const scopeKey = getScopeKey();
+    const allEntries = [];
+    for (const flowId of BUILT_IN_COMMAND_FLOW_IDS) {
+        const entries = determineFlowReadiness(flowId, scopeKey);
+        allEntries.push(...entries);
+    }
+    const readyCount = allEntries.filter((e) => e.status === "ready").length;
+    const notReadyCount = allEntries.filter((e) => e.status === "not_ready").length;
+    const notConfiguredCount = allEntries.filter((e) => e.status === "not_configured").length;
+    const lines = [];
+    for (const entry of allEntries) {
+        const modeStr = entry.mode ? `:${entry.mode}` : "";
+        const statusStr = entry.status === "ready" ? "✓ ready" : entry.status === "not_configured" ? "⚠ not configured" : "✗ not ready";
+        lines.push(`  ${entry.flowId}${modeStr}: ${statusStr}`);
+        for (const blocker of entry.blockers) {
+            lines.push(`    - ${blocker}`);
+        }
+    }
+    const overallStatus = notReadyCount > 0 ? DoctorStatus.Fail : notConfiguredCount > 0 ? DoctorStatus.Warn : DoctorStatus.Ok;
+    const message = `${readyCount} flows ready, ${notReadyCount} not ready, ${notConfiguredCount} not configured`;
+    return {
+        status: overallStatus,
+        message,
+        details: lines.join("\n"),
+    };
+}
+export const flowReadinessCheck = {
+    id: "flow-readiness-01",
+    category: CATEGORY.FLOW_READINESS,
+    title: "flow-readiness",
+    dependencies: ["env-diagnostics-01", "cwd-context-01"],
+    execute: async () => {
+        const result = performFlowReadinessCheck();
+        return {
+            id: "flow-readiness-01",
+            status: result.status,
+            title: "flow-readiness",
+            message: result.message,
+            details: result.details,
+        };
+    },
+};

package/dist/doctor/checks/node-version.js

@@ -0,0 +1,79 @@
+import { readFileSync, existsSync } from "node:fs";
+import path from "node:path";
+import semver from "semver";
+import { DoctorStatus } from "../types.js";
+import { CATEGORY } from "./category.js";
+const PACKAGE_ROOT = process.cwd();
+export const nodeVersionCheck = {
+    id: "node-version-01",
+    category: CATEGORY.NODE_VERSION,
+    title: "node-version",
+    dependencies: ["system-01"],
+    execute: async () => {
+        const packageJsonPath = path.join(PACKAGE_ROOT, "package.json");
+        if (!existsSync(packageJsonPath)) {
+            return {
+                id: "node-version-01",
+                status: DoctorStatus.Warn,
+                title: "node-version",
+                message: "package.json not found in project root",
+                hint: "Cannot verify Node.js compatibility without package.json",
+            };
+        }
+        let enginesNode;
+        try {
+            const raw = readFileSync(packageJsonPath, "utf8");
+            const pkg = JSON.parse(raw);
+            if (!pkg.engines?.node) {
+                return {
+                    id: "node-version-01",
+                    status: DoctorStatus.Warn,
+                    title: "node-version",
+                    message: "engines.node not specified in package.json",
+                    hint: "Consider adding engines.node requirement to package.json",
+                };
+            }
+            enginesNode = pkg.engines.node;
+        }
+        catch {
+            return {
+                id: "node-version-01",
+                status: DoctorStatus.Warn,
+                title: "node-version",
+                message: "Failed to read package.json",
+                hint: "Ensure package.json is valid JSON",
+            };
+        }
+        const currentVersion = process.version.slice(1);
+        const validRange = semver.validRange(enginesNode);
+        if (!validRange) {
+            return {
+                id: "node-version-01",
+                status: DoctorStatus.Warn,
+                title: "node-version",
+                message: `Invalid semver range in engines.node: ${enginesNode}`,
+                hint: "Ensure engines.node contains a valid semver range",
+            };
+        }
+        const satisfied = semver.satisfies(currentVersion, validRange);
+        if (satisfied) {
+            return {
+                id: "node-version-01",
+                status: DoctorStatus.Ok,
+                title: "node-version",
+                message: `Compatible: ${currentVersion} satisfies ${enginesNode}`,
+                details: `engine requirement: ${enginesNode}, current: ${currentVersion}`,
+            };
+        }
+        else {
+            return {
+                id: "node-version-01",
+                status: DoctorStatus.Warn,
+                title: "node-version",
+                message: `Incompatible: ${currentVersion} does not satisfy ${enginesNode}`,
+                hint: "Consider using a Node.js version that matches the engines.node requirement",
+                details: `engine requirement: ${enginesNode}, current: ${currentVersion}`,
+            };
+        }
+    },
+};

package/dist/doctor/checks/register.js

@@ -0,0 +1,18 @@
+import { REGISTRY } from "../registry.js";
+import { systemChecks } from "./system.js";
+import { nodeVersionCheck } from "./node-version.js";
+import { agentweaverHomeCheck } from "./agentweaver-home.js";
+import { cwdContextCheck } from "./cwd-context.js";
+import { codexExecutorCheck, opencodeExecutorCheck } from "./executors.js";
+import { envDiagnosticsCheck } from "./env-diagnostics.js";
+import { flowReadinessCheck } from "./flow-readiness.js";
+REGISTRY.register(nodeVersionCheck);
+for (const check of systemChecks) {
+    REGISTRY.register(check);
+}
+REGISTRY.register(agentweaverHomeCheck);
+REGISTRY.register(cwdContextCheck);
+REGISTRY.register(codexExecutorCheck);
+REGISTRY.register(opencodeExecutorCheck);
+REGISTRY.register(envDiagnosticsCheck);
+REGISTRY.register(flowReadinessCheck);

package/dist/doctor/checks/system.js

@@ -0,0 +1,91 @@
+import { spawnSync } from "node:child_process";
+import { DoctorStatus } from "../types.js";
+import { CATEGORY } from "./category.js";
+import { resolveCmd } from "../../runtime/command-resolution.js";
+const BINARY_CHECKS = [
+    {
+        id: "system-01",
+        title: "node",
+        command: "node",
+        versionArgs: ["--version"],
+        versionEnvVar: "",
+        parseVersion: (stdout) => stdout.trim(),
+    },
+    {
+        id: "system-02",
+        title: "npm",
+        command: "npm",
+        versionArgs: ["--version"],
+        versionEnvVar: "",
+        parseVersion: (stdout) => stdout.trim(),
+    },
+    {
+        id: "system-03",
+        title: "git",
+        command: "git",
+        versionArgs: ["--version"],
+        versionEnvVar: "",
+        parseVersion: (stdout) => stdout.trim(),
+    },
+    {
+        id: "system-04",
+        title: "bash",
+        command: "bash",
+        versionArgs: ["--version"],
+        versionEnvVar: "",
+        parseVersion: (stdout) => (stdout.split("\n")[0] ?? stdout).trim(),
+    },
+];
+function runVersionCheck(spec) {
+    let cmdPath;
+    try {
+        cmdPath = resolveCmd(spec.command, "");
+    }
+    catch {
+        return {
+            status: DoctorStatus.Fail,
+            message: `${spec.title} binary not found`,
+            hint: `Install ${spec.title} or ensure it is available in PATH`,
+        };
+    }
+    const result = spawnSync(cmdPath, spec.versionArgs, { encoding: "utf8", stdio: "pipe" });
+    if (result.status !== 0 || !result.stdout) {
+        return {
+            status: DoctorStatus.Fail,
+            message: `Failed to get ${spec.title} version`,
+            hint: `${spec.title} --version did not return expected output`,
+        };
+    }
+    const stdout = result.stdout;
+    const version = spec.parseVersion(stdout);
+    const okResult = {
+        status: DoctorStatus.Ok,
+        message: version,
+    };
+    if (spec.title === "node") {
+        okResult.details = `process.version: ${process.version}`;
+    }
+    return okResult;
+}
+export const systemChecks = BINARY_CHECKS.map((spec) => ({
+    id: spec.id,
+    category: CATEGORY.SYSTEM,
+    title: spec.title,
+    dependencies: [],
+    execute: async () => {
+        const result = runVersionCheck(spec);
+        const checkResult = {
+            id: spec.id,
+            status: result.status,
+            title: spec.title,
+            message: result.message,
+        };
+        if (result.hint) {
+            checkResult.hint = result.hint;
+        }
+        if (result.details) {
+            checkResult.details = result.details;
+        }
+        return checkResult;
+    },
+}));

package/dist/doctor/index.js

@@ -0,0 +1,4 @@
+export { DoctorStatus, ReadinessStatus } from "./types.js";
+export { CheckRegistry, REGISTRY } from "./registry.js";
+export { DoctorOrchestrator } from "./orchestrator.js";
+export { runDoctorCommand } from "./runner.js";

package/dist/doctor/orchestrator.js

@@ -0,0 +1,78 @@
+import { DoctorStatus, ReadinessStatus } from "./types.js";
+import { REGISTRY } from "./registry.js";
+import { SOFT_CHECK_IDS } from "./checks/cwd-context.js";
+class DoctorOrchestrator {
+    async run(checks, filter) {
+        let checksToRun;
+        if (checks) {
+            checksToRun = checks;
+        }
+        else if (filter) {
+            const byCategory = REGISTRY.getByCategory(filter);
+            if (byCategory.length > 0) {
+                checksToRun = byCategory;
+            }
+            else {
+                const byId = REGISTRY.getById(filter);
+                if (byId) {
+                    checksToRun = [byId];
+                }
+                else {
+                    const byTitle = REGISTRY.getByTitle(filter);
+                    if (byTitle) {
+                        checksToRun = [byTitle];
+                    }
+                    else {
+                        checksToRun = [];
+                    }
+                }
+            }
+        }
+        else {
+            checksToRun = REGISTRY.getDependencyOrder();
+        }
+        const results = [];
+        for (const check of checksToRun) {
+            const result = await this.executeCheck(check);
+            results.push(result);
+            if (result.status === DoctorStatus.Fail) {
+                break;
+            }
+        }
+        const overall = this.aggregateReadiness(results);
+        return {
+            overall,
+            checks: results,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    async executeCheck(check) {
+        const timeout = check.timeout ?? 30000;
+        try {
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error(`Check '${check.id}' timed out after ${timeout}ms`)), timeout);
+            });
+            const result = await Promise.race([check.execute(), timeoutPromise]);
+            return result;
+        }
+        catch (error) {
+            return {
+                id: check.id,
+                status: DoctorStatus.Fail,
+                title: check.title,
+                message: error instanceof Error ? error.message : "Unknown error occurred",
+                hint: `Check execution failed: ${check.id}`,
+            };
+        }
+    }
+    aggregateReadiness(results) {
+        if (results.some((r) => r.status === DoctorStatus.Fail)) {
+            return ReadinessStatus.NotReady;
+        }
+        if (results.some((r) => r.status === DoctorStatus.Warn && !SOFT_CHECK_IDS.includes(r.id))) {
+            return ReadinessStatus.ReadyWithWarnings;
+        }
+        return ReadinessStatus.Ready;
+    }
+}
+export { DoctorOrchestrator };

package/dist/doctor/registry.js

@@ -0,0 +1,50 @@
+class CheckRegistry {
+    checks = [];
+    register(check) {
+        this.checks.push(check);
+    }
+    getAll() {
+        return [...this.checks];
+    }
+    getByCategory(category) {
+        return this.checks.filter((check) => check.category === category);
+    }
+    getById(id) {
+        return this.checks.find((check) => check.id === id);
+    }
+    getByTitle(title) {
+        return this.checks.find((check) => check.title === title);
+    }
+    getDependencyOrder() {
+        const result = [];
+        const visited = new Set();
+        const visiting = new Set();
+        const visit = (check) => {
+            if (visited.has(check.id)) {
+                return;
+            }
+            if (visiting.has(check.id)) {
+                throw new Error(`Cycle detected in check dependencies: ${check.id}`);
+            }
+            visiting.add(check.id);
+            for (const depId of check.dependencies) {
+                const dep = this.getById(depId);
+                if (dep) {
+                    visit(dep);
+                }
+            }
+            visiting.delete(check.id);
+            visited.add(check.id);
+            result.push(check);
+        };
+        for (const check of this.checks) {
+            if (!visited.has(check.id)) {
+                visit(check);
+            }
+        }
+        return result;
+    }
+}
+export { CheckRegistry };
+const REGISTRY = new CheckRegistry();
+export { REGISTRY };