@apexops/cli 0.10.0-next.3 → 0.10.0-next.5

package/dist/mcp.js

@@ -5,6 +5,14 @@ import { ApexService, SUPPORTED_ARTIFACT_KINDS } from "./service.js";
 import { APEX_VERSION } from "./version.js";
 const artifactKind = z.enum(SUPPORTED_ARTIFACT_KINDS);
 const taskOutput = z.object({ kind: artifactKind, value: z.unknown(), summary: z.string().optional() });
+const reviewFinding = z
+    .object({
+    id: z.string().min(1),
+    severity: z.enum(["critical", "high", "medium", "low", "info"]),
+    title: z.string().min(1),
+    detail: z.string().min(1),
+})
+    .strict();
 const uniqueStrings = z
     .array(z.string().min(1))
     .min(1)
@@ -65,6 +73,44 @@ const projectCreateInput = z
 const projectIdInput = z.object({ projectId: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/) }).strict();
 const projectUseInput = projectIdInput.extend({ runId: z.string().min(1).optional() });
 const projectDeleteInput = projectIdInput.extend({ confirm: z.literal(true) });
+const planCompletionInput = z
+    .object({
+    taskId: z.string().min(1),
+    implementationIntent: z.unknown(),
+    iacBinding: z
+        .object({
+        schemaVersion: z.literal("1.0.0"),
+        projectId: z.string().min(1),
+        runId: z.string().min(1),
+        track: z.enum(["bicep", "terraform"]),
+        resourceBindings: z.record(z.string().min(1), z.unknown()),
+    })
+        .strict(),
+    environmentInputs: z.unknown(),
+})
+    .strict();
+const gateDecisionInput = z
+    .object({
+    gate: z.union([z.literal(1), z.literal(2), z.literal(3)]),
+    decision: z.enum(["approved", "rejected"]),
+    confirm: z.literal(true),
+})
+    .strict();
+const reviewDecisionInput = z
+    .object({
+    reviewHash: z.string().regex(/^[0-9a-f]{64}$/),
+    decisions: z
+        .array(z
+        .object({
+        findingId: z.string().min(1),
+        action: z.enum(["revise", "accept-risk"]),
+        rationale: z.string().min(1),
+        expiresAt: z.string().datetime().optional(),
+    })
+        .strict())
+        .min(1),
+})
+    .strict();
 const normalizeOutputs = (outputs) => outputs.map(({ kind, value, summary }) => ({
     kind,
     value,
@@ -86,6 +132,14 @@ export function createMcpServer(service) {
         description: "Read context only for the exact task.taskId returned by nextTask with status=task.",
         inputSchema: { taskId: z.string() },
     }, async ({ taskId }) => result(await service.taskContext(taskId)));
+    server.registerTool("readTaskInput", {
+        description: "Read a bounded chunk of the accepted source artifact for an active review task.",
+        inputSchema: {
+            taskId: z.string(),
+            offset: z.number().int().nonnegative().optional(),
+            limit: z.number().int().min(1).max(6_000).optional(),
+        },
+    }, async ({ taskId, offset, limit }) => result(await service.readTaskInput(taskId, offset, limit)));
     server.registerTool("recordInput", { description: "Record answers for the exact pending kernel input request", inputSchema: inputSubmission }, async (input) => result(await service.recordInput(input)));
     server.registerTool("projectCreate", {
         description: "Create and select a new project with its initial environment run",
@@ -97,6 +151,17 @@ export function createMcpServer(service) {
         description: "Delete a project and all of its run-bound state after explicit confirmation",
         inputSchema: projectDeleteInput,
     }, async ({ projectId, confirm }) => result(await service.deleteProject(projectId, confirm)));
+    server.registerTool("gateDecide", {
+        description: "Record an explicitly confirmed human decision for Gate 1, 2, or 3 using the local OS username as actor. Gate 4 remains CLI-only.",
+        inputSchema: gateDecisionInput,
+    }, async ({ gate, decision }) => result(await service.decideInteractiveGate(gate, decision)));
+    server.registerTool("reviewDecide", {
+        description: "Resolve all current review findings atomically by requesting revision or accepting permitted time-bound risk.",
+        inputSchema: reviewDecisionInput,
+    }, async ({ reviewHash, decisions }) => result(await service.decideReview(reviewHash, decisions.map(({ expiresAt, ...decision }) => ({
+        ...decision,
+        ...(expiresAt === undefined ? {} : { expiresAt }),
+    })))));
     server.registerTool("stageArtifact", {
         inputSchema: {
             taskId: z.string(),
@@ -151,25 +216,33 @@ export function createMcpServer(service) {
             : { kind, value, ...(summary === undefined ? {} : { summary }) }
         : normalizeOutputs(outputs))));
     server.registerTool("completeTask", {
-        description: "Complete a task atomically. Supply outputs[] for every task with multiple required output kinds.",
+        description: "Complete a task atomically with a nonempty outputs[] bundle.",
         inputSchema: {
             taskId: z.string(),
-            kind: artifactKind.optional(),
-            value: z.unknown().optional(),
-            summary: z.string().optional(),
-            outputs: z.array(taskOutput).optional(),
+            outputs: z.array(taskOutput).min(1),
         },
-    }, async ({ taskId, kind, value, summary, outputs }) => {
-        if (outputs !== undefined)
-            return result(await service.completeTaskOutputs(taskId, normalizeOutputs(outputs)));
-        if (kind === undefined)
-            throw new Error("completeTask requires kind/value or outputs[]");
-        const context = await service.taskContext(taskId);
-        if (context.task.allowedOutputKinds.length > 1) {
-            throw new Error("completeTask requires outputs[] when the task has multiple required output kinds");
-        }
-        return result(await service.completeTask(taskId, { kind, value, ...(summary === undefined ? {} : { summary }) }));
-    });
+    }, async ({ taskId, outputs }) => result(await service.completeTaskOutputs(taskId, normalizeOutputs(outputs))));
+    server.registerTool("requirementsComplete", {
+        description: "Complete the active Requirements task atomically.",
+        inputSchema: { taskId: z.string(), requirements: z.unknown() },
+    }, async ({ taskId, requirements }) => result(await service.completeRequirements(taskId, requirements)));
+    server.registerTool("architectureComplete", {
+        description: "Complete the active Architecture task atomically with all required outputs.",
+        inputSchema: {
+            taskId: z.string(),
+            architecture: z.unknown(),
+            costEstimate: z.unknown(),
+            decisionManifest: z.unknown(),
+        },
+    }, async ({ taskId, architecture, costEstimate, decisionManifest }) => result(await service.completeArchitecture(taskId, architecture, costEstimate, decisionManifest)));
+    server.registerTool("reviewComplete", {
+        description: "Complete the active review task; APEX derives subject identity, hash, timestamp, and evidence binding.",
+        inputSchema: { taskId: z.string(), findings: z.array(reviewFinding) },
+    }, async ({ taskId, findings }) => result(await service.completeReview(taskId, findings)));
+    server.registerTool("planComplete", {
+        description: "Atomically complete a plan. Derives the canonical implementation intent hash for the binding; do not supply intentHash.",
+        inputSchema: planCompletionInput,
+    }, async ({ taskId, implementationIntent, iacBinding, environmentInputs }) => result(await service.completePlan(taskId, implementationIntent, iacBinding, environmentInputs)));
     server.registerTool("preview", { description: "Read the current operator-created deployment preview" }, async () => result(await service.currentPreview()));
     server.registerTool("reconcile", {}, async () => result(await service.reconcile()));
     server.registerTool("inventory", {}, async () => result(await service.inventory()));

package/dist/service.d.ts

@@ -1,4 +1,4 @@
-import { type ApprovalEvidenceV1, type ArchitectureAvailabilityV1, type DeploymentPreviewV1, type InputRequestV1, type InputValueV1, type InputSubmissionV1, type ImprovementCategory, type ImprovementDecisionV1, type ImprovementObservationV1, type ImprovementPolicyV1, type ImprovementProposalV1, type ImprovementSource, type Operation, type ProjectId, type ResourceInventoryV1, type RunConfigV1, type RunId, type TaskEnvelopeV1 } from "@apexops/contracts";
+import { type ApprovalEvidenceV1, type ArchitectureAvailabilityV1, type ArchitectureV1, type CostEstimateV1, type DeploymentPreviewV1, type EnvironmentInputsV1, type IacBindingV1, type InputRequestV1, type InputValueV1, type InputSubmissionV1, type ImprovementCategory, type ImprovementDecisionV1, type ImprovementObservationV1, type ImprovementPolicyV1, type ImprovementProposalV1, type ImprovementSource, type ImplementationIntentV1, type Operation, type ProjectId, type ResourceInventoryV1, type ReviewFindingsV1, type RequirementsV1, type RunConfigV1, type RunId, type WorkloadDecisionManifestV1, type TaskEnvelopeV1 } from "@apexops/contracts";
 import { type CapabilityPackInstallOptions, type IacProvider, type ProcessRunnerLike } from "@apexops/capabilities";
 import { type JsonValue } from "@apexops/kernel";
 import { type BundledClientProjection } from "./assets.js";
@@ -52,6 +52,12 @@ export interface ReviewResolution {
     expiresAt?: string;
     dependencyHash: string;
 }
+export interface ReviewDecision {
+    findingId: string;
+    action: "revise" | "accept-risk";
+    rationale: string;
+    expiresAt?: string;
+}
 export interface ServiceOptions {
     clock?: () => Date;
     idSource?: () => string;
@@ -618,6 +624,9 @@ export declare class ApexService {
     nextTask(): Promise<{
         status: "needs_input";
         request: InputRequestV1;
+    } | {
+        status: "needs_review";
+        review: Awaited<ReturnType<ApexService["pendingReview"]>>;
     } | {
         status: "task";
         task: TaskEnvelopeV1;
@@ -638,6 +647,13 @@ export declare class ApexService {
         status: string;
         blockers: string[];
     }>;
+    readTaskInput(taskId: string, offset?: number, limit?: number): Promise<{
+        subjectHash: string;
+        content: string;
+        offset: number;
+        nextOffset?: number;
+        outputTemplate?: unknown;
+    }>;
     stageArtifact(taskId: string, output: TaskOutput): Promise<StagedArtifact>;
     stageFile(taskId: string, relativePath: string, content: string | Uint8Array, expectedSha?: string): Promise<StagedFile>;
     generateIac(taskId: string, options?: GenerateIacOptions): Promise<{
@@ -658,6 +674,23 @@ export declare class ApexService {
         outputHashes: Partial<Record<ArtifactKind, string>>;
         summary: string;
     }>;
+    completeRequirements(taskId: string, requirements: RequirementsV1): Promise<{
+        outputHashes: Partial<Record<ArtifactKind, string>>;
+        summary: string;
+    }>;
+    completeArchitecture(taskId: string, architecture: ArchitectureV1, costEstimate: CostEstimateV1, decisionManifest: WorkloadDecisionManifestV1): Promise<{
+        outputHashes: Partial<Record<ArtifactKind, string>>;
+        summary: string;
+    }>;
+    completeReview(taskId: string, findings: Array<Pick<ReviewFindingsV1["findings"][number], "id" | "severity" | "title" | "detail">>): Promise<{
+        outputHashes: Partial<Record<ArtifactKind, string>>;
+        summary: string;
+    }>;
+    completePlan(taskId: string, intent: ImplementationIntentV1, binding: Omit<IacBindingV1, "intentHash">, environmentInputs: EnvironmentInputsV1): Promise<{
+        outputHashes: Partial<Record<ArtifactKind, string>>;
+        summary: string;
+    }>;
+    private assertTaskType;
     private acceptTaskOutputs;
     private renderRequirementsDocument;
     private requirementsReviewDirectory;
@@ -676,8 +709,14 @@ export declare class ApexService {
     private requirementsDocumentTemplateContent;
     cancelTask(taskId: string): Promise<void>;
     resolveReview(resolution: ReviewResolution): Promise<void>;
+    decideReview(reviewHash: string, decisions: ReviewDecision[]): Promise<{
+        status: "revision_requested" | "resolved";
+    }>;
+    private pendingReview;
+    private reviseReview;
     private assertReviewResolution;
     decideGateNumber(gateNumber: number, decision: "approved" | "rejected", actor: string, options?: GateDecisionOptions): Promise<ApprovalEvidenceV1>;
+    decideInteractiveGate(gateNumber: 1 | 2 | 3, decision: "approved" | "rejected"): Promise<ApprovalEvidenceV1>;
     preview(options: PreviewOptions): Promise<DeploymentPreviewV1>;
     private operationsReviewDirectory;
     private materializeOperationsPreviewPackage;
@@ -749,8 +788,12 @@ export declare class ApexService {
     private architectureDecisionValues;
     private issueArchitectureDecision;
     private nextRequirementsIntakeRound;
+    private requirementsIntakeCatalog;
     private issueRequirementsInput;
     private requirementsIntakeQuestions;
+    private recommendedWorkloadPattern;
+    private workloadScalePrompt;
+    private recommendedServiceCandidates;
     private append;
     private journal;
     private runPath;
@@ -801,6 +844,8 @@ export declare class ApexService {
     private customizationSelection;
     private assertCleanInitialization;
     private createRuntimeLock;
+    private installRuntimeGeneration;
+    private runtimeRootForRun;
     private capabilityPacks;
     private runtimeLockChecks;
     private ensureLocalGitBoundary;