@planu/cli 4.11.1 → 4.11.3

package/dist/server/openapi-spec.d.ts

@@ -4,50 +4,50 @@
  * SPEC-610: Planu HTTP API — OpenAPI document for LLM function calling
  */
 export declare const OPENAPI_SPEC: {
-    readonly openapi: "3.1.0";
+    readonly openapi: '3.1.0';
     readonly info: {
-        readonly title: "Planu HTTP API";
-        readonly version: "1.0.0";
-        readonly description: "Planu Spec Driven Development HTTP API — transport-agnostic access to Planu engine";
+        readonly title: 'Planu HTTP API';
+        readonly version: '1.0.0';
+        readonly description: 'Planu Spec Driven Development HTTP API — transport-agnostic access to Planu engine';
     };
     readonly servers: readonly [{
-        readonly url: "http://localhost:3000";
-        readonly description: "Local development server";
+        readonly url: 'http://localhost:3000';
+        readonly description: 'Local development server';
     }];
     readonly paths: {
         readonly '/api/health': {
             readonly get: {
-                readonly operationId: "getHealth";
-                readonly summary: "Health check";
-                readonly description: "Returns server status and version information";
+                readonly operationId: 'getHealth';
+                readonly summary: 'Health check';
+                readonly description: 'Returns server status and version information';
                 readonly responses: {
                     readonly '200': {
-                        readonly description: "Server is healthy";
+                        readonly description: 'Server is healthy';
                         readonly content: {
                             readonly 'application/json': {
                                 readonly schema: {
-                                    readonly type: "object";
+                                    readonly type: 'object';
                                     readonly properties: {
                                         readonly data: {
-                                            readonly type: "object";
+                                            readonly type: 'object';
                                             readonly properties: {
                                                 readonly status: {
-                                                    readonly type: "string";
-                                                    readonly example: "ok";
+                                                    readonly type: 'string';
+                                                    readonly example: 'ok';
                                                 };
                                                 readonly version: {
-                                                    readonly type: "string";
-                                                    readonly example: "1.0.0";
+                                                    readonly type: 'string';
+                                                    readonly example: '1.0.0';
                                                 };
                                                 readonly uptime: {
-                                                    readonly type: "number";
-                                                    readonly description: "Process uptime in seconds";
+                                                    readonly type: 'number';
+                                                    readonly description: 'Process uptime in seconds';
                                                 };
                                             };
-                                            readonly required: readonly ["status", "version", "uptime"];
+                                            readonly required: readonly ['status', 'version', 'uptime'];
                                         };
                                         readonly error: {
-                                            readonly type: "null";
+                                            readonly type: 'null';
                                         };
                                     };
                                 };
@@ -59,35 +59,35 @@ export declare const OPENAPI_SPEC: {
         };
         readonly '/api/specs': {
             readonly get: {
-                readonly operationId: "listSpecs";
-                readonly summary: "List specs";
-                readonly description: "Returns all specs, optionally filtered by status";
+                readonly operationId: 'listSpecs';
+                readonly summary: 'List specs';
+                readonly description: 'Returns all specs, optionally filtered by status';
                 readonly parameters: readonly [{
-                    readonly name: "status";
-                    readonly in: "query";
-                    readonly description: "Filter by spec status. Valid values: draft, review, approved, implementing, done, discarded";
+                    readonly name: 'status';
+                    readonly in: 'query';
+                    readonly description: 'Filter by spec status. Valid values: draft, review, approved, implementing, done, discarded';
                     readonly required: false;
                     readonly schema: {
-                        readonly type: "string";
-                        readonly enum: readonly ["draft", "review", "approved", "implementing", "done", "discarded"];
+                        readonly type: 'string';
+                        readonly enum: readonly ['draft', 'review', 'approved', 'implementing', 'done', 'discarded'];
                     };
                 }];
                 readonly responses: {
                     readonly '200': {
-                        readonly description: "List of specs";
+                        readonly description: 'List of specs';
                         readonly content: {
                             readonly 'application/json': {
                                 readonly schema: {
-                                    readonly type: "object";
+                                    readonly type: 'object';
                                     readonly properties: {
                                         readonly data: {
-                                            readonly type: "array";
+                                            readonly type: 'array';
                                             readonly items: {
-                                                readonly $ref: "#/components/schemas/Spec";
+                                                readonly $ref: '#/components/schemas/Spec';
                                             };
                                         };
                                         readonly error: {
-                                            readonly type: "null";
+                                            readonly type: 'null';
                                         };
                                     };
                                 };
@@ -97,43 +97,43 @@ export declare const OPENAPI_SPEC: {
                 };
             };
             readonly post: {
-                readonly operationId: "createSpec";
-                readonly summary: "Create a spec";
-                readonly description: "Creates a new spec with the given title and description";
+                readonly operationId: 'createSpec';
+                readonly summary: 'Create a spec';
+                readonly description: 'Creates a new spec with the given title and description';
                 readonly requestBody: {
                     readonly required: true;
                     readonly content: {
                         readonly 'application/json': {
                             readonly schema: {
-                                readonly type: "object";
+                                readonly type: 'object';
                                 readonly properties: {
                                     readonly title: {
-                                        readonly type: "string";
-                                        readonly description: "Spec title";
+                                        readonly type: 'string';
+                                        readonly description: 'Spec title';
                                     };
                                     readonly description: {
-                                        readonly type: "string";
-                                        readonly description: "Spec description / requirements";
+                                        readonly type: 'string';
+                                        readonly description: 'Spec description / requirements';
                                     };
                                 };
-                                readonly required: readonly ["title", "description"];
+                                readonly required: readonly ['title', 'description'];
                             };
                         };
                     };
                 };
                 readonly responses: {
                     readonly '201': {
-                        readonly description: "Spec created";
+                        readonly description: 'Spec created';
                         readonly content: {
                             readonly 'application/json': {
                                 readonly schema: {
-                                    readonly type: "object";
+                                    readonly type: 'object';
                                     readonly properties: {
                                         readonly data: {
-                                            readonly $ref: "#/components/schemas/Spec";
+                                            readonly $ref: '#/components/schemas/Spec';
                                         };
                                         readonly error: {
-                                            readonly type: "null";
+                                            readonly type: 'null';
                                         };
                                     };
                                 };
@@ -141,38 +141,38 @@ export declare const OPENAPI_SPEC: {
                         };
                     };
                     readonly '400': {
-                        readonly $ref: "#/components/responses/BadRequest";
+                        readonly $ref: '#/components/responses/BadRequest';
                     };
                 };
             };
         };
         readonly '/api/specs/{id}': {
             readonly get: {
-                readonly operationId: "getSpec";
-                readonly summary: "Get spec details";
-                readonly description: "Returns a single spec by ID";
+                readonly operationId: 'getSpec';
+                readonly summary: 'Get spec details';
+                readonly description: 'Returns a single spec by ID';
                 readonly parameters: readonly [{
-                    readonly name: "id";
-                    readonly in: "path";
+                    readonly name: 'id';
+                    readonly in: 'path';
                     readonly required: true;
                     readonly schema: {
-                        readonly type: "string";
-                        readonly example: "SPEC-001";
+                        readonly type: 'string';
+                        readonly example: 'SPEC-001';
                     };
                 }];
                 readonly responses: {
                     readonly '200': {
-                        readonly description: "Spec details";
+                        readonly description: 'Spec details';
                         readonly content: {
                             readonly 'application/json': {
                                 readonly schema: {
-                                    readonly type: "object";
+                                    readonly type: 'object';
                                     readonly properties: {
                                         readonly data: {
-                                            readonly $ref: "#/components/schemas/Spec";
+                                            readonly $ref: '#/components/schemas/Spec';
                                         };
                                         readonly error: {
-                                            readonly type: "null";
+                                            readonly type: 'null';
                                         };
                                     };
                                 };
@@ -180,23 +180,23 @@ export declare const OPENAPI_SPEC: {
                         };
                     };
                     readonly '404': {
-                        readonly $ref: "#/components/responses/NotFound";
+                        readonly $ref: '#/components/responses/NotFound';
                     };
                 };
             };
         };
         readonly '/api/specs/{id}/status': {
             readonly patch: {
-                readonly operationId: "updateSpecStatus";
-                readonly summary: "Update spec status";
-                readonly description: "Transitions a spec to a new status";
+                readonly operationId: 'updateSpecStatus';
+                readonly summary: 'Update spec status';
+                readonly description: 'Transitions a spec to a new status';
                 readonly parameters: readonly [{
-                    readonly name: "id";
-                    readonly in: "path";
+                    readonly name: 'id';
+                    readonly in: 'path';
                     readonly required: true;
                     readonly schema: {
-                        readonly type: "string";
-                        readonly example: "SPEC-001";
+                        readonly type: 'string';
+                        readonly example: 'SPEC-001';
                     };
                 }];
                 readonly requestBody: {
@@ -204,32 +204,32 @@ export declare const OPENAPI_SPEC: {
                     readonly content: {
                         readonly 'application/json': {
                             readonly schema: {
-                                readonly type: "object";
+                                readonly type: 'object';
                                 readonly properties: {
                                     readonly status: {
-                                        readonly type: "string";
-                                        readonly enum: readonly ["draft", "review", "approved", "implementing", "done", "discarded"];
-                                        readonly description: "New status. Valid values: draft, review, approved, implementing, done, discarded";
+                                        readonly type: 'string';
+                                        readonly enum: readonly ['draft', 'review', 'approved', 'implementing', 'done', 'discarded'];
+                                        readonly description: 'New status. Valid values: draft, review, approved, implementing, done, discarded';
                                     };
                                 };
-                                readonly required: readonly ["status"];
+                                readonly required: readonly ['status'];
                             };
                         };
                     };
                 };
                 readonly responses: {
                     readonly '200': {
-                        readonly description: "Spec status updated";
+                        readonly description: 'Spec status updated';
                         readonly content: {
                             readonly 'application/json': {
                                 readonly schema: {
-                                    readonly type: "object";
+                                    readonly type: 'object';
                                     readonly properties: {
                                         readonly data: {
-                                            readonly $ref: "#/components/schemas/Spec";
+                                            readonly $ref: '#/components/schemas/Spec';
                                         };
                                         readonly error: {
-                                            readonly type: "null";
+                                            readonly type: 'null';
                                         };
                                     };
                                 };
@@ -237,58 +237,58 @@ export declare const OPENAPI_SPEC: {
                         };
                     };
                     readonly '400': {
-                        readonly $ref: "#/components/responses/BadRequest";
+                        readonly $ref: '#/components/responses/BadRequest';
                     };
                     readonly '404': {
-                        readonly $ref: "#/components/responses/NotFound";
+                        readonly $ref: '#/components/responses/NotFound';
                     };
                 };
             };
         };
         readonly '/api/specs/{id}/validate': {
             readonly post: {
-                readonly operationId: "validateSpec";
-                readonly summary: "Validate a spec";
-                readonly description: "Runs readiness and quality checks on a spec";
+                readonly operationId: 'validateSpec';
+                readonly summary: 'Validate a spec';
+                readonly description: 'Runs readiness and quality checks on a spec';
                 readonly parameters: readonly [{
-                    readonly name: "id";
-                    readonly in: "path";
+                    readonly name: 'id';
+                    readonly in: 'path';
                     readonly required: true;
                     readonly schema: {
-                        readonly type: "string";
-                        readonly example: "SPEC-001";
+                        readonly type: 'string';
+                        readonly example: 'SPEC-001';
                     };
                 }];
                 readonly responses: {
                     readonly '200': {
-                        readonly description: "Validation results";
+                        readonly description: 'Validation results';
                         readonly content: {
                             readonly 'application/json': {
                                 readonly schema: {
-                                    readonly type: "object";
+                                    readonly type: 'object';
                                     readonly properties: {
                                         readonly data: {
-                                            readonly type: "object";
+                                            readonly type: 'object';
                                             readonly properties: {
                                                 readonly specId: {
-                                                    readonly type: "string";
+                                                    readonly type: 'string';
                                                 };
                                                 readonly ready: {
-                                                    readonly type: "boolean";
+                                                    readonly type: 'boolean';
                                                 };
                                                 readonly score: {
-                                                    readonly type: "number";
+                                                    readonly type: 'number';
                                                 };
                                                 readonly issues: {
-                                                    readonly type: "array";
+                                                    readonly type: 'array';
                                                     readonly items: {
-                                                        readonly type: "string";
+                                                        readonly type: 'string';
                                                     };
                                                 };
                                             };
                                         };
                                         readonly error: {
-                                            readonly type: "null";
+                                            readonly type: 'null';
                                         };
                                     };
                                 };
@@ -296,23 +296,23 @@ export declare const OPENAPI_SPEC: {
                         };
                     };
                     readonly '404': {
-                        readonly $ref: "#/components/responses/NotFound";
+                        readonly $ref: '#/components/responses/NotFound';
                     };
                 };
             };
         };
         readonly '/api/openapi.json': {
             readonly get: {
-                readonly operationId: "getOpenApiSpec";
-                readonly summary: "OpenAPI specification";
-                readonly description: "Returns this OpenAPI document for LLM function calling";
+                readonly operationId: 'getOpenApiSpec';
+                readonly summary: 'OpenAPI specification';
+                readonly description: 'Returns this OpenAPI document for LLM function calling';
                 readonly responses: {
                     readonly '200': {
-                        readonly description: "OpenAPI spec";
+                        readonly description: 'OpenAPI spec';
                         readonly content: {
                             readonly 'application/json': {
                                 readonly schema: {
-                                    readonly type: "object";
+                                    readonly type: 'object';
                                 };
                             };
                         };
@@ -324,74 +324,74 @@ export declare const OPENAPI_SPEC: {
     readonly components: {
         readonly schemas: {
             readonly Spec: {
-                readonly type: "object";
+                readonly type: 'object';
                 readonly properties: {
                     readonly id: {
-                        readonly type: "string";
-                        readonly example: "SPEC-001";
+                        readonly type: 'string';
+                        readonly example: 'SPEC-001';
                     };
                     readonly title: {
-                        readonly type: "string";
+                        readonly type: 'string';
                     };
                     readonly status: {
-                        readonly type: "string";
-                        readonly enum: readonly ["draft", "review", "approved", "implementing", "done", "discarded"];
+                        readonly type: 'string';
+                        readonly enum: readonly ['draft', 'review', 'approved', 'implementing', 'done', 'discarded'];
                     };
                     readonly type: {
-                        readonly type: "string";
+                        readonly type: 'string';
                     };
                     readonly scope: {
-                        readonly type: "string";
+                        readonly type: 'string';
                     };
                     readonly difficulty: {
-                        readonly type: "string";
+                        readonly type: 'string';
                     };
                     readonly risk: {
-                        readonly type: "string";
+                        readonly type: 'string';
                     };
                     readonly tags: {
-                        readonly type: "array";
+                        readonly type: 'array';
                         readonly items: {
-                            readonly type: "string";
+                            readonly type: 'string';
                         };
                     };
                     readonly createdAt: {
-                        readonly type: "string";
-                        readonly format: "date-time";
+                        readonly type: 'string';
+                        readonly format: 'date-time';
                     };
                     readonly updatedAt: {
-                        readonly type: "string";
-                        readonly format: "date-time";
+                        readonly type: 'string';
+                        readonly format: 'date-time';
                     };
                 };
-                readonly required: readonly ["id", "title", "status"];
+                readonly required: readonly ['id', 'title', 'status'];
             };
             readonly ApiError: {
-                readonly type: "object";
+                readonly type: 'object';
                 readonly properties: {
                     readonly message: {
-                        readonly type: "string";
+                        readonly type: 'string';
                     };
                     readonly code: {
-                        readonly type: "string";
+                        readonly type: 'string';
                     };
                 };
-                readonly required: readonly ["message", "code"];
+                readonly required: readonly ['message', 'code'];
             };
         };
         readonly responses: {
             readonly BadRequest: {
-                readonly description: "Bad request — validation error";
+                readonly description: 'Bad request — validation error';
                 readonly content: {
                     readonly 'application/json': {
                         readonly schema: {
-                            readonly type: "object";
+                            readonly type: 'object';
                             readonly properties: {
                                 readonly data: {
-                                    readonly type: "null";
+                                    readonly type: 'null';
                                 };
                                 readonly error: {
-                                    readonly $ref: "#/components/schemas/ApiError";
+                                    readonly $ref: '#/components/schemas/ApiError';
                                 };
                             };
                         };
@@ -399,17 +399,17 @@ export declare const OPENAPI_SPEC: {
                 };
             };
             readonly NotFound: {
-                readonly description: "Resource not found";
+                readonly description: 'Resource not found';
                 readonly content: {
                     readonly 'application/json': {
                         readonly schema: {
-                            readonly type: "object";
+                            readonly type: 'object';
                             readonly properties: {
                                 readonly data: {
-                                    readonly type: "null";
+                                    readonly type: 'null';
                                 };
                                 readonly error: {
-                                    readonly $ref: "#/components/schemas/ApiError";
+                                    readonly $ref: '#/components/schemas/ApiError';
                                 };
                             };
                         };
@@ -417,17 +417,17 @@ export declare const OPENAPI_SPEC: {
                 };
             };
             readonly InternalError: {
-                readonly description: "Internal server error";
+                readonly description: 'Internal server error';
                 readonly content: {
                     readonly 'application/json': {
                         readonly schema: {
-                            readonly type: "object";
+                            readonly type: 'object';
                             readonly properties: {
                                 readonly data: {
-                                    readonly type: "null";
+                                    readonly type: 'null';
                                 };
                                 readonly error: {
-                                    readonly $ref: "#/components/schemas/ApiError";
+                                    readonly $ref: '#/components/schemas/ApiError';
                                 };
                             };
                         };

package/dist/tools/challenge-spec/challenge-report.d.ts

@@ -0,0 +1,13 @@
+import type { ChallengeReport, ChallengeResolutionEvidence, FailureScenario } from '../../types/index.js';
+export declare const MINIMUM_RESOLVED_CHALLENGES = 3;
+/** Count only evidence tied to findings persisted by the same challenge report. */
+export declare function getResolvedChallengeEvidence(report: ChallengeReport | undefined): ChallengeResolutionEvidence[];
+/** Build a report whose resolution state is derived exclusively from explicit evidence. */
+export declare function buildChallengeReport(input: {
+    scenarios: FailureScenario[];
+    focusAreas: string[];
+    overallRisk: ChallengeReport['overallRisk'];
+    previousReport?: ChallengeReport;
+    runAt?: string;
+}): ChallengeReport;
+//# sourceMappingURL=challenge-report.d.ts.map

package/dist/tools/challenge-spec/challenge-report.js

@@ -0,0 +1,55 @@
+export const MINIMUM_RESOLVED_CHALLENGES = 3;
+function isExplicitResolutionEvidence(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.scenario === 'string' &&
+        candidate.scenario.trim().length > 0 &&
+        (candidate.resolution === 'mitigated' || candidate.resolution === 'accepted') &&
+        typeof candidate.evidence === 'string' &&
+        candidate.evidence.trim().length > 0 &&
+        typeof candidate.resolvedAt === 'string' &&
+        candidate.resolvedAt.trim().length > 0);
+}
+function uniqueMatchingEvidence(report, scenarioNames) {
+    const evidence = Array.isArray(report?.resolutionEvidence) ? report.resolutionEvidence : [];
+    const matched = new Map();
+    for (const item of evidence) {
+        if (isExplicitResolutionEvidence(item) && scenarioNames.has(item.scenario)) {
+            matched.set(item.scenario, item);
+        }
+    }
+    return [...matched.values()];
+}
+/** Count only evidence tied to findings persisted by the same challenge report. */
+export function getResolvedChallengeEvidence(report) {
+    if (!Array.isArray(report?.findings)) {
+        return [];
+    }
+    const scenarioNames = new Set(report.findings
+        .map((finding) => finding.scenario)
+        .filter((scenario) => typeof scenario === 'string' && scenario.trim().length > 0));
+    return uniqueMatchingEvidence(report, scenarioNames);
+}
+/** Build a report whose resolution state is derived exclusively from explicit evidence. */
+export function buildChallengeReport(input) {
+    const scenarioNames = new Set(input.scenarios.map((scenario) => scenario.scenario));
+    const resolutionEvidence = uniqueMatchingEvidence(input.previousReport, scenarioNames);
+    const resolvedScenarios = new Set(resolutionEvidence.map((item) => item.scenario));
+    const addressedCount = resolvedScenarios.size;
+    return {
+        runAt: input.runAt ?? new Date().toISOString(),
+        totalScenarios: input.scenarios.length,
+        addressedCount,
+        focusAreas: input.focusAreas,
+        overallRisk: input.overallRisk,
+        passed: addressedCount >= MINIMUM_RESOLVED_CHALLENGES,
+        findings: input.scenarios.map((scenario) => ({
+            scenario: scenario.scenario,
+            resolved: resolvedScenarios.has(scenario.scenario),
+        })),
+        resolutionEvidence,
+    };
+}
+//# sourceMappingURL=challenge-report.js.map