@tudeorangbiasa/sdd-multiagent-opencode 0.2.2 → 0.3.0

package/bin/sdd-quick.js

@@ -0,0 +1,607 @@
+#!/usr/bin/env node
+
+/**
+ * sdd-quick CLI Wrapper
+ * Deterministic pre-flight and post-flight checks for quick cosmetic/config changes.
+ * Handles: classification, lock management, impact scan, verification, ledger append.
+ * LLM is only invoked for the actual edit (Phase 3), never for classification or verification.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = process.cwd();
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const LOCK_FILE = path.join(projectRoot, "specs", ".sdd-lock");
+const LEDGER_FILE = path.join(projectRoot, "specs", "QUICKFIX_LOG.md");
+const LEDGER_ARCHIVE = path.join(projectRoot, "specs", "QUICKFIX_LOG_ARCHIVE.md");
+const MAX_LEDGER_ENTRIES = 50;
+const ARCHIVE_THRESHOLD = 25;
+const MAX_FILE_LINES_FOR_FULL_RETURN = 500;
+const MAX_CROSS_FILE_REFS = 5;
+const MAX_STRING_DELTA = 20;
+const MAX_STRING_PERCENT_INCREASE = 50;
+
+const CONTRACT_PATH_PATTERNS = [
+  /\/api\//,
+  /\/dto\//,
+  /\/schema\//,
+  /\/types\/public-api\.ts$/,
+  /\/graphql\/types\.ts$/,
+];
+
+const LOGIC_OPERATORS = /\b(>=|<=|==|===|!=|!==|&&|\|\|)\b|[><]{2,}|[&|]{2,}|(?<![-=])[><](?![=-])/;
+const LOGIC_KEYWORDS = /\b(if|else|switch|case|for|while|return|throw|try|catch|finally)\b/;
+
+// ─── Utility ─────────────────────────────────────────────────────────────────
+
+function logError(msg) {
+  console.error(`❌ ${msg}`);
+}
+
+function logWarn(msg) {
+  console.warn(`⚠️  ${msg}`);
+}
+
+function logInfo(msg) {
+  console.log(`ℹ️  ${msg}`);
+}
+
+function logSuccess(msg) {
+  console.log(`✅ ${msg}`);
+}
+
+function exitWith(code, msg) {
+  if (msg) logError(msg);
+  process.exit(code);
+}
+
+function slugify(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, "")
+    .replace(/\s+/g, "-")
+    .replace(/-+/g, "-")
+    .slice(0, 40);
+}
+
+function now() {
+  return new Date().toISOString().replace("T", " ").slice(0, 16);
+}
+
+// ─── Phase 1a: Keyword Scan (CLI, 0 tokens) ──────────────────────────────────
+
+function keywordScan(request) {
+  const lower = request.toLowerCase();
+
+  if (LOGIC_OPERATORS.test(request)) {
+    return {
+      type: "LOGIC",
+      reason: "Request contains operators (>, <, >=, <=, ==, ===, !=, !==, &&, ||, !)",
+      blocked: true,
+    };
+  }
+
+  if (LOGIC_KEYWORDS.test(lower)) {
+    return {
+      type: "LOGIC",
+      reason: "Request contains control flow keywords (if, else, switch, case, for, while, return, throw, try, catch)",
+      blocked: true,
+    };
+  }
+
+  return { type: "COSMETIC_OR_CONFIG", blocked: false };
+}
+
+// ─── Phase 1b: Context-Aware Classification (LLM, ~50 tokens) ───────────────
+
+function buildClassificationPrompt(request, filePath, fileContent) {
+  return `Classify this change request. Return ONLY JSON: {"safe": true|false, "type": "COSMETIC"|"CONFIG"|"LOGIC"|"CONTRACT", "reason": "..."}
+
+Request: "${request}"
+File: ${filePath}
+File content:
+\`\`\`
+${fileContent.slice(0, 3000)}
+\`\`\`
+
+Rules:
+- If change touches exported function/class/type name → CONTRACT (blocked)
+- If change modifies logic, condition, or calculation → LOGIC (blocked)
+- If change is in a comment or string literal only → COSMETIC (allowed)
+- If change is a constant/env/config value → CONFIG (allowed)`;
+}
+
+// ─── Phase 1c: Contract Path Check (CLI, 0 tokens) ──────────────────────────
+
+function contractPathCheck(filePath) {
+  for (const pattern of CONTRACT_PATH_PATTERNS) {
+    if (pattern.test(filePath)) {
+      return {
+        type: "CONTRACT",
+        reason: `File matches contract boundary pattern: ${pattern.source}`,
+        blocked: true,
+      };
+    }
+  }
+  return { type: "OK", blocked: false };
+}
+
+// ─── Phase 2: Pre-Flight Checks (CLI, 0 tokens) ─────────────────────────────
+
+function checkLockFile() {
+  if (!fs.existsSync(LOCK_FILE)) {
+    return { locked: false };
+  }
+
+  try {
+    const lock = JSON.parse(fs.readFileSync(LOCK_FILE, "utf8"));
+    const pid = lock.pid;
+
+    // Check if process is still running
+    try {
+      process.kill(pid, 0);
+      return {
+        locked: true,
+        pid,
+        command: lock.command,
+        changeId: lock["change-id"],
+        started: lock.started,
+      };
+    } catch {
+      // Process is dead, remove stale lock
+      fs.unlinkSync(LOCK_FILE);
+      return { locked: false, stale: true };
+    }
+  } catch {
+    // Corrupt lock file, remove it
+    try { fs.unlinkSync(LOCK_FILE); } catch {}
+    return { locked: false, corrupt: true };
+  }
+}
+
+function acquireLock(command, changeId) {
+  const lock = {
+    pid: process.pid,
+    command,
+    "change-id": changeId,
+    started: now(),
+  };
+  const specsDir = path.dirname(LOCK_FILE);
+  if (!fs.existsSync(specsDir)) {
+    fs.mkdirSync(specsDir, { recursive: true });
+  }
+  fs.writeFileSync(LOCK_FILE, JSON.stringify(lock, null, 2));
+}
+
+function releaseLock() {
+  try {
+    if (fs.existsSync(LOCK_FILE)) {
+      fs.unlinkSync(LOCK_FILE);
+    }
+  } catch {}
+}
+
+function crossFileScan(pattern, targetFile) {
+  try {
+    const result = execSync(
+      `grep -r "${pattern}" --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx" . 2>/dev/null | grep -v node_modules | grep -v ".sdd/" | wc -l`,
+      { cwd: projectRoot, encoding: "utf8" }
+    );
+    const count = parseInt(result.trim(), 10);
+    return { count, exceeds: count > MAX_CROSS_FILE_REFS };
+  } catch {
+    return { count: 0, exceeds: false };
+  }
+}
+
+function stringLengthCheck(oldStr, newStr) {
+  const oldLen = oldStr.length;
+  const newLen = newStr.length;
+  const delta = Math.abs(newLen - oldLen);
+  const percentIncrease = oldLen > 0 ? ((newLen - oldLen) / oldLen) * 100 : 0;
+
+  return {
+    delta,
+    percentIncrease,
+    exceeds: delta > MAX_STRING_DELTA || percentIncrease > MAX_STRING_PERCENT_INCREASE,
+  };
+}
+
+// ─── Phase 3: LLM Edit (invoked by agent, not CLI) ──────────────────────────
+
+function buildEditPrompt(request, filePath, fileContent) {
+  const isSmall = fileContent.split("\n").length <= MAX_FILE_LINES_FOR_FULL_RETURN;
+
+  if (isSmall) {
+    return `Here is the full content of ${filePath}.
+
+\`\`\`
+${fileContent}
+\`\`\`
+
+Task: ${request}
+
+Return the ENTIRE file content with the change applied. No explanation. No diff format. No markdown code blocks. Just the raw file content.`;
+  }
+
+  // For large files, use search-replace blocks
+  return `File: ${filePath}
+
+Task: ${request}
+
+Use this format to show changes:
+<<<SEARCH
+exact lines from original file
+>>>
+<<<REPLACE
+new lines to replace with
+>>>
+
+Only show the sections that change. Do NOT return the entire file.`;
+}
+
+// ─── Phase 4: Post-Flight Verification (CLI, 0 tokens) ──────────────────────
+
+function verifyChange(backupPath, targetPath, request) {
+  const backup = fs.readFileSync(backupPath, "utf8");
+  const current = fs.readFileSync(targetPath, "utf8");
+
+  if (backup === current) {
+    return { changed: false, reason: "No changes were made to the file." };
+  }
+
+  // Compute diff
+  const backupLines = backup.split("\n");
+  const currentLines = current.split("\n");
+  const addedLines = currentLines.length - backupLines.length;
+
+  // Check if only the requested change was made
+  // Simple heuristic: if too many lines added beyond the request, flag it
+  if (addedLines > 3) {
+    return {
+      changed: true,
+      extraLines: addedLines,
+      reason: `LLM added ${addedLines} extra lines beyond the requested change.`,
+      revert: true,
+    };
+  }
+
+  return { changed: true, extraLines: addedLines };
+}
+
+function runLint() {
+  try {
+    // Try common lint commands
+    const pkgPath = path.join(projectRoot, "package.json");
+    if (!fs.existsSync(pkgPath)) return { available: false };
+
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    const scripts = pkg.scripts || {};
+
+    if (scripts["lint"]) {
+      execSync(`npm run lint`, { cwd: projectRoot, stdio: "pipe" });
+      return { available: true, passed: true, command: "npm run lint" };
+    }
+    return { available: false };
+  } catch (err) {
+    return { available: true, passed: false, command: "npm run lint", error: err.message };
+  }
+}
+
+function runTypecheck() {
+  try {
+    const pkgPath = path.join(projectRoot, "package.json");
+    if (!fs.existsSync(pkgPath)) return { available: false };
+
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    const scripts = pkg.scripts || {};
+
+    if (scripts["typecheck"]) {
+      execSync(`npm run typecheck`, { cwd: projectRoot, stdio: "pipe" });
+      return { available: true, passed: true, command: "npm run typecheck" };
+    }
+    if (scripts["tsc"]) {
+      execSync(`npm run tsc`, { cwd: projectRoot, stdio: "pipe" });
+      return { available: true, passed: true, command: "npm run tsc" };
+    }
+    // Try npx tsc --noEmit
+    try {
+      execSync(`npx tsc --noEmit`, { cwd: projectRoot, stdio: "pipe" });
+      return { available: true, passed: true, command: "npx tsc --noEmit" };
+    } catch {
+      return { available: false };
+    }
+  } catch (err) {
+    return { available: true, passed: false, command: "typecheck", error: err.message };
+  }
+}
+
+// ─── Phase 5: Atomic Ledger Append (CLI, 0 tokens) ──────────────────────────
+
+function appendToLedger(entry) {
+  const specsDir = path.dirname(LEDGER_FILE);
+  if (!fs.existsSync(specsDir)) {
+    fs.mkdirSync(specsDir, { recursive: true });
+  }
+
+  let content = "";
+  if (fs.existsSync(LEDGER_FILE)) {
+    content = fs.readFileSync(LEDGER_FILE, "utf8");
+  } else {
+    content = "# Quick Change Log\n\n";
+  }
+
+  content += entry + "\n";
+
+  // Atomic write via temp file
+  const tmpFile = LEDGER_FILE + ".tmp";
+  fs.writeFileSync(tmpFile, content);
+  fs.renameSync(tmpFile, LEDGER_FILE);
+
+  // Ledger maintenance: archive old entries if too large
+  const entries = content.split(/^## /m).filter(Boolean);
+  if (entries.length > MAX_LEDGER_ENTRIES) {
+    const keep = entries.slice(-ARCHIVE_THRESHOLD);
+    const archive = entries.slice(0, -ARCHIVE_THRESHOLD);
+
+    let archiveContent = "";
+    if (fs.existsSync(LEDGER_ARCHIVE)) {
+      archiveContent = fs.readFileSync(LEDGER_ARCHIVE, "utf8");
+    } else {
+      archiveContent = "# Quick Change Log Archive\n\n";
+    }
+
+    archiveContent += archive.join("## ");
+
+    const archiveTmp = LEDGER_ARCHIVE + ".tmp";
+    fs.writeFileSync(archiveTmp, archiveContent);
+    fs.renameSync(archiveTmp, LEDGER_ARCHIVE);
+
+    const newContent = "# Quick Change Log\n\n" + keep.join("## ");
+    const newTmp = LEDGER_FILE + ".tmp";
+    fs.writeFileSync(newTmp, newContent);
+    fs.renameSync(newTmp, LEDGER_FILE);
+  }
+}
+
+// ─── CLI Entry Point ─────────────────────────────────────────────────────────
+
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+    console.log(`sdd-quick CLI Wrapper
+
+Usage:
+  sdd-quick classify "<request>" [file]     - Classify a change request
+  sdd-quick preflight "<request>" [file]     - Run pre-flight checks
+  sdd-quick postflight <backup> <target>     - Run post-flight verification
+  sdd-quick lint                            - Run lint check
+  sdd-quick typecheck                       - Run typecheck
+  sdd-quick ledger append "<entry>"          - Append to ledger
+  sdd-quick lock acquire <command> [id]      - Acquire lock
+  sdd-quick lock release                     - Release lock
+  sdd-quick lock check                       - Check lock status
+  sdd-quick grep "<pattern>"                 - Cross-file reference count
+  sdd-quick string-len "<old>" "<new>"       - String length delta check
+  sdd-quick edit-prompt "<request>" <file>   - Generate LLM edit prompt
+
+All commands exit 0 on success, non-zero on failure.`);
+    process.exit(0);
+  }
+
+  const command = args[0];
+
+  try {
+    switch (command) {
+      case "classify": {
+        const request = args[1] || "";
+        const filePath = args[2] || "";
+
+        if (!request) exitWith(1, "Request is required for classification.");
+
+        // Phase 1a: Keyword scan
+        const keywordResult = keywordScan(request);
+        if (keywordResult.blocked) {
+          console.log(JSON.stringify({
+            blocked: true,
+            type: keywordResult.type,
+            reason: keywordResult.reason,
+            needsLLM: false,
+          }));
+          process.exit(0);
+        }
+
+        // Phase 1c: Contract path check
+        if (filePath) {
+          const contractResult = contractPathCheck(filePath);
+          if (contractResult.blocked) {
+            console.log(JSON.stringify({
+              blocked: true,
+              type: contractResult.type,
+              reason: contractResult.reason,
+              needsLLM: false,
+            }));
+            process.exit(0);
+          }
+        }
+
+        // If file provided and keyword scan found something ambiguous, suggest LLM classification
+        if (filePath && fs.existsSync(filePath)) {
+          const content = fs.readFileSync(filePath, "utf8");
+          const prompt = buildClassificationPrompt(request, filePath, content);
+          console.log(JSON.stringify({
+            blocked: false,
+            type: "NEEDS_LLM_CLASSIFICATION",
+            prompt,
+          }));
+        } else {
+          console.log(JSON.stringify({
+            blocked: false,
+            type: "COSMETIC_OR_CONFIG",
+            reason: "No blocking keywords or contract paths detected.",
+          }));
+        }
+        process.exit(0);
+      }
+
+      case "preflight": {
+        const request = args[1] || "";
+        const filePath = args[2] || "";
+
+        // Lock check
+        const lock = checkLockFile();
+        if (lock.locked) {
+          console.log(JSON.stringify({
+            preflight: "FAIL",
+            reason: `Another SDD process is active (PID ${lock.pid}, ${lock.command}).`,
+            lock,
+          }));
+          process.exit(1);
+        }
+
+        // Cross-file scan
+        if (request) {
+          const refs = crossFileScan(request, filePath);
+          if (refs.exceeds) {
+            console.log(JSON.stringify({
+              preflight: "WARN",
+              crossFileRefs: refs.count,
+              exceeds: true,
+            }));
+          }
+        }
+
+        // String length check (if old/new strings provided)
+        if (args[3] && args[4]) {
+          const strCheck = stringLengthCheck(args[3], args[4]);
+          if (strCheck.exceeds) {
+            console.log(JSON.stringify({
+              preflight: "WARN",
+              stringDelta: strCheck.delta,
+              percentIncrease: strCheck.percentIncrease,
+              exceeds: true,
+            }));
+          }
+        }
+
+        console.log(JSON.stringify({ preflight: "PASS", lockStale: lock.stale }));
+        process.exit(0);
+      }
+
+      case "postflight": {
+        const backupPath = args[1];
+        const targetPath = args[2];
+
+        if (!backupPath || !targetPath) {
+          exitWith(1, "Usage: sdd-quick postflight <backup> <target>");
+        }
+
+        const result = verifyChange(backupPath, targetPath);
+        console.log(JSON.stringify(result));
+
+        if (result.revert) {
+          fs.copyFileSync(backupPath, targetPath);
+          logWarn(`Auto-reverted: ${result.reason}`);
+          process.exit(1);
+        }
+
+        process.exit(0);
+      }
+
+      case "lint": {
+        const result = runLint();
+        console.log(JSON.stringify(result));
+        process.exit(result.available && !result.passed ? 1 : 0);
+      }
+
+      case "typecheck": {
+        const result = runTypecheck();
+        console.log(JSON.stringify(result));
+        process.exit(result.available && !result.passed ? 1 : 0);
+      }
+
+      case "ledger": {
+        if (args[1] !== "append") exitWith(1, "Usage: sdd-quick ledger append \"<entry>\"");
+        const entry = args[2] || "";
+        if (!entry) exitWith(1, "Entry is required.");
+        appendToLedger(entry);
+        logSuccess(`Ledger updated: ${LEDGER_FILE}`);
+        process.exit(0);
+      }
+
+      case "lock": {
+        const sub = args[1];
+        switch (sub) {
+          case "acquire": {
+            const cmd = args[2] || "sdd-quick";
+            const id = args[3] || `quick-${Date.now()}`;
+            acquireLock(cmd, id);
+            logSuccess(`Lock acquired: PID ${process.pid}`);
+            process.exit(0);
+          }
+          case "release": {
+            releaseLock();
+            logSuccess("Lock released");
+            process.exit(0);
+          }
+          case "check": {
+            const lock = checkLockFile();
+            console.log(JSON.stringify(lock));
+            process.exit(0);
+          }
+          default:
+            exitWith(1, "Usage: sdd-quick lock [acquire|release|check]");
+        }
+      }
+
+      case "grep": {
+        const pattern = args[1] || "";
+        if (!pattern) exitWith(1, "Pattern is required.");
+        const result = crossFileScan(pattern);
+        console.log(JSON.stringify(result));
+        process.exit(0);
+      }
+
+      case "string-len": {
+        const oldStr = args[1] || "";
+        const newStr = args[2] || "";
+        const result = stringLengthCheck(oldStr, newStr);
+        console.log(JSON.stringify(result));
+        process.exit(0);
+      }
+
+      case "edit-prompt": {
+        const request = args[1] || "";
+        const filePath = args[2] || "";
+
+        if (!request || !filePath) {
+          exitWith(1, "Usage: sdd-quick edit-prompt \"<request>\" <file>");
+        }
+
+        if (!fs.existsSync(filePath)) {
+          exitWith(1, `File not found: ${filePath}`);
+        }
+
+        const content = fs.readFileSync(filePath, "utf8");
+        const prompt = buildEditPrompt(request, filePath, content);
+        console.log(prompt);
+        process.exit(0);
+      }
+
+      default:
+        exitWith(1, `Unknown command: ${command}. Run sdd-quick --help for usage.`);
+    }
+  } catch (err) {
+    exitWith(1, `Error: ${err.message}`);
+  }
+}
+
+main();

package/opencode.json

@@ -1,8 +1,7 @@
 {
   "$schema": "https://opencode.ai/config.json",
   "plugin": [
-    "./plugins/sdd-model-router.js",
-    "./plugins/sdd-auto-reasoning.js"
+    "./plugins/sdd-register.js"
   ],
   "agent": {
     "sdd-orchestrator": {

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@tudeorangbiasa/sdd-multiagent-opencode",
-  "version": "0.2.2",
-  "description": "Spec-Driven Development workflow kit for OpenCode with 4 core commands, multi-agent support, and configurable model routing",
+  "version": "0.3.0",
+  "description": "Spec-Driven Development workflow kit for OpenCode with 5 core commands, multi-agent support, CLI wrappers, and configurable model routing",
   "type": "module",
   "main": ".opencode/plugins/sdd-register.js",
   "bin": {
-    "sdd-opencode": "bin/sdd-opencode.js"
+    "sdd-opencode": "bin/sdd-opencode.js",
+    "sdd-quick": "bin/sdd-quick.js"
   },
   "files": [
     "bin",
@@ -17,7 +18,9 @@
     "opencode.json"
   ],
   "scripts": {
-    "smoke": "node bin/sdd-opencode.js init --dry-run"
+    "smoke": "node bin/sdd-opencode.js init --dry-run",
+    "doctor": "node bin/sdd-opencode.js doctor",
+    "migrate": "node bin/sdd-opencode.js migrate"
   },
   "keywords": [
     "opencode",