@ai-dev-orchestrator/schemas 0.1.1

package/dist/specification/intake.d.ts

@@ -0,0 +1,419 @@
+import { z } from 'zod/v4';
+export declare const intakeVerdictSchema: z.ZodEnum<{
+    Ready: "Ready";
+    NotReady: "NotReady";
+}>;
+export type IntakeVerdict = z.infer<typeof intakeVerdictSchema>;
+export declare const sourceMetadataSchema: z.ZodObject<{
+    fetchedAt: z.ZodString;
+    checksum: z.ZodString;
+}, z.core.$strip>;
+export type SourceMetadata = z.infer<typeof sourceMetadataSchema>;
+export declare const intermediateRequirementsSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    rawFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    sourceMetadata: z.ZodObject<{
+        fetchedAt: z.ZodString;
+        checksum: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type IntermediateRequirements = z.infer<typeof intermediateRequirementsSchema>;
+export declare const analystConfigSchema: z.ZodObject<{
+    readinessThreshold: z.ZodNumber;
+    maxAmbiguities: z.ZodNumber;
+    requireExplicitAssumptions: z.ZodBoolean;
+}, z.core.$strip>;
+export type AnalystConfig = z.infer<typeof analystConfigSchema>;
+export declare const intakeConfigSchema: z.ZodObject<{
+    analyst: z.ZodObject<{
+        readinessThreshold: z.ZodNumber;
+        maxAmbiguities: z.ZodNumber;
+        requireExplicitAssumptions: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type IntakeConfig = z.infer<typeof intakeConfigSchema>;
+export declare const intakeResultSchema: z.ZodObject<{
+    verdict: z.ZodEnum<{
+        Ready: "Ready";
+        NotReady: "NotReady";
+    }>;
+    artifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type IntakeResult = z.infer<typeof intakeResultSchema>;
+export declare const ambiguitySeveritySchema: z.ZodEnum<{
+    high: "high";
+    medium: "medium";
+    low: "low";
+}>;
+export type AmbiguitySeverity = z.infer<typeof ambiguitySeveritySchema>;
+export declare const ambiguitySchema: z.ZodObject<{
+    id: z.ZodString;
+    field: z.ZodString;
+    description: z.ZodString;
+    severity: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+}, z.core.$strip>;
+export type Ambiguity = z.infer<typeof ambiguitySchema>;
+export declare const requirementsAnalysisSchema: z.ZodObject<{
+    completenessScore: z.ZodNumber;
+    ambiguities: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        field: z.ZodString;
+        description: z.ZodString;
+        severity: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+    }, z.core.$strip>>>;
+    assumptions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        impact: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        validated: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    risks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        likelihood: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        impact: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        mitigation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    constraints: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        type: z.ZodEnum<{
+            resource: "resource";
+            technical: "technical";
+            business: "business";
+            regulatory: "regulatory";
+            timeline: "timeline";
+        }>;
+        source: z.ZodString;
+    }, z.core.$strip>>>;
+    dependencies: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        type: z.ZodEnum<{
+            external: "external";
+            internal: "internal";
+        }>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            available: "available";
+            blocked: "blocked";
+        }>;
+        owner: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    missingInformation: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type RequirementsAnalysis = z.infer<typeof requirementsAnalysisSchema>;
+export declare const clarificationQuestionCategorySchema: z.ZodEnum<{
+    ambiguity: "ambiguity";
+    missing: "missing";
+    assumption: "assumption";
+    risk: "risk";
+    constraint: "constraint";
+}>;
+export type ClarificationQuestionCategory = z.infer<typeof clarificationQuestionCategorySchema>;
+export declare const clarificationQuestionSchema: z.ZodObject<{
+    id: z.ZodString;
+    category: z.ZodEnum<{
+        ambiguity: "ambiguity";
+        missing: "missing";
+        assumption: "assumption";
+        risk: "risk";
+        constraint: "constraint";
+    }>;
+    question: z.ZodString;
+    context: z.ZodString;
+    suggestedDefault: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ClarificationQuestion = z.infer<typeof clarificationQuestionSchema>;
+export declare const analystInputSchema: z.ZodObject<{
+    specification: z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SpecificationId", "out">;
+        version: z.ZodNumber;
+        previousVersion: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        businessGoal: z.ZodString;
+        stakeholders: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            role: z.ZodString;
+            interest: z.ZodString;
+        }, z.core.$strip>>>;
+        assumptions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            impact: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            validated: z.ZodBoolean;
+        }, z.core.$strip>>>;
+        constraints: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            type: z.ZodEnum<{
+                resource: "resource";
+                technical: "technical";
+                business: "business";
+                regulatory: "regulatory";
+                timeline: "timeline";
+            }>;
+            source: z.ZodString;
+        }, z.core.$strip>>>;
+        functionalRequirements: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            priority: z.ZodEnum<{
+                must: "must";
+                should: "should";
+                could: "could";
+                wont: "wont";
+            }>;
+            acceptanceCriteria: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            dependencies: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>>>;
+        nonFunctionalRequirements: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            category: z.ZodEnum<{
+                security: "security";
+                performance: "performance";
+                maintainability: "maintainability";
+                other: "other";
+                reliability: "reliability";
+                scalability: "scalability";
+                usability: "usability";
+                compatibility: "compatibility";
+            }>;
+            metric: z.ZodOptional<z.ZodString>;
+            threshold: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        acceptanceCriteria: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            verificationMethod: z.ZodEnum<{
+                review: "review";
+                test: "test";
+                demo: "demo";
+                analysis: "analysis";
+            }>;
+            requirementIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        risks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            likelihood: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            impact: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            mitigation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        dependencies: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            type: z.ZodEnum<{
+                external: "external";
+                internal: "internal";
+            }>;
+            status: z.ZodEnum<{
+                pending: "pending";
+                available: "available";
+                blocked: "blocked";
+            }>;
+            owner: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        definitionOfDone: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        sources: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            fetchedAt: z.ZodString;
+            checksum: z.ZodString;
+            fieldsMapped: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        analysis: z.ZodOptional<z.ZodObject<{
+            completenessScore: z.ZodNumber;
+            ambiguityCount: z.ZodNumber;
+            riskCount: z.ZodNumber;
+            unvalidatedAssumptionCount: z.ZodNumber;
+            readinessVerdict: z.ZodEnum<{
+                Ready: "Ready";
+                NotReady: "NotReady";
+            }>;
+            analystNotes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    config: z.ZodObject<{
+        readinessThreshold: z.ZodNumber;
+        maxAmbiguities: z.ZodNumber;
+        requireExplicitAssumptions: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AnalystInput = z.infer<typeof analystInputSchema>;
+export declare const analystOutputSchema: z.ZodObject<{
+    verdict: z.ZodEnum<{
+        Ready: "Ready";
+        NotReady: "NotReady";
+    }>;
+    analysis: z.ZodObject<{
+        completenessScore: z.ZodNumber;
+        ambiguities: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            field: z.ZodString;
+            description: z.ZodString;
+            severity: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+        }, z.core.$strip>>>;
+        assumptions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            impact: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            validated: z.ZodBoolean;
+        }, z.core.$strip>>>;
+        risks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            likelihood: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            impact: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            mitigation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        constraints: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            type: z.ZodEnum<{
+                resource: "resource";
+                technical: "technical";
+                business: "business";
+                regulatory: "regulatory";
+                timeline: "timeline";
+            }>;
+            source: z.ZodString;
+        }, z.core.$strip>>>;
+        dependencies: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            type: z.ZodEnum<{
+                external: "external";
+                internal: "internal";
+            }>;
+            status: z.ZodEnum<{
+                pending: "pending";
+                available: "available";
+                blocked: "blocked";
+            }>;
+            owner: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        missingInformation: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    questions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        category: z.ZodEnum<{
+            ambiguity: "ambiguity";
+            missing: "missing";
+            assumption: "assumption";
+            risk: "risk";
+            constraint: "constraint";
+        }>;
+        question: z.ZodString;
+        context: z.ZodString;
+        suggestedDefault: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+export type AnalystOutput = z.infer<typeof analystOutputSchema>;
+export declare const ambiguityResultSchema: z.ZodObject<{
+    ambiguities: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        field: z.ZodString;
+        description: z.ZodString;
+        severity: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+    }, z.core.$strip>>>;
+    isReady: z.ZodBoolean;
+}, z.core.$strip>;
+export type AmbiguityResult = z.infer<typeof ambiguityResultSchema>;

package/dist/specification/intake.js

@@ -0,0 +1,70 @@
+import { z } from 'zod/v4';
+import { artifactRefSchema } from '../artifacts/artifact-system';
+import { readinessVerdictSchema, threeTierSeveritySchema } from '../shared/string-enums';
+import { canonicalSpecificationSchema, assumptionSchema, riskSchema, constraintSchema, dependencySchema, } from './canonical-specification';
+export const intakeVerdictSchema = readinessVerdictSchema;
+export const sourceMetadataSchema = z.object({
+    fetchedAt: z.string(),
+    checksum: z.string(),
+});
+export const intermediateRequirementsSchema = z.object({
+    title: z.string().optional(),
+    description: z.string().optional(),
+    rawFields: z.record(z.string(), z.unknown()).optional(),
+    sourceMetadata: sourceMetadataSchema,
+});
+export const analystConfigSchema = z.object({
+    readinessThreshold: z.number(),
+    maxAmbiguities: z.number(),
+    requireExplicitAssumptions: z.boolean(),
+});
+export const intakeConfigSchema = z.object({
+    analyst: analystConfigSchema,
+});
+export const intakeResultSchema = z.object({
+    verdict: intakeVerdictSchema,
+    artifacts: z.array(artifactRefSchema).readonly(),
+});
+export const ambiguitySeveritySchema = threeTierSeveritySchema;
+export const ambiguitySchema = z.object({
+    id: z.string(),
+    field: z.string(),
+    description: z.string(),
+    severity: ambiguitySeveritySchema,
+});
+export const requirementsAnalysisSchema = z.object({
+    completenessScore: z.number(),
+    ambiguities: z.array(ambiguitySchema).readonly(),
+    assumptions: z.array(assumptionSchema).readonly(),
+    risks: z.array(riskSchema).readonly(),
+    constraints: z.array(constraintSchema).readonly(),
+    dependencies: z.array(dependencySchema).readonly(),
+    missingInformation: z.array(z.string()).readonly(),
+});
+export const clarificationQuestionCategorySchema = z.enum([
+    'ambiguity',
+    'missing',
+    'assumption',
+    'risk',
+    'constraint',
+]);
+export const clarificationQuestionSchema = z.object({
+    id: z.string(),
+    category: clarificationQuestionCategorySchema,
+    question: z.string(),
+    context: z.string(),
+    suggestedDefault: z.string().optional(),
+});
+export const analystInputSchema = z.object({
+    specification: canonicalSpecificationSchema,
+    config: analystConfigSchema,
+});
+export const analystOutputSchema = z.object({
+    verdict: intakeVerdictSchema,
+    analysis: requirementsAnalysisSchema,
+    questions: z.array(clarificationQuestionSchema).readonly().optional(),
+});
+export const ambiguityResultSchema = z.object({
+    ambiguities: z.array(ambiguitySchema).readonly(),
+    isReady: z.boolean(),
+});