@jterrats/open-orchestra 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,550 @@
+export type TaskStatus = "pending" | "ready" | "in_progress" | "blocked" | "review" | "approved" | "rejected" | "done" | "canceled";
+export type ReviewResult = "approve" | "block" | "changes";
+export type Severity = "info" | "low" | "medium" | "high" | "critical";
+export type EvidenceType = "command" | "file" | "screenshot" | "trace" | "video" | "log" | "report";
+export interface Role {
+    id: string;
+    name: string;
+    description: string;
+    capabilities: string[];
+    requiredHandoffFields: string[];
+    blockingAuthority: string[];
+    activationCriteria?: string[];
+    expectedEvidence?: string[];
+    gateParticipation?: string[];
+}
+export interface MechanicalOverride {
+    rationale: string;
+}
+export interface ArchitectureApproval {
+    proposal?: string;
+    userApproved?: boolean;
+    approvedBy?: string;
+    approvedAt?: string;
+}
+export interface QaGateMetadata {
+    plan?: string;
+    executionStatus?: "not_run" | "passed" | "failed" | "deferred";
+    deferredRationale?: string;
+    deferredOwner?: string;
+}
+export type RiskImpactArea = "security" | "sre" | "dba" | "devops" | "compliance" | "ux";
+export interface RiskAcceptance {
+    acceptedBy?: string;
+    rationale?: string;
+}
+export interface RiskGateMetadata {
+    impactAreas?: RiskImpactArea[];
+    acceptance?: RiskAcceptance;
+}
+export interface Task {
+    id: string;
+    title: string;
+    ownerRole: string;
+    status: TaskStatus;
+    dependencies: string[];
+    backlogItem?: string;
+    goal?: string;
+    scope?: string;
+    acceptanceCriteria?: string[];
+    assumptions?: string[];
+    risks?: string[];
+    paths?: string[];
+    testStrategy?: string;
+    blockedReason?: string;
+    mechanicalOverride?: MechanicalOverride;
+    architectureApproval?: ArchitectureApproval;
+    qaGate?: QaGateMetadata;
+    riskGate?: RiskGateMetadata;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface LockEntry {
+    id: string;
+    taskId: string;
+    ownerRole: string;
+    path: string;
+    reason: string;
+    createdAt: string;
+    expiresAt?: string;
+}
+export interface EventEntry {
+    id: string;
+    type: string;
+    timestamp: string;
+    actor: string;
+    summary: string;
+    taskId: string | null;
+    artifacts?: string[];
+    metadata: Record<string, unknown>;
+}
+export interface EventInput {
+    type: string;
+    actor: string;
+    summary: string;
+    taskId?: string;
+    artifacts?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface ToolConfig {
+    enabled?: boolean;
+    command: string;
+    args: string[];
+    cwd: string;
+    allowedRoles: string[];
+    timeoutMs: number;
+    evidence: string;
+    risk: string;
+}
+export interface ModelProviderCapabilities {
+    streaming: boolean;
+    tools: boolean;
+    vision: boolean;
+    jsonMode: boolean;
+    maxContextTokens: number;
+    timeoutMs: number;
+}
+export interface ModelMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+}
+export interface ModelRequest {
+    messages: ModelMessage[];
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    jsonMode?: boolean;
+    tools?: unknown[];
+    timeoutMs?: number;
+}
+export interface ModelResponse {
+    id: string;
+    provider: string;
+    model: string;
+    content: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    finishReason: "stop" | "length" | "tool_call" | "error";
+}
+export interface ModelStreamEvent {
+    type: "content" | "tool_call" | "done" | "error";
+    content?: string;
+    error?: string;
+}
+export interface ModelProviderError {
+    provider: string;
+    code: string;
+    message: string;
+    retryable: boolean;
+}
+export interface ProviderFallbackResult {
+    provider: string;
+    model: string;
+    response: ModelResponse;
+    fallbackUsed: boolean;
+    failedProviders: {
+        provider: string;
+        reason: string;
+    }[];
+}
+export interface ModelProvenanceInput {
+    task: string;
+    role: string;
+    provider: string;
+    model: string;
+    promptId: string;
+    responseId: string;
+    inputTokens: number;
+    outputTokens: number;
+    estimatedCostUsd: number;
+    finishReason: ModelResponse["finishReason"];
+}
+export interface ModelProvenanceRecord extends ModelProvenanceInput {
+    timestamp: string;
+}
+export interface ModelProvider {
+    id: string;
+    capabilities: ModelProviderCapabilities;
+    complete(request: ModelRequest): Promise<ModelResponse>;
+    stream?(request: ModelRequest): AsyncIterable<ModelStreamEvent>;
+}
+export interface ConfiguredProviderSummary {
+    scope: string;
+    provider: string;
+    model: string;
+    fallbacks: string[];
+    maxTokens: number;
+    maxCostUsd: number;
+    timeoutMs: number;
+    retries: number;
+    requiredCapabilities: string[];
+}
+export interface ProviderRouting {
+    provider: string;
+    model: string;
+    fallbacks: string[];
+    maxTokens: number;
+    maxCostUsd: number;
+    timeoutMs: number;
+    retries: number;
+    requiredCapabilities: string[];
+}
+export interface WorkflowProvidersConfig {
+    defaults: ProviderRouting;
+    byRole: Record<string, ProviderRouting>;
+}
+export interface BudgetLimit {
+    maxRequests?: number;
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+    maxTotalTokens?: number;
+    maxEstimatedCostUsd?: number;
+}
+export interface BudgetPolicy {
+    defaults?: BudgetLimit;
+    byRole: Record<string, BudgetLimit>;
+    byTask: Record<string, BudgetLimit>;
+}
+export interface WorkflowConfig {
+    version: number;
+    providers: WorkflowProvidersConfig;
+    budgets?: BudgetPolicy;
+    tools: Record<string, ToolConfig>;
+    staticAnalysis: {
+        preCommit: {
+            required: boolean;
+            checks: string[];
+            disallowNoVerifyWithoutApproval: boolean;
+        };
+        ci: {
+            checks: string[];
+        };
+    };
+}
+export interface Workspace {
+    base: string;
+    roles: Role[];
+    roleIds: Set<string>;
+    tasks: Task[];
+    locks: LockEntry[];
+}
+export interface CliOptions {
+    _: string[];
+    [key: string]: string | boolean | string[];
+}
+export interface CliIo {
+    log(message: string): void;
+}
+export interface ReadinessReport {
+    isReady: boolean;
+    missing: string[];
+}
+export interface GateEvaluationContext {
+    task: Task;
+    events: EventEntry[];
+    locks: LockEntry[];
+}
+export interface GateEvaluationResult {
+    gateId: string;
+    passed: boolean;
+    blocking: boolean;
+    summary: string;
+    missing: string[];
+    metadata: Record<string, unknown>;
+}
+export interface WorkflowGate {
+    id: string;
+    description: string;
+    evaluate(context: GateEvaluationContext): GateEvaluationResult;
+}
+export interface WorkflowStatus {
+    tasks: {
+        total: number;
+        byStatus: Record<string, number>;
+        blocked: {
+            id: string;
+            title: string;
+            reason: string;
+        }[];
+    };
+    locks: {
+        total: number;
+    };
+}
+export interface WorkflowSummary {
+    tasks: Task[];
+    locks: LockEntry[];
+    reviews: EventEntry[];
+    evidence: EventEntry[];
+    blockers: Task[];
+    eventCount: number;
+}
+export interface DependencyStatus {
+    id: string;
+    status: TaskStatus;
+    isComplete: boolean;
+}
+export interface DependencyReport {
+    taskId: string;
+    isSatisfied: boolean;
+    dependencies: DependencyStatus[];
+    incomplete: DependencyStatus[];
+}
+export interface TaskGraphReadyItem {
+    id: string;
+    title: string;
+    status: TaskStatus;
+    ownerRole: string;
+}
+export interface TaskGraphBlockedItem extends TaskGraphReadyItem {
+    incomplete: DependencyStatus[];
+}
+export interface TaskGraphLockInfo {
+    id: string;
+    path: string;
+    conflictPath?: string;
+    ownerRole: string;
+    reason: string;
+}
+export interface TaskGraphLockedItem extends TaskGraphReadyItem {
+    locks: TaskGraphLockInfo[];
+}
+export interface TaskGraphCompleteItem {
+    id: string;
+    title: string;
+    status: TaskStatus;
+    ownerRole: string;
+}
+export interface TaskGraphPlan {
+    ready: TaskGraphReadyItem[];
+    blocked: TaskGraphBlockedItem[];
+    locked: TaskGraphLockedItem[];
+    complete: TaskGraphCompleteItem[];
+}
+export interface PullRequestSummary {
+    task: Task;
+    handoffs: EventEntry[];
+    reviews: EventEntry[];
+    evidence: EventEntry[];
+    gates: EventEntry[];
+    locks: LockEntry[];
+    risks: string[];
+    rollout: string;
+    rollback: string;
+}
+export interface PlaywrightScenario {
+    name: string;
+    source: string;
+    pageObject: string;
+    selectors: string[];
+    assertions: string[];
+    evidence: string[];
+}
+export interface PlaywrightTestPlan {
+    taskId: string;
+    title: string;
+    targetUser: string;
+    scenarios: PlaywrightScenario[];
+    fixtures: string[];
+    notes: string[];
+}
+export interface AddTaskInput {
+    id: string;
+    title: string;
+    ownerRole: string;
+    dependencies: string[];
+    backlogItem?: string;
+    goal?: string;
+    scope?: string;
+    acceptanceCriteria?: string[];
+    assumptions?: string[];
+    risks?: string[];
+    paths?: string[];
+    testStrategy?: string;
+    architectureApproval?: ArchitectureApproval;
+    qaGate?: QaGateMetadata;
+    riskGate?: RiskGateMetadata;
+}
+export interface UpdateTaskInput {
+    id: string;
+    status?: TaskStatus;
+    blockedReason?: string;
+}
+export interface ClaimLockInput {
+    id?: string;
+    taskId: string;
+    ownerRole: string;
+    path: string;
+    reason: string;
+    expiresAt?: string;
+}
+export interface HandoffInput {
+    task: string;
+    from: string;
+    to: string;
+    changed: string;
+    behavior: string;
+    tests: string;
+    commands: string;
+    status?: string;
+    gaps?: string;
+    risks?: string;
+    playwright?: string;
+}
+export interface ReviewInput {
+    task: string;
+    role: string;
+    result: string;
+    severity: string;
+    findings: string;
+    recommendation: string;
+}
+export interface EvidenceInput {
+    task: string;
+    role: string;
+    type: string;
+    summary: string;
+    path?: string | boolean | string[];
+    command?: string | boolean | string[];
+    exitCode?: string | boolean | string[];
+}
+export interface PlaywrightEvidenceInput {
+    task: string;
+    kind: "screenshot" | "trace" | "video" | "report";
+    path: string;
+    summary: string;
+    runId?: string;
+}
+export interface ArtifactResult {
+    artifact: string;
+    content: string;
+}
+export interface DecisionInput {
+    task: string;
+    title: string;
+    context: string;
+    decision: string;
+    consequences: string;
+    status: "proposed" | "accepted" | "superseded";
+    owner: string;
+}
+export interface DecisionRecord extends DecisionInput {
+    artifact: string;
+}
+export interface TaskContext {
+    task: Task;
+    dependencies: DependencyReport;
+    locks: LockEntry[];
+    decisions: EventEntry[];
+    handoffs: EventEntry[];
+    reviews: EventEntry[];
+    evidence: EventEntry[];
+    gates: EventEntry[];
+    modelProvenance: ModelProvenanceRecord[];
+    risks: string[];
+}
+export interface ExecutionPlanStep {
+    id: string;
+    role: string;
+    action: string;
+    dependsOn: string[];
+    gate?: string;
+}
+export interface ExecutionPlan {
+    taskId: string;
+    steps: ExecutionPlanStep[];
+}
+export interface ExecutionRunStep {
+    id: string;
+    role: string;
+    status: "completed" | "failed";
+    provider: string;
+    model: string;
+    responseId?: string;
+    artifact?: string;
+    error?: string;
+}
+export interface ExecutionRun {
+    taskId: string;
+    provider: string;
+    model: string;
+    steps: ExecutionRunStep[];
+    budgetEscalation?: BudgetEscalationResult;
+}
+export interface TaskGraphBatchFailure {
+    taskId: string;
+    error: string;
+}
+export interface TaskGraphBatchRun {
+    selectedTaskIds: string[];
+    runs: ExecutionRun[];
+    locked: TaskGraphLockedItem[];
+    failure?: TaskGraphBatchFailure;
+    artifact?: string;
+}
+export interface UsageBreakdown {
+    key: string;
+    requests: number;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    estimatedCostUsd: number;
+}
+export interface UsageReport {
+    taskId?: string;
+    totals: UsageBreakdown;
+    byRole: UsageBreakdown[];
+    byProvider: UsageBreakdown[];
+}
+export interface BudgetViolation {
+    scope: string;
+    metric: string;
+    actual: number;
+    limit: number;
+}
+export interface BudgetCheckResult {
+    taskId?: string;
+    passed: boolean;
+    usage: UsageReport;
+    appliedBudgets: string[];
+    violations: BudgetViolation[];
+}
+export interface BudgetFallbackProposal {
+    fromProvider: string;
+    fromModel: string;
+    toProvider: string;
+    toModel: string;
+    violations: BudgetViolation[];
+    artifact?: string;
+}
+export interface BudgetEscalationDecision {
+    approved: boolean;
+    approver?: string;
+    rationale?: string;
+}
+export interface BudgetEscalationResult {
+    status: "not_required" | "approved" | "rejected";
+    proposal?: BudgetFallbackProposal;
+    approver?: string;
+    rationale?: string;
+    approvalId?: string;
+    approvalSource?: "explicit" | "stored";
+}
+export interface ApprovalRecord {
+    id: string;
+    taskId?: string;
+    artifact: string;
+    status: "pending" | "approved" | "rejected";
+    summary: string;
+    requestedAt?: string;
+    decidedAt?: string;
+    approver?: string;
+    rationale?: string;
+}
+export interface ApprovalDecisionInput {
+    id: string;
+    approver: string;
+    rationale: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/dist/validation.d.ts

@@ -0,0 +1,10 @@
+import type { EvidenceInput, ReadinessReport, ReviewInput, Task } from "./types.js";
+export declare function assertObject(value: unknown, name: string): asserts value is Record<string, unknown>;
+export declare function validateLocks(locks: unknown, taskIds: Set<string>, roleIds: Set<string>): void;
+export declare function taskIdsFor(tasks: Task[]): Set<string>;
+export declare function assertNonEmptyString(value: unknown, name: string): asserts value is string;
+export declare function validateRoles(roles: unknown): Set<string>;
+export declare function validateTasks(tasks: unknown, roleIds: Set<string>): void;
+export declare function validateReviewInput(input: ReviewInput, roleIds: Set<string>): void;
+export declare function validateEvidenceInput(input: EvidenceInput, roleIds: Set<string>): void;
+export declare function validateReadiness(task: Task): ReadinessReport;