@dv.nghiem/flowdeck 0.1.0

package/dist/commands/analysis/analyze-change.d.ts

@@ -0,0 +1,148 @@
+/**
+ * /fd-analyze-change — umbrella analysis command
+ *
+ * Combines: impact radar, blast radius, regression prediction,
+ * test gap detection, volatility map, and reviewer routing into a
+ * single consolidated pre-change report.
+ *
+ * Replaces individual: /fd-impact-radar, /fd-blast-radius,
+ * /fd-regression-predict, /fd-test-gap, /fd-volatility-map, /fd-review-route
+ */
+export interface AnalyzeChangeArgs {
+    change?: string;
+    scope?: string;
+    files?: string;
+    depth?: string;
+    impact?: boolean;
+    "blast-radius"?: boolean;
+    regression?: boolean;
+    "test-gap"?: boolean;
+    volatility?: boolean;
+    "review-route"?: boolean;
+    all?: boolean;
+    json?: boolean;
+}
+export declare const analyzeChangeCommand: {
+    name: string;
+    description: string;
+    execute(context: any, args?: AnalyzeChangeArgs): Promise<{
+        error: string;
+        code: string;
+        success?: undefined;
+        data?: undefined;
+        meta?: undefined;
+        message?: undefined;
+        modules_run?: undefined;
+        affected_zones?: undefined;
+        recommended_reviewers?: undefined;
+        risk_summary?: undefined;
+        risk_score?: undefined;
+        config?: undefined;
+        phase?: undefined;
+    } | {
+        success: boolean;
+        data: {
+            modules_run: string[];
+            affected_zones: string[];
+            regression_categories: string[];
+            test_gap_types: string[];
+            recommended_reviewers: string[];
+            risk_summary: string;
+            risk_score: number;
+            config: {
+                change_description: string;
+                scope: string;
+                files: string[];
+                modules_run: string[];
+                agents: (false | {
+                    name: string;
+                    role: string;
+                })[];
+                data: {
+                    hotspots: string[];
+                    known_failures: string[];
+                    related_modules: string[];
+                    volatile_zones: {
+                        path: string;
+                        stability: string;
+                    }[];
+                    fragile_patterns: number;
+                    repo_memory_nodes: number;
+                    regression_categories: string[];
+                    past_regression_signals: string[];
+                    test_gap_types: string[];
+                    recommended_reviewers: string[];
+                    trust_score: number | null;
+                    trust_verdict: string;
+                    prior_failures: string[];
+                };
+                risk_score: number;
+                risk_summary: string;
+                traversal_depth: number;
+            };
+            phase: number;
+        };
+        meta: {
+            formatted: string;
+            timestamp: string;
+        };
+        error?: undefined;
+        code?: undefined;
+        message?: undefined;
+        modules_run?: undefined;
+        affected_zones?: undefined;
+        recommended_reviewers?: undefined;
+        risk_summary?: undefined;
+        risk_score?: undefined;
+        config?: undefined;
+        phase?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        modules_run: string[];
+        affected_zones: string[];
+        recommended_reviewers: string[];
+        risk_summary: string;
+        risk_score: number;
+        config: {
+            change_description: string;
+            scope: string;
+            files: string[];
+            modules_run: string[];
+            agents: (false | {
+                name: string;
+                role: string;
+            })[];
+            data: {
+                hotspots: string[];
+                known_failures: string[];
+                related_modules: string[];
+                volatile_zones: {
+                    path: string;
+                    stability: string;
+                }[];
+                fragile_patterns: number;
+                repo_memory_nodes: number;
+                regression_categories: string[];
+                past_regression_signals: string[];
+                test_gap_types: string[];
+                recommended_reviewers: string[];
+                trust_score: number | null;
+                trust_verdict: string;
+                prior_failures: string[];
+            };
+            risk_score: number;
+            risk_summary: string;
+            traversal_depth: number;
+        };
+        phase: number;
+        meta: {
+            formatted: string;
+            timestamp: string;
+        };
+        error?: undefined;
+        code?: undefined;
+        data?: undefined;
+    }>;
+};
+//# sourceMappingURL=analyze-change.d.ts.map

package/dist/commands/analysis/analyze-change.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-change.d.ts","sourceRoot":"","sources":["../../../src/commands/analysis/analyze-change.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAmCH,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,IAAI,CAAC,EAAE,OAAO,CAAA;CACf;AAED,eAAO,MAAM,oBAAoB;;;qBAGR,GAAG,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAoFjB,MAAM;mCAAa,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAzB,MAAM;+BAAa,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;CAwI7D,CAAA"}

package/dist/commands/analysis/evaluate-risk.d.ts

@@ -0,0 +1,77 @@
+/**
+ * /fd-evaluate-risk — standalone risk assessment command
+ *
+ * Estimates change risk, confidence, likely regressions, whether
+ * approval is needed, and suggests safer alternatives when risk is high.
+ *
+ * Works without a --file if --change is provided (keyword-based analysis).
+ */
+type RiskLevel = "low" | "medium" | "high" | "critical";
+export declare const evaluateRiskCommand: {
+    name: string;
+    description: string;
+    execute(context: any, args?: {
+        change?: string;
+        file?: string;
+        volatility?: boolean;
+        confidence?: boolean;
+        "risk-score"?: boolean;
+        json?: boolean;
+    }): Promise<{
+        error: string;
+        code: string;
+        success?: undefined;
+        data?: undefined;
+        meta?: undefined;
+    } | {
+        success: boolean;
+        data: {
+            agents: ({
+                name: string;
+                role: string;
+            } | null)[];
+            phase: number;
+            risk_score: number;
+            risk_level: RiskLevel;
+            confidence: number;
+            approval_needed: boolean;
+            likely_regressions: string[];
+            volatile_zones: number;
+            volatile_matches: string[];
+            safer_alternative: string | null;
+            trust_signals: string[];
+        };
+        meta: {
+            formatted: string;
+            timestamp: string;
+        };
+        error?: undefined;
+        code?: undefined;
+    } | {
+        agents: ({
+            name: string;
+            role: string;
+        } | null)[];
+        phase: number;
+        meta: {
+            formatted: string;
+            timestamp: string;
+        };
+        risk_score: number;
+        risk_level: RiskLevel;
+        confidence: number;
+        approval_needed: boolean;
+        likely_regressions: string[];
+        volatile_zones: number;
+        volatile_matches: string[];
+        safer_alternative: string | null;
+        trust_signals: string[];
+        success: boolean;
+        message: string;
+        error?: undefined;
+        code?: undefined;
+        data?: undefined;
+    }>;
+};
+export {};
+//# sourceMappingURL=evaluate-risk.d.ts.map

package/dist/commands/analysis/evaluate-risk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-risk.d.ts","sourceRoot":"","sources":["../../../src/commands/analysis/evaluate-risk.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAiCH,KAAK,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAA;AAuDvD,eAAO,MAAM,mBAAmB;;;qBAGP,GAAG,SAAS;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2I1J,CAAA"}

package/dist/commands/analysis/guarded-edit.d.ts

@@ -0,0 +1,72 @@
+/**
+ * /fd-guarded-edit — edit gate command
+ *
+ * Runs before a risky edit to determine whether to:
+ *   auto-approve    → safe to apply without confirmation
+ *   require-confirmation → apply with inline warning and human ACK
+ *   require-review  → route to a human reviewer before applying
+ *   block           → do not apply; violation of arch constraint or critical policy
+ *
+ * Combines: policy engine, patch trust score, volatility, arch constraints,
+ * failure history, and safe execution mode resolution.
+ */
+export type GateDecision = "auto-approve" | "require-confirmation" | "require-review" | "block";
+export interface GuardedEditResult {
+    decision: GateDecision;
+    reason: string;
+    risk_score: number;
+    execution_mode: "auto" | "guarded" | "review-only";
+    policy_violations: string[];
+    volatile_files: string[];
+    prior_failures: string[];
+    arch_constraint: boolean;
+    recommended_action: string;
+}
+export declare const guardedEditCommand: {
+    name: string;
+    description: string;
+    execute(context: any, args?: {
+        file?: string;
+        change?: string;
+        "dry-run"?: boolean;
+        json?: boolean;
+    }): Promise<{
+        error: string;
+        code: string;
+        hint: string;
+        success?: undefined;
+        data?: undefined;
+        meta?: undefined;
+    } | {
+        success: boolean;
+        data: GuardedEditResult;
+        meta: {
+            formatted: string;
+            timestamp: string;
+        };
+        error?: undefined;
+        code?: undefined;
+        hint?: undefined;
+    } | {
+        meta: {
+            formatted: string;
+            timestamp: string;
+        };
+        decision: GateDecision;
+        reason: string;
+        risk_score: number;
+        execution_mode: "auto" | "guarded" | "review-only";
+        policy_violations: string[];
+        volatile_files: string[];
+        prior_failures: string[];
+        arch_constraint: boolean;
+        recommended_action: string;
+        success: boolean;
+        message: string;
+        error?: undefined;
+        code?: undefined;
+        hint?: undefined;
+        data?: undefined;
+    }>;
+};
+//# sourceMappingURL=guarded-edit.d.ts.map

package/dist/commands/analysis/guarded-edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guarded-edit.d.ts","sourceRoot":"","sources":["../../../src/commands/analysis/guarded-edit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AASH,MAAM,MAAM,YAAY,GAAG,cAAc,GAAG,sBAAsB,GAAG,gBAAgB,GAAG,OAAO,CAAA;AAE/F,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,YAAY,CAAA;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,CAAA;IAClD,iBAAiB,EAAE,MAAM,EAAE,CAAA;IAC3B,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,eAAe,EAAE,OAAO,CAAA;IACxB,kBAAkB,EAAE,MAAM,CAAA;CAC3B;AAqFD,eAAO,MAAM,kBAAkB;;;qBAGN,GAAG,SAAS;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;kBAjGhG,YAAY;gBACd,MAAM;oBACF,MAAM;wBACF,MAAM,GAAG,SAAS,GAAG,aAAa;2BAC/B,MAAM,EAAE;wBACX,MAAM,EAAE;wBACR,MAAM,EAAE;yBACP,OAAO;4BACJ,MAAM;;;;;;;;CAyM3B,CAAA"}

package/dist/commands/execution/deploy-check.d.ts

@@ -0,0 +1,91 @@
+import type { CommandContext } from "../../types/command-context";
+export declare const deployCheckCommand: {
+    name: string;
+    description: string;
+    execute(context: CommandContext, args?: {
+        json?: boolean;
+    }): Promise<{
+        error: string;
+        code: string;
+        success?: undefined;
+        data?: undefined;
+        meta?: undefined;
+        message?: undefined;
+        workflow?: undefined;
+        config?: undefined;
+        phase?: undefined;
+    } | {
+        success: boolean;
+        data: {
+            workflow: string;
+            config: {
+                agents: {
+                    name: string;
+                    budget: number;
+                    action: string;
+                }[];
+                parallel: boolean;
+                aggregation: {
+                    go_signals: string[];
+                    no_go_signals: string[];
+                };
+                decision: {
+                    go: string;
+                    no_go: string;
+                };
+                tdd_aware_checks: {
+                    new_feature_changes_have_tests: string;
+                    bugfix_has_regression_coverage: string;
+                    no_suspicious_test_omissions: string;
+                    overrides_logged: string;
+                };
+            };
+            phase: number;
+        };
+        meta: {
+            formatted: string;
+            timestamp: string;
+        };
+        error?: undefined;
+        code?: undefined;
+        message?: undefined;
+        workflow?: undefined;
+        config?: undefined;
+        phase?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        workflow: string;
+        config: {
+            agents: {
+                name: string;
+                budget: number;
+                action: string;
+            }[];
+            parallel: boolean;
+            aggregation: {
+                go_signals: string[];
+                no_go_signals: string[];
+            };
+            decision: {
+                go: string;
+                no_go: string;
+            };
+            tdd_aware_checks: {
+                new_feature_changes_have_tests: string;
+                bugfix_has_regression_coverage: string;
+                no_suspicious_test_omissions: string;
+                overrides_logged: string;
+            };
+        };
+        phase: number;
+        meta: {
+            formatted: string;
+            timestamp: string;
+        };
+        error?: undefined;
+        code?: undefined;
+        data?: undefined;
+    }>;
+};
+//# sourceMappingURL=deploy-check.d.ts.map

package/dist/commands/execution/deploy-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy-check.d.ts","sourceRoot":"","sources":["../../../src/commands/execution/deploy-check.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAIjE,eAAO,MAAM,kBAAkB;;;qBAGN,cAAc,SAAS;QAAE,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4EjE,CAAA"}

package/dist/commands/execution/fix-bug.d.ts

@@ -0,0 +1,187 @@
+import type { CommandContext } from "../../types/command-context";
+export declare const fixBugCommand: {
+    name: string;
+    description: string;
+    execute(context: CommandContext, args?: {
+        scope?: string;
+        bug?: string;
+        json?: boolean;
+    }): Promise<{
+        error: string;
+        code: string;
+        hint?: undefined;
+        success?: undefined;
+        data?: undefined;
+        meta?: undefined;
+        message?: undefined;
+        workflow?: undefined;
+        config?: undefined;
+        phase?: undefined;
+        impact_radar?: undefined;
+        prior_failures?: undefined;
+    } | {
+        error: string;
+        code: string;
+        hint: string;
+        success?: undefined;
+        data?: undefined;
+        meta?: undefined;
+        message?: undefined;
+        workflow?: undefined;
+        config?: undefined;
+        phase?: undefined;
+        impact_radar?: undefined;
+        prior_failures?: undefined;
+    } | {
+        success: boolean;
+        data: {
+            workflow: string;
+            config: {
+                phases: ({
+                    step: number;
+                    name: string;
+                    agent: string;
+                    action: string;
+                    mode?: undefined;
+                    require_regression_pass?: undefined;
+                    tool?: undefined;
+                    tool_action?: undefined;
+                } | {
+                    step: number;
+                    name: string;
+                    agent: string;
+                    action: string;
+                    mode: string;
+                    require_regression_pass?: undefined;
+                    tool?: undefined;
+                    tool_action?: undefined;
+                } | {
+                    step: number;
+                    name: string;
+                    agent: string;
+                    action: string;
+                    require_regression_pass: boolean;
+                    mode?: undefined;
+                    tool?: undefined;
+                    tool_action?: undefined;
+                } | {
+                    step: number;
+                    name: string;
+                    agent: string;
+                    action: string;
+                    tool: string;
+                    tool_action: string;
+                    mode?: undefined;
+                    require_regression_pass?: undefined;
+                })[];
+                run_id: string;
+                scope: string;
+                architecture_context: string | null;
+                impact_radar: import("../../lib/impact-radar").ImpactRadarResult;
+                prior_failures: {
+                    id: string;
+                    type: "reverted_commit" | "failed_deployment" | "flaky_test" | "bug_fix" | "build_failure";
+                    description: string;
+                    affected_paths: string[];
+                    root_cause: string | null;
+                    fix_applied: string | null;
+                    recurrence_count: number;
+                }[];
+                policy_violations: import("../../services").PolicyViolation[];
+                proposed_policies: (import("../../services").ProposedPolicy | null)[];
+            };
+            phase: number;
+        };
+        meta: {
+            formatted: string;
+            timestamp: string;
+        };
+        error?: undefined;
+        code?: undefined;
+        hint?: undefined;
+        message?: undefined;
+        workflow?: undefined;
+        config?: undefined;
+        phase?: undefined;
+        impact_radar?: undefined;
+        prior_failures?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        workflow: string;
+        config: {
+            phases: ({
+                step: number;
+                name: string;
+                agent: string;
+                action: string;
+                mode?: undefined;
+                require_regression_pass?: undefined;
+                tool?: undefined;
+                tool_action?: undefined;
+            } | {
+                step: number;
+                name: string;
+                agent: string;
+                action: string;
+                mode: string;
+                require_regression_pass?: undefined;
+                tool?: undefined;
+                tool_action?: undefined;
+            } | {
+                step: number;
+                name: string;
+                agent: string;
+                action: string;
+                require_regression_pass: boolean;
+                mode?: undefined;
+                tool?: undefined;
+                tool_action?: undefined;
+            } | {
+                step: number;
+                name: string;
+                agent: string;
+                action: string;
+                tool: string;
+                tool_action: string;
+                mode?: undefined;
+                require_regression_pass?: undefined;
+            })[];
+            run_id: string;
+            scope: string;
+            architecture_context: string | null;
+            impact_radar: import("../../lib/impact-radar").ImpactRadarResult;
+            prior_failures: {
+                id: string;
+                type: "reverted_commit" | "failed_deployment" | "flaky_test" | "bug_fix" | "build_failure";
+                description: string;
+                affected_paths: string[];
+                root_cause: string | null;
+                fix_applied: string | null;
+                recurrence_count: number;
+            }[];
+            policy_violations: import("../../services").PolicyViolation[];
+            proposed_policies: (import("../../services").ProposedPolicy | null)[];
+        };
+        phase: number;
+        impact_radar: import("../../lib/impact-radar").ImpactRadarResult;
+        prior_failures: {
+            id: string;
+            type: "reverted_commit" | "failed_deployment" | "flaky_test" | "bug_fix" | "build_failure";
+            description: string;
+            affected_paths: string[];
+            root_cause: string | null;
+            fix_applied: string | null;
+            recurrence_count: number;
+        }[];
+        meta: {
+            formatted: string;
+            timestamp: string;
+        };
+        error?: undefined;
+        code?: undefined;
+        hint?: undefined;
+        data?: undefined;
+    }>;
+};
+//# sourceMappingURL=fix-bug.d.ts.map

package/dist/commands/execution/fix-bug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fix-bug.d.ts","sourceRoot":"","sources":["../../../src/commands/execution/fix-bug.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAEjE,eAAO,MAAM,aAAa;;;qBAGD,cAAc,SAAS;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqK/F,CAAA"}