@arcfoundry/core 0.2.0 → 0.2.1

package/dist/agency-execution/final-gates/availability.d.ts

@@ -0,0 +1,2 @@
+export type CommandAvailabilityChecker = (command: string) => Promise<boolean>;
+export declare function isCommandAvailable(command: string): Promise<boolean>;

package/dist/agency-execution/final-gates/availability.js

@@ -0,0 +1,4 @@
+import { isCommandExecutableAvailable } from "../../commands/availability.js";
+export async function isCommandAvailable(command) {
+    return isCommandExecutableAvailable(command, process.cwd());
+}

package/dist/agency-execution/final-gates/package-manager.d.ts

@@ -0,0 +1,2 @@
+export type PackageManager = "npm" | "pnpm" | "yarn" | "bun";
+export declare function detectPackageManager(repoRoot: string, packageManagerSpec: string | undefined): Promise<PackageManager>;

package/dist/agency-execution/final-gates/package-manager.js

@@ -0,0 +1,38 @@
+import { access } from "node:fs/promises";
+import path from "node:path";
+const LOCKFILE_PACKAGE_MANAGERS = [
+    ["package-lock.json", "npm"],
+    ["npm-shrinkwrap.json", "npm"],
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+];
+export async function detectPackageManager(repoRoot, packageManagerSpec) {
+    const declared = parsePackageManager(packageManagerSpec);
+    if (declared)
+        return declared;
+    for (const [lockfile, packageManager] of LOCKFILE_PACKAGE_MANAGERS) {
+        if (await fileExists(path.join(repoRoot, lockfile)))
+            return packageManager;
+    }
+    return "npm";
+}
+function parsePackageManager(packageManagerSpec) {
+    const packageManager = packageManagerSpec?.split("@")[0];
+    return packageManager === "npm" ||
+        packageManager === "pnpm" ||
+        packageManager === "yarn" ||
+        packageManager === "bun"
+        ? packageManager
+        : null;
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/agency-execution/final-gates/project-command-metadata.d.ts

@@ -0,0 +1,6 @@
+import { type PackageManager } from "./package-manager.js";
+export type ProjectCommandMetadata = {
+    readonly packageManager: PackageManager;
+    readonly scripts: ReadonlySet<string>;
+};
+export declare function projectCommandMetadata(repoRoot: string): Promise<ProjectCommandMetadata>;

package/dist/agency-execution/final-gates/project-command-metadata.js

@@ -0,0 +1,24 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { detectPackageManager } from "./package-manager.js";
+export async function projectCommandMetadata(repoRoot) {
+    const packageJson = await readPackageJson(repoRoot);
+    return {
+        packageManager: await detectPackageManager(repoRoot, packageJson.packageManager),
+        scripts: new Set(Object.keys(packageJson.scripts ?? {})),
+    };
+}
+async function readPackageJson(repoRoot) {
+    try {
+        const raw = await readFile(path.join(repoRoot, "package.json"), "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return {};
+        throw error;
+    }
+}
+function isMissingFileError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}

package/dist/agency-execution/final-gates/script-gates.d.ts

@@ -0,0 +1,2 @@
+import { type CommandPurpose } from "@arcfoundry/schemas";
+export declare function scriptGates(scripts: ReadonlySet<string>): ReadonlyArray<readonly [CommandPurpose, string]>;

package/dist/agency-execution/final-gates/script-gates.js

@@ -0,0 +1,20 @@
+const FALLBACK_TEST_GATES = [
+    ["test", "test:unit"],
+    ["test", "test:integration"],
+    ["test", "test:e2e"],
+    ["browser-validation", "test:browser"],
+];
+const QUALITY_GATES = [
+    ["lint", "lint"],
+    ["format", "format"],
+    ["format", "format:check"],
+];
+export function scriptGates(scripts) {
+    return [
+        ...(scripts.has("build") ? [["build", "build"]] : []),
+        ...(scripts.has("test")
+            ? [["test", "test"]]
+            : FALLBACK_TEST_GATES.filter(([, script]) => scripts.has(script))),
+        ...QUALITY_GATES.filter(([, script]) => scripts.has(script)),
+    ];
+}

package/dist/agency-execution/final-gates/steps.d.ts

@@ -0,0 +1,9 @@
+import { type CommandStep } from "../../commands/command-sequence.js";
+import { type ProjectCommandMetadata } from "./project-command-metadata.js";
+type FinalVerificationStepsInput = {
+    readonly evidenceDir: string;
+    readonly metadata: ProjectCommandMetadata;
+    readonly repoRoot: string;
+};
+export declare function finalVerificationSteps(input: FinalVerificationStepsInput): CommandStep[];
+export {};

package/dist/agency-execution/final-gates/steps.js

@@ -0,0 +1,24 @@
+import { scriptGates } from "./script-gates.js";
+export function finalVerificationSteps(input) {
+    return [
+        step(input, "install", installArgs(input.metadata.packageManager)),
+        ...scriptGates(input.metadata.scripts).map(([purpose, script]) => step(input, purpose, runScriptArgs(script))),
+    ];
+}
+function step(input, purpose, args) {
+    return {
+        purpose,
+        command: input.metadata.packageManager,
+        args: [...args],
+        cwd: input.repoRoot,
+        evidenceDir: input.evidenceDir,
+    };
+}
+function installArgs(packageManager) {
+    if (packageManager === "pnpm")
+        return ["install", "--config.confirm-modules-purge=false"];
+    return ["install"];
+}
+function runScriptArgs(script) {
+    return ["run", script];
+}

package/dist/agency-execution/final-gates.d.ts

@@ -1,11 +1,16 @@
 import { type CommandEvidence } from "@arcfoundry/schemas";
 import { type CommandStepRunner } from "../commands/command-sequence.js";
+import { type CommandAvailabilityChecker } from "./final-gates/availability.js";
+export { type CommandAvailabilityChecker } from "./final-gates/availability.js";
+export type FinalVerificationGatePlanOptions = {
+    readonly commandAvailable?: CommandAvailabilityChecker;
+};
 export declare class FinalVerificationGatePlan {
     private readonly repoRoot;
     private readonly evidenceDir;
-    constructor(repoRoot: string, evidenceDir: string);
+    private readonly options;
+    constructor(repoRoot: string, evidenceDir: string, options?: FinalVerificationGatePlanOptions);
     run(runner?: CommandStepRunner): Promise<CommandEvidence[]>;
-    private steps;
 }
 export declare function runFinalVerificationGates(repoRoot: string, evidenceDir: string): Promise<CommandEvidence[]>;
 export declare function commandFailureMessages(commands: CommandEvidence[]): string[];

package/dist/agency-execution/final-gates.js

@@ -1,29 +1,36 @@
-import { CommandSequence, } from "../commands/command-sequence.js";
-const FINAL_GATE_COMMANDS = [
-    ["install", "pnpm", ["install", "--config.confirm-modules-purge=false"]],
-    ["test", "pnpm", ["run", "test"]],
-    ["lint", "pnpm", ["run", "lint"]],
-    ["format", "pnpm", ["run", "format"]],
-    ["format", "pnpm", ["run", "format:check"]],
-];
+import { CommandSequence } from "../commands/command-sequence.js";
+import { isCommandAvailable } from "./final-gates/availability.js";
+import { finalVerificationSteps } from "./final-gates/steps.js";
+import { projectCommandMetadata } from "./final-gates/project-command-metadata.js";
 export class FinalVerificationGatePlan {
     repoRoot;
     evidenceDir;
-    constructor(repoRoot, evidenceDir) {
+    options;
+    constructor(repoRoot, evidenceDir, options = {}) {
         this.repoRoot = repoRoot;
         this.evidenceDir = evidenceDir;
+        this.options = options;
     }
     async run(runner) {
         const sink = { commands: [] };
-        return new CommandSequence(sink, runner).run(this.steps());
-    }
-    steps() {
-        return FINAL_GATE_COMMANDS.map(([purpose, command, args]) => ({
-            purpose,
-            command,
-            args: [...args],
-            cwd: this.repoRoot,
+        const metadata = await projectCommandMetadata(this.repoRoot);
+        const commandAvailable = this.options.commandAvailable ?? isCommandAvailable;
+        if (!(await commandAvailable(metadata.packageManager))) {
+            return [
+                {
+                    purpose: "install",
+                    command: `${metadata.packageManager} (unavailable)`,
+                    exitCode: 127,
+                    durationMs: 0,
+                    stdoutRef: null,
+                    stderrRef: null,
+                },
+            ];
+        }
+        return new CommandSequence(sink, runner).run(finalVerificationSteps({
             evidenceDir: this.evidenceDir,
+            metadata,
+            repoRoot: this.repoRoot,
         }));
     }
 }

package/dist/commands/availability.d.ts

@@ -0,0 +1 @@
+export declare function isCommandExecutableAvailable(command: string, cwd: string, pathValue?: string): Promise<boolean>;

package/dist/commands/availability.js

@@ -0,0 +1,27 @@
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import path from "node:path";
+export async function isCommandExecutableAvailable(command, cwd, pathValue = process.env.PATH ?? "") {
+    if (isPathCommand(command))
+        return canExecute(path.resolve(cwd, command));
+    return searchPath(command, pathValue);
+}
+function isPathCommand(command) {
+    return path.isAbsolute(command) || command.includes(path.sep);
+}
+async function searchPath(command, pathValue) {
+    for (const directory of pathValue.split(path.delimiter)) {
+        if (directory && (await canExecute(path.join(directory, command))))
+            return true;
+    }
+    return false;
+}
+async function canExecute(filePath) {
+    try {
+        await access(filePath, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/evidence-runner.js

@@ -1,7 +1,24 @@
+import { isCommandExecutableAvailable } from "./availability.js";
 import { writeCommandEvidenceFiles } from "./evidence-files.js";
 import { runCommandProcess } from "./process-runner.js";
 export async function runCommandEvidence(command, args, cwd, evidenceDir, extraEnv = {}, timeoutMs = 180000) {
     const started = Date.now();
+    if (!(await isCommandExecutableAvailable(command, cwd, extraEnv.PATH))) {
+        const result = {
+            code: 127,
+            stdout: "",
+            stderr: `Command unavailable before execution: ${command}\n`,
+        };
+        const files = await writeCommandEvidenceFiles(evidenceDir, command, result);
+        return {
+            purpose: "other",
+            command: [command, ...args].join(" "),
+            exitCode: result.code,
+            durationMs: Date.now() - started,
+            stdoutRef: files.stdoutRef,
+            stderrRef: files.stderrRef,
+        };
+    }
     const result = await runCommandProcess({
         command,
         args,

package/dist/opencode-runtime/sdk-stage/output-retry.d.ts

@@ -0,0 +1,12 @@
+import { type PromptedOpenCodeSession } from "../session-prompt.js";
+import { type OpenCodeSdkClient } from "../sdk-stage-runtime.js";
+import { type OpenCodeModelSelection } from "../types.js";
+import { type OpenCodeSdkStageOptions } from "./options.js";
+export declare function retryMissingStageOutput(options: {
+    client: OpenCodeSdkClient;
+    prompted: PromptedOpenCodeSession;
+    sessionId: string;
+    stageOptions: OpenCodeSdkStageOptions;
+    model: OpenCodeModelSelection | null;
+    signal: AbortSignal;
+}): Promise<PromptedOpenCodeSession>;

package/dist/opencode-runtime/sdk-stage/output-retry.js

@@ -0,0 +1,20 @@
+import { promptOpenCodeSession } from "../session-prompt.js";
+import { parseStageOutput } from "../stage-output.js";
+import { stageOutputRetryPrompt } from "../stage-output-retry.js";
+export async function retryMissingStageOutput(options) {
+    const parsed = parseStageOutput(options.prompted.assistantText);
+    if (parsed.ok)
+        return options.prompted;
+    return promptOpenCodeSession({
+        client: options.client,
+        sessionId: options.sessionId,
+        repoRoot: options.stageOptions.repoRoot,
+        agent: options.stageOptions.opencodeAgent,
+        model: options.model,
+        prompt: stageOutputRetryPrompt({
+            stage: options.stageOptions.stage,
+            parsingError: parsed.error,
+        }),
+        signal: options.signal,
+    });
+}

package/dist/opencode-runtime/sdk-stage/session-flow.js

@@ -1,5 +1,6 @@
 import { createOpenCodeSdkSession } from "../sdk-stage-session.js";
 import { promptOpenCodeSession } from "../session-prompt.js";
+import { retryMissingStageOutput } from "./output-retry.js";
 export async function promptOpenCodeSdkStageSession(options) {
     const { session, model } = await createOpenCodeSdkSession({
         client: options.client,
@@ -21,5 +22,15 @@ export async function promptOpenCodeSdkStageSession(options) {
         prompt: options.stageOptions.prompt,
         signal: options.signal,
     });
-    return { sessionId: session.id, prompted };
+    return {
+        sessionId: session.id,
+        prompted: await retryMissingStageOutput({
+            client: options.client,
+            prompted,
+            sessionId: session.id,
+            stageOptions: options.stageOptions,
+            model,
+            signal: options.signal,
+        }),
+    };
 }

package/dist/opencode-runtime/stage-output-retry.d.ts

@@ -0,0 +1,4 @@
+export declare function stageOutputRetryPrompt(input: {
+    stage: string;
+    parsingError: string;
+}): string;

package/dist/opencode-runtime/stage-output-retry.js

@@ -0,0 +1,15 @@
+export function stageOutputRetryPrompt(input) {
+    return [
+        "Your previous response completed without a valid Arc Foundry stage output.",
+        "",
+        `Stage: ${input.stage}`,
+        `Parsing error: ${input.parsingError}`,
+        "",
+        "Finish this stage now.",
+        "If the stage work is already complete, do not repeat it. If more work is required, complete only the missing work.",
+        "End with exactly one strict JSON object between these markers and no Markdown fences:",
+        "AGENCY_STAGE_OUTPUT_JSON_START",
+        '{"status":"passed","summary":"Concise stage result.","outputs":{},"blockingIssues":[]}',
+        "AGENCY_STAGE_OUTPUT_JSON_END",
+    ].join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcfoundry/core",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Core workflow, governance, artifact, and runtime primitives for Arc Foundry.",
   "license": "UNLICENSED",
   "files": [
@@ -19,7 +19,7 @@
   },
   "dependencies": {
     "@opencode-ai/sdk": "^1.15.11",
-    "@arcfoundry/schemas": "0.2.0"
+    "@arcfoundry/schemas": "0.2.1"
   },
   "engines": {
     "node": "^25.9.0"