spets 0.1.65 → 0.1.67

package/dist/index.js

@@ -943,50 +943,32 @@ function buildClarifyPrompt(params) {
   parts.push("");
   parts.push(params.gatheredContext);
   parts.push("");
-  if (params.previousQA && params.previousQA.length > 0) {
-    const unresolvedEntries = params.previousQA.filter((e) => !e.question.resolved);
-    const resolvedEntries = params.previousQA.filter((e) => e.question.resolved);
-    if (unresolvedEntries.length > 0) {
-      parts.push("## Unresolved Questions");
-      parts.push("");
-      parts.push("The user indicated confusion on these questions. Re-ask with a clearer explanation:");
-      parts.push("");
-      for (const entry of unresolvedEntries) {
-        parts.push(`**Original Question:** ${entry.question.question}`);
-        if (entry.question.context) {
-          parts.push(`Context: ${entry.question.context}`);
-        }
-        parts.push(`**User Response:** "${entry.answer.answer}"`);
-        parts.push("");
-        parts.push("\u2192 Re-ask this question with simpler language, concrete examples, or more context.");
-        parts.push("");
-      }
-    }
-    if (resolvedEntries.length > 0) {
-      parts.push("## Previous Questions & Answers");
-      parts.push("");
-      parts.push("The following questions have been resolved:");
-      parts.push("");
-      for (const entry of resolvedEntries) {
-        parts.push(`**Q: ${entry.question.question}**`);
-        if (entry.question.context) {
-          parts.push(`Context: ${entry.question.context}`);
-        }
-        parts.push(`A: ${entry.answer.answer}`);
-        parts.push("");
-      }
-      parts.push("Based on these answers, determine if there are still ambiguities that need clarification.");
-      parts.push("Do NOT repeat questions that have already been resolved.");
+  const hasQAHistory = params.previousQA && params.previousQA.length > 0;
+  if (hasQAHistory) {
+    parts.push("## Previous Q&A");
+    parts.push("");
+    for (const entry of params.previousQA) {
+      parts.push(`**Q:** ${entry.question.question}`);
+      parts.push(`**A:** ${entry.answer.answer}`);
       parts.push("");
     }
+    parts.push("## Your Task");
+    parts.push("");
+    parts.push("For each Q&A above, judge if the question is resolved:");
+    parts.push("- Clear answer \u2192 resolved, do NOT re-ask");
+    parts.push('- "you decide" / "\uC54C\uC544\uC11C \uD574" \u2192 resolved, use your judgment');
+    parts.push('- "give options" / "\uC635\uC158 \uC918" \u2192 NOT resolved, re-ask WITH concrete options');
+    parts.push("- Confused / unclear \u2192 NOT resolved, re-ask simpler");
+    parts.push("");
+    parts.push("Only output questions that are NOT resolved. Do NOT ask new questions.");
+    parts.push("");
+  } else {
+    parts.push("## Consider");
+    parts.push("");
+    parts.push("1. Is the task clear enough to proceed?");
+    parts.push("2. Are there ambiguities that need user decision?");
+    parts.push("");
   }
-  parts.push("## Consider These Questions");
-  parts.push("");
-  parts.push("1. Is the task description clear enough to proceed?");
-  parts.push("2. Are there multiple valid approaches that need user decision?");
-  parts.push("3. Are there ambiguities that could lead to wrong implementation?");
-  parts.push("4. Are there missing requirements or constraints?");
-  parts.push("");
   parts.push("## Output Format");
   parts.push("");
   parts.push("Output a JSON object with questions array:");
@@ -1655,30 +1637,10 @@ ${issues}`;
     this.saveState(state);
     return this.responsePhaseExecute(state);
   }
-  /**
-   * Check if an answer indicates user confusion
-   */
-  isConfusedAnswer(answer) {
-    const confusionPatterns = [
-      /don'?t understand/i,
-      /not sure/i,
-      /unclear/i,
-      /what do you mean/i,
-      /i'?m confused/i,
-      /can you explain/i,
-      /뭔 말/i,
-      /이해가 안/i,
-      /모르겠/i,
-      /무슨 말/i,
-      /잘 모르/i
-    ];
-    return confusionPatterns.some((p) => p.test(answer));
-  }
   /**
    * Human answered questions
-   * - Mark questions as resolved if answer is clear
-   * - Keep questions unresolved if user indicates confusion
-   * - Re-ask unresolved questions until all are resolved
+   * - Store Q&A in history
+   * - Loop back to clarify phase - AI will judge if answers resolved the questions
    */
   cmdClarified(taskId, answers) {
     const state = this.loadState(taskId);
@@ -1686,23 +1648,11 @@ ${issues}`;
       return this.responseError(`No workflow found: ${taskId}`, taskId);
     }
     const questions = state.questions || [];
-    for (const answer of answers) {
-      const question = questions.find((q) => q.id === answer.questionId);
-      if (question) {
-        question.resolved = !this.isConfusedAnswer(answer.answer);
-      }
-    }
     const newEntries = questions.map((q, i) => ({
       question: q,
       answer: answers[i] || { questionId: q.id, answer: "" }
     }));
     state.qaHistory = [...state.qaHistory || [], ...newEntries];
-    const unresolvedQuestions = questions.filter((q) => !q.resolved);
-    if (unresolvedQuestions.length > 0) {
-      state.questions = unresolvedQuestions;
-      this.saveState(state);
-      return this.responseCheckpointClarify(state);
-    }
     state.questions = void 0;
     state.answers = void 0;
     state.status = "phase_clarify";
@@ -4146,6 +4096,54 @@ function outputError(error) {
   console.log(JSON.stringify({ type: "error", error }, null, 2));
   process.exit(1);
 }
+function parseFlexibleJSON(json, options = {}) {
+  const { expectArray = false, arrayKeys = [], defaultValue, allowStringFallback = false } = options;
+  try {
+    const parsed = JSON.parse(json);
+    if (expectArray) {
+      if (Array.isArray(parsed)) {
+        return { success: true, data: parsed };
+      }
+      if (typeof parsed === "object" && parsed !== null) {
+        for (const key of arrayKeys) {
+          if (Array.isArray(parsed[key])) {
+            return { success: true, data: parsed[key] };
+          }
+        }
+        for (const key of ["data", "items", "results", "list"]) {
+          if (Array.isArray(parsed[key])) {
+            return { success: true, data: parsed[key] };
+          }
+        }
+        const values = Object.values(parsed);
+        const arrays = values.filter(Array.isArray);
+        if (arrays.length === 1) {
+          return { success: true, data: arrays[0] };
+        }
+      }
+      return { success: true, data: [] };
+    }
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      const keys = Object.keys(parsed);
+      if (keys.length === 1) {
+        const innerValue = parsed[keys[0]];
+        if (typeof innerValue === "object" && innerValue !== null && !Array.isArray(innerValue)) {
+          const innerKeys = Object.keys(innerValue);
+          if (innerKeys.length > 1) {
+            return { success: true, data: innerValue };
+          }
+        }
+      }
+      return { success: true, data: parsed };
+    }
+    return { success: true, data: parsed };
+  } catch {
+    if (allowStringFallback && defaultValue !== void 0) {
+      return { success: true, data: defaultValue };
+    }
+    return { success: false, error: "Invalid JSON format" };
+  }
+}
 async function orchestrateCommand(action, args) {
   try {
     const orchestrator = new Orchestrator();
@@ -4167,18 +4165,21 @@ async function orchestrateCommand(action, args) {
           outputError("Task ID is required for explore-done");
           return;
         }
-        let exploreOutput = {
+        const defaultExplore = {
           summary: "",
           relevantFiles: [],
           patterns: [],
           constraints: [],
           dependencies: []
         };
+        let exploreOutput = defaultExplore;
         if (exploreJson) {
-          try {
-            exploreOutput = JSON.parse(exploreJson);
-          } catch {
-            exploreOutput.summary = exploreJson;
+          const parsed = parseFlexibleJSON(exploreJson, {
+            allowStringFallback: true,
+            defaultValue: { ...defaultExplore, summary: exploreJson }
+          });
+          if (parsed.success) {
+            exploreOutput = { ...defaultExplore, ...parsed.data };
           }
         }
         const result = orchestrator.cmdExploreDone(taskId, exploreOutput);
@@ -4194,13 +4195,15 @@ async function orchestrateCommand(action, args) {
         }
         let questions = [];
         if (questionsJson) {
-          try {
-            const parsed = JSON.parse(questionsJson);
-            questions = Array.isArray(parsed) ? parsed : parsed.questions || [];
-          } catch {
-            outputError("Invalid JSON for questions");
+          const parsed = parseFlexibleJSON(questionsJson, {
+            expectArray: true,
+            arrayKeys: ["questions"]
+          });
+          if (!parsed.success) {
+            outputError(parsed.error);
             return;
           }
+          questions = parsed.data;
         }
         const result = orchestrator.cmdClarifyDone(taskId, questions);
         outputJSON(result);
@@ -4223,7 +4226,7 @@ async function orchestrateCommand(action, args) {
           outputError("Task ID is required for verify-done");
           return;
         }
-        let verifyOutput = {
+        const defaultVerify = {
           passed: false,
           score: {
             requirementsCoverage: 0,
@@ -4234,13 +4237,14 @@ async function orchestrateCommand(action, args) {
           issues: [],
           summary: ""
         };
+        let verifyOutput = defaultVerify;
         if (verifyJson) {
-          try {
-            verifyOutput = JSON.parse(verifyJson);
-          } catch {
-            outputError("Invalid JSON for verify output");
+          const parsed = parseFlexibleJSON(verifyJson, {});
+          if (!parsed.success) {
+            outputError(parsed.error);
             return;
           }
+          verifyOutput = { ...defaultVerify, ...parsed.data };
         }
         const result = orchestrator.cmdVerifyDone(taskId, verifyOutput);
         outputJSON(result);
@@ -4253,14 +4257,15 @@ async function orchestrateCommand(action, args) {
           outputError("Task ID and answers JSON are required for clarified");
           return;
         }
-        let answers;
-        try {
-          answers = JSON.parse(answersJson);
-        } catch {
-          outputError("Invalid JSON for answers");
+        const parsed = parseFlexibleJSON(answersJson, {
+          expectArray: true,
+          arrayKeys: ["answers"]
+        });
+        if (!parsed.success) {
+          outputError(parsed.error);
           return;
         }
-        const result = orchestrator.cmdClarified(taskId, answers);
+        const result = orchestrator.cmdClarified(taskId, parsed.data);
         outputJSON(result);
         break;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spets",
-  "version": "0.1.65",
+  "version": "0.1.67",
   "description": "Spec Driven Development Execution Framework",
   "type": "module",
   "main": "dist/index.js",