spets 0.1.65 → 0.1.66

package/dist/index.js

@@ -965,8 +965,6 @@ function buildClarifyPrompt(params) {
     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) {
@@ -975,8 +973,11 @@ function buildClarifyPrompt(params) {
         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.");
+      parts.push("**Rules:**");
+      parts.push('- If user said "you decide" or "\uC54C\uC544\uC11C \uD574" \u2192 use your judgment and move on');
+      parts.push("- If user asked for options \u2192 provide options for that specific topic only");
+      parts.push("- Do NOT ask about topics already answered, even with different wording");
+      parts.push("- When in doubt, proceed rather than ask again");
       parts.push("");
     }
   }
@@ -4146,6 +4147,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 +4216,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 +4246,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 +4277,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 +4288,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 +4308,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.66",
   "description": "Spec Driven Development Execution Framework",
   "type": "module",
   "main": "dist/index.js",