@syntesseraai/opencode-feature-factory 0.6.21 → 0.7.0

package/dist/workflow/gate-evaluator.js

@@ -0,0 +1,118 @@
+/**
+ * Deterministic gate evaluation functions.
+ *
+ * These replace the LLM-evaluated gate commands with code that applies
+ * threshold logic directly. The LLM still produces the synthesis; the
+ * gate decision is computed here.
+ */
+// ---------------------------------------------------------------------------
+// Planning gate
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate the planning consensus gate.
+ *
+ * - `>=75` consensus score → APPROVED
+ * - `50-74` → REWORK
+ * - `<50`   → BLOCKED
+ */
+export function evaluatePlanningGate(consensus) {
+    if (consensus.consensusScore >= 75) {
+        return { decision: 'APPROVED' };
+    }
+    if (consensus.consensusScore >= 50) {
+        return {
+            decision: 'REWORK',
+            feedback: `Consensus score ${consensus.consensusScore}/100. Divergent elements:\n${consensus.divergentElements}\nOpen questions:\n${consensus.openQuestions}`,
+        };
+    }
+    return {
+        decision: 'BLOCKED',
+        reason: `Consensus score too low (${consensus.consensusScore}/100). Open questions:\n${consensus.openQuestions}`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Review gate
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate the review approval gate.
+ *
+ * - confidence >=95 AND unresolvedIssues == 0 → APPROVED
+ * - iteration >= maxIterations → ESCALATE
+ * - otherwise → REWORK
+ */
+export function evaluateReviewGate(synthesis, iteration, maxIterations = 10) {
+    if (synthesis.overallConfidence >= 95 && synthesis.unresolvedIssues === 0) {
+        return { decision: 'APPROVED' };
+    }
+    if (iteration >= maxIterations) {
+        return {
+            decision: 'ESCALATE',
+            reason: `Max review iterations reached (${maxIterations}). Confidence: ${synthesis.overallConfidence}, unresolved: ${synthesis.unresolvedIssues}`,
+        };
+    }
+    return {
+        decision: 'REWORK',
+        feedback: synthesis.reworkInstructions ??
+            `Confidence ${synthesis.overallConfidence}/100 with ${synthesis.unresolvedIssues} unresolved issues.`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Documentation gate
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate the documentation approval gate.
+ *
+ * - confidence >95, no change requested, 0 unresolved → APPROVED
+ * - iteration >= maxIterations → ESCALATE
+ * - otherwise → REWORK
+ */
+export function evaluateDocGate(review, iteration, maxIterations = 5) {
+    if (review.verdict === 'APPROVED' && review.unresolvedIssues === 0 && review.confidence > 95) {
+        return { decision: 'APPROVED' };
+    }
+    if (iteration >= maxIterations) {
+        return {
+            decision: 'ESCALATE',
+            reason: `Max doc iterations reached (${maxIterations}). Confidence: ${review.confidence}, unresolved: ${review.unresolvedIssues}`,
+        };
+    }
+    return {
+        decision: 'REWORK',
+        feedback: review.reworkInstructions ??
+            `Documentation review verdict: ${review.verdict}. ${review.unresolvedIssues} unresolved issues.`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Mini-loop implementation gate
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate the mini-loop implementation gate.
+ *
+ * - confidence >95, no change requested, 0 blocking issues → APPROVED
+ * - iteration >= maxIterations → ESCALATE
+ * - otherwise → REWORK
+ */
+export function evaluateMiniLoopImplGate(review, iteration, maxIterations = 10) {
+    if (review.confidence > 95 && !review.changeRequested && review.unresolvedIssues === 0) {
+        return { decision: 'APPROVED' };
+    }
+    if (iteration >= maxIterations) {
+        return {
+            decision: 'ESCALATE',
+            reason: `Max mini-loop iterations reached (${maxIterations}). Confidence: ${review.confidence}, unresolved: ${review.unresolvedIssues}`,
+        };
+    }
+    return {
+        decision: 'REWORK',
+        feedback: review.reworkInstructions ??
+            `Change requested: ${review.changeRequested}, confidence: ${review.confidence}, unresolved: ${review.unresolvedIssues}`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Mini-loop documentation gate
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate the mini-loop documentation gate.
+ * Same thresholds as the pipeline doc gate.
+ */
+export const evaluateMiniLoopDocGate = evaluateDocGate;

package/dist/workflow/orchestrator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared workflow orchestration utilities.
+ *
+ * Re-exports the fan-out, gate, and type modules as a single convenient
+ * entry-point for tool implementations.
+ */
+export { fanOut, promptSession, extractText, type Client } from './fan-out.js';
+export { evaluatePlanningGate, evaluateReviewGate, evaluateDocGate, evaluateMiniLoopImplGate, evaluateMiniLoopDocGate, } from './gate-evaluator.js';
+export * from './types.js';

package/dist/workflow/orchestrator.js

@@ -0,0 +1,9 @@
+/**
+ * Shared workflow orchestration utilities.
+ *
+ * Re-exports the fan-out, gate, and type modules as a single convenient
+ * entry-point for tool implementations.
+ */
+export { fanOut, promptSession, extractText } from './fan-out.js';
+export { evaluatePlanningGate, evaluateReviewGate, evaluateDocGate, evaluateMiniLoopImplGate, evaluateMiniLoopDocGate, } from './gate-evaluator.js';
+export * from './types.js';

package/dist/workflow/types.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Workflow type definitions for the Feature Factory pipeline and mini-loop.
+ *
+ * These types represent the structured data that flows between phases
+ * of the workflow, replacing the untyped $RESULT[name] string interpolation
+ * used by the subtask2 command approach.
+ */
+/** A model identifier split into provider and model parts. */
+export interface ModelId {
+    providerID: string;
+    modelID: string;
+}
+/** Named model configuration used for fan-out. */
+export interface NamedModel {
+    /** Human label used in prompts and logs (e.g. "opus", "gemini", "codex") */
+    tag: string;
+    /** Provider/model split consumed by the SDK. */
+    model: ModelId;
+}
+export declare const PLANNING_MODELS: readonly NamedModel[];
+export declare const REVIEW_MODELS: readonly NamedModel[];
+export declare const ORCHESTRATOR_MODEL: ModelId;
+export declare const BUILD_MODEL: ModelId;
+export declare const DOC_MODEL: ModelId;
+export declare const VALIDATE_MODEL: ModelId;
+export declare const DOC_REVIEW_MODEL: ModelId;
+export type GateDecision = 'APPROVED' | 'REWORK' | 'BLOCKED' | 'ESCALATE';
+export interface GateResult {
+    decision: GateDecision;
+    /** Feedback for the next loop iteration when decision is REWORK. */
+    feedback?: string;
+    /** Reason the gate blocked or escalated. */
+    reason?: string;
+}
+export interface PlanProposal {
+    tag: string;
+    requirementsSummary: string;
+    architectureValidation: string;
+    implementationSteps: string;
+    risksAndMitigations: string;
+    testingStrategy: string;
+    /** The full raw text returned by the model (kept for transparency). */
+    raw: string;
+}
+export interface ConsensusPlan {
+    consensusScore: number;
+    agreedElements: string;
+    divergentElements: string;
+    synthesizedPlan: string;
+    openQuestions: string;
+    raw: string;
+}
+export interface PlanningPhaseResult {
+    proposals: PlanProposal[];
+    consensus: ConsensusPlan;
+    gate: GateResult;
+    /** The final plan text accepted by the gate (only set when APPROVED). */
+    finalPlan?: string;
+}
+export interface TaskBreakdown {
+    taskId: string;
+    title: string;
+    description: string;
+    targetFiles: string[];
+    dependencies: string[];
+    acceptanceCriteria: string;
+}
+export interface ValidatedBatch {
+    batchId: string;
+    tasks: TaskBreakdown[];
+    parallelizable: boolean;
+    architecturalRisks: string[];
+}
+export interface ImplementationReport {
+    filesChanged: string[];
+    testsRun: string[];
+    testsPassed: boolean;
+    openIssues: string[];
+    raw: string;
+}
+export interface BuildPhaseResult {
+    tasks: TaskBreakdown[];
+    batches: ValidatedBatch[];
+    implementation: ImplementationReport;
+}
+export interface ReviewReport {
+    tag: string;
+    findings: string;
+    confidence: number;
+    raw: string;
+}
+export interface ReviewSynthesis {
+    overallConfidence: number;
+    consolidatedFindings: string;
+    unresolvedIssues: number;
+    verdict: 'APPROVED' | 'REWORK_REQUIRED';
+    reworkInstructions?: string;
+    raw: string;
+}
+export interface ReviewPhaseResult {
+    reviews: ReviewReport[];
+    synthesis: ReviewSynthesis;
+    gate: GateResult;
+}
+export interface DocUpdate {
+    filesChanged: string[];
+    rationale: string;
+    raw: string;
+}
+export interface DocReview {
+    verdict: 'APPROVED' | 'REWORK_REQUIRED';
+    unresolvedIssues: number;
+    confidence: number;
+    reworkInstructions?: string;
+    raw: string;
+}
+export interface DocPhaseResult {
+    update: DocUpdate;
+    review: DocReview;
+    gate: GateResult;
+}
+export interface PipelineState {
+    requirements: string;
+    planning?: PlanningPhaseResult;
+    build?: BuildPhaseResult;
+    review?: ReviewPhaseResult;
+    documentation?: DocPhaseResult;
+}
+export interface MiniLoopState {
+    requirements: string;
+    implementation?: ImplementationReport;
+    review?: {
+        confidence: number;
+        changeRequested: boolean;
+        unresolvedIssues: number;
+        reworkInstructions?: string;
+        raw: string;
+    };
+    documentation?: DocPhaseResult;
+}
+/** Parse "provider/model" string into a ModelId. */
+export declare function parseModelString(s: string): ModelId;
+/**
+ * Parse a comma-separated list of `tag:provider/model` entries into NamedModel[].
+ *
+ * Example input: `"opus:anthropic/claude-opus-4-6, gemini:google/gemini-2.5-pro"`
+ */
+export declare function parseNamedModels(s: string): NamedModel[];

package/dist/workflow/types.js

@@ -0,0 +1,62 @@
+/**
+ * Workflow type definitions for the Feature Factory pipeline and mini-loop.
+ *
+ * These types represent the structured data that flows between phases
+ * of the workflow, replacing the untyped $RESULT[name] string interpolation
+ * used by the subtask2 command approach.
+ */
+// ---------------------------------------------------------------------------
+// Default model roster
+// ---------------------------------------------------------------------------
+export const PLANNING_MODELS = [
+    { tag: 'opus', model: { providerID: 'anthropic', modelID: 'claude-opus-4-6' } },
+    { tag: 'gemini', model: { providerID: 'opencode', modelID: 'gemini-3.1-pro' } },
+    { tag: 'codex', model: { providerID: 'openai', modelID: 'gpt-5.3-codex' } },
+];
+export const REVIEW_MODELS = PLANNING_MODELS;
+export const ORCHESTRATOR_MODEL = {
+    providerID: 'openai',
+    modelID: 'gpt-5.4',
+};
+export const BUILD_MODEL = {
+    providerID: 'openai',
+    modelID: 'gpt-5.3-codex',
+};
+export const DOC_MODEL = BUILD_MODEL;
+export const VALIDATE_MODEL = {
+    providerID: 'opencode',
+    modelID: 'gemini-3.1-pro',
+};
+export const DOC_REVIEW_MODEL = VALIDATE_MODEL;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Parse "provider/model" string into a ModelId. */
+export function parseModelString(s) {
+    const slash = s.indexOf('/');
+    if (slash === -1)
+        return { providerID: s, modelID: s };
+    return { providerID: s.slice(0, slash), modelID: s.slice(slash + 1) };
+}
+/**
+ * Parse a comma-separated list of `tag:provider/model` entries into NamedModel[].
+ *
+ * Example input: `"opus:anthropic/claude-opus-4-6, gemini:google/gemini-2.5-pro"`
+ */
+export function parseNamedModels(s) {
+    return s
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0)
+        .map((entry) => {
+        const colon = entry.indexOf(':');
+        if (colon === -1) {
+            // No tag — use the model id as the tag
+            const model = parseModelString(entry);
+            return { tag: model.modelID, model };
+        }
+        const tag = entry.slice(0, colon).trim();
+        const model = parseModelString(entry.slice(colon + 1).trim());
+        return { tag, model };
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@syntesseraai/opencode-feature-factory",
-  "version": "0.6.21",
+  "version": "0.7.0",
   "type": "module",
   "description": "OpenCode plugin for Feature Factory agents - provides sub-agents and skills for validation, review, security, and architecture assessment",
   "license": "MIT",