@syntesseraai/opencode-feature-factory 0.1.12 → 0.1.13

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@syntesseraai/opencode-feature-factory",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "OpenCode plugin for Feature Factory agents - provides planning, implementation, review, testing, and validation agents",
   "type": "module",
   "license": "MIT",

package/src/stop-quality-gate.ts

@@ -261,23 +261,66 @@ async function runCommand(
   }
 }
 
+/**
+ * Progress callback for real-time feedback
+ */
+type ProgressCallback = (params: {
+  type: 'started' | 'step-complete' | 'step-failed' | 'completed';
+  step?: string;
+  stepIndex?: number;
+  totalSteps?: number;
+  exitCode?: number;
+  results?: StepResult[];
+}) => Promise<void>;
+
 /**
  * Run all command steps sequentially, stopping on first failure
- * Now with progress feedback support!
+ * Provides real-time progress feedback via callback
  */
 async function runAllCommands(
   $: BunShell,
   steps: { step: string; cmd: string }[],
-  cwd: string
+  cwd: string,
+  onProgress: ProgressCallback
 ): Promise<StepResult[]> {
   const results: StepResult[] = [];
 
-  for (const { step, cmd } of steps) {
+  // Report started before running any commands
+  await onProgress({
+    type: 'started',
+    totalSteps: steps.length,
+  });
+
+  for (let i = 0; i < steps.length; i++) {
+    const { step, cmd } = steps[i];
     const { exitCode, output } = await runCommand($, cmd, cwd);
-    results.push({ step, cmd, exitCode, output });
+    const result = { step, cmd, exitCode, output };
+    results.push(result);
+
+    if (exitCode !== 0) {
+      await onProgress({
+        type: 'step-failed',
+        step,
+        stepIndex: i + 1,
+        totalSteps: steps.length,
+        exitCode,
+      });
+      break;
+    }
+
+    await onProgress({
+      type: 'step-complete',
+      step,
+      stepIndex: i + 1,
+      totalSteps: steps.length,
+    });
+  }
 
-    // Stop on first failure
-    if (exitCode !== 0) break;
+  if (results.every((r) => r.exitCode === 0)) {
+    await onProgress({
+      type: 'completed',
+      results,
+    });
   }
 
   return results;
@@ -437,7 +480,51 @@ export async function createQualityGateHooks(input: PluginInput): Promise<Partia
 
       if (state.dirty || cacheExpired || results.length === 0) {
         const startTime = Date.now();
-        results = await runAllCommands($, plan, cwd);
+        results = await runAllCommands($, plan, cwd, async (progress) => {
+          switch (progress.type) {
+            case 'started':
+              await client.session.prompt({
+                path: { id: sessionId },
+                body: {
+                  parts: [
+                    {
+                      type: 'text',
+                      text: `## Running quality gate${progress.totalSteps ? ` (${progress.totalSteps} steps)` : ''}...`,
+                    },
+                  ],
+                },
+              });
+              break;
+            case 'step-complete':
+              await client.session.prompt({
+                path: { id: sessionId },
+                body: {
+                  parts: [
+                    {
+                      type: 'text',
+                      text: `## Quality gate progress: ${progress.step} ✓ (${progress.stepIndex}/${progress.totalSteps})`,
+                    },
+                  ],
+                },
+              });
+              break;
+            case 'step-failed':
+              await client.session.prompt({
+                path: { id: sessionId },
+                body: {
+                  parts: [
+                    {
+                      type: 'text',
+                      text: `## Quality gate failed: ${progress.step} ✗ (${progress.stepIndex}/${progress.totalSteps})`,
+                    },
+                  ],
+                },
+              });
+              break;
+            case 'completed':
+              break;
+          }
+        });
         const durationMs = Date.now() - startTime;
 
         state.lastResults = results;