@tarcisiopgs/lisa 1.30.0 → 1.31.0

package/README.md

@@ -40,7 +40,8 @@ If something fails — pre-push hooks, quota limits, stuck processes — Lisa ha
 - **7 issue trackers** — Linear, GitHub Issues, GitLab Issues, Jira, Trello, Plane, Shortcut
 - **8 AI agents** — Claude Code, Gemini CLI, GitHub Copilot CLI, Cursor Agent, Aider, Goose, OpenCode, Codex
 - **AI planning** — describe a goal, the AI brainstorms with you, decomposes it into issues with dependencies, created in your tracker
-- **Language-aware** — detects your goal's language (pt/en/es) and generates issues in the same language
+- **Language-aware** — responds in the same language you write your goal in
+- **Spec compliance** — LLM-verified acceptance criteria check before PR creation, with auto-retry
 - **Concurrent execution** — process multiple issues in parallel, each in its own worktree
 - **Multi-repo** — plans across repos, creates one PR per repo in the correct order
 - **Model fallback** — chain models; transient errors (429, quota, timeout) auto-switch to the next
@@ -101,6 +102,9 @@ lisa plan --no-brainstorm "goal" # skip brainstorming, decompose directly
 lisa plan --yes "goal"      # skip confirmations (CI/scripts)
 lisa init                   # create .lisa/config.yaml interactively
 lisa status                 # show session stats
+lisa config --show           # print current config
+lisa config --get loop.cooldown  # query a specific value
+lisa config --set loop.cooldown=5  # set nested config values
 lisa doctor                 # diagnose setup issues (config, provider, env, git)
 lisa context refresh        # regenerate project context
 lisa feedback --pr URL      # inject PR review feedback into guardrails
@@ -235,6 +239,11 @@ proof_of_work:
 validation:
   require_acceptance_criteria: true
 
+spec_compliance:
+  enabled: true
+  max_retries: 1             # retry agent to fix unmet criteria (default: 1)
+  block_on_failure: true     # skip PR when criteria aren't met (default: false)
+
 ci_monitor:
   enabled: true
   max_retries: 3             # fix attempts on CI failure
@@ -244,10 +253,34 @@ ci_monitor:
 
 progress_comments:
   enabled: true              # post real-time status on issues
+
+hooks:
+  before_run: "./scripts/setup.sh"
+  after_run: "./scripts/cleanup.sh"
+  timeout: 60000             # ms, default 60000
 ```
 
 </details>
 
+## Validation Pipeline
+
+After the agent implements an issue, Lisa runs a multi-stage validation pipeline before creating a PR:
+
+```
+Agent implements → Proof of Work (lint/test/typecheck) → Spec Compliance → PR
+```
+
+**Proof of Work** runs configured shell commands (lint, typecheck, test). If any fail, the agent is re-invoked with the error output to fix the issue.
+
+**Spec Compliance** extracts acceptance criteria from the issue description (`- [ ]` checklists) and asks the LLM to verify each one against the git diff. The result is a structured JSON with met/not-met verdicts and evidence. If criteria are unmet, the agent is re-invoked to fix them. Results are appended to the PR body as a Markdown table:
+
+| Criterion | Status | Evidence |
+|-----------|--------|----------|
+| Returns 429 on rate limit | Met | Rate limit middleware returns 429 |
+| Headers include X-RateLimit | Not Met | No header injection found |
+
+Both stages support `max_retries` and `block_on_failure` — when blocking is enabled, the PR is skipped entirely on failure.
+
 ## Writing Good Issues
 
 Issue quality = PR quality. Lisa validates issues and skips vague ones (labeling them `needs-spec`).
@@ -290,15 +323,23 @@ The real-time Kanban board shows issue progress, streams provider output, and de
 | `m` | Merge PR (warns if CI not passed) |
 | `Esc` | Back to board |
 
-**Plan mode**
+**Plan chat**
+
+| Key | Action |
+|-----|--------|
+| `↵` | Send message |
+| `↑` `↓` | Scroll chat history |
+| `Esc` | Cancel |
+
+**Plan review**
 
 | Key | Action |
 |-----|--------|
-| `↵` | Send message / view detail |
+| `↵` | View issue detail |
 | `e` | Edit issue in $EDITOR |
 | `d` | Delete issue |
 | `a` | Approve and create issues |
-| `Esc` | Cancel / back |
+| `Esc` | Back |
 
 In CLI mode, the plan wizard also offers **Regenerate with feedback** — describe what to change and the AI regenerates the entire plan incorporating your feedback.
 

package/dist/{chunk-PBPVDKID.js → chunk-45ZNECZ5.js}

@@ -4,6 +4,9 @@ import {
   analyzeProject,
   appendPlatformAttribution,
   appendPlatformProofOfWork,
+  appendPlatformSpecCompliance,
+  buildCompliancePrompt,
+  buildComplianceRecoveryPrompt,
   buildContinuationPrompt,
   buildImplementPrompt,
   buildNativeWorktreePrompt,
@@ -15,14 +18,18 @@ import {
   createSource,
   detectPackageManager,
   detectTestRunner,
+  extractAcceptanceCriteria,
   getContextPath,
+  getFullDiff,
   isCompleteProviderExhaustion,
   isProofOfWorkEnabled,
+  isSpecComplianceEnabled,
+  parseComplianceResponse,
   readContext,
   resolveModels,
   runValidationCommands,
   runWithFallback
-} from "./chunk-IMIDFVMI.js";
+} from "./chunk-RQTH257A.js";
 import {
   divider,
   error,
@@ -225,6 +232,7 @@ function loadConfig(cwd = process.cwd()) {
   const rawProofOfWork = parsed.proof_of_work;
   const rawReconciliation = parsed.reconciliation;
   const rawCiMonitor = parsed.ci_monitor;
+  const rawSpecCompliance = parsed.spec_compliance;
   const rawProgress = parsed.progress_comments;
   const config = {
     ...DEFAULT_CONFIG,
@@ -265,6 +273,11 @@ function loadConfig(cwd = process.cwd()) {
       poll_timeout: rawCiMonitor.poll_timeout,
       block_on_failure: rawCiMonitor.block_on_failure
     } : void 0,
+    spec_compliance: rawSpecCompliance ? {
+      enabled: rawSpecCompliance.enabled ?? false,
+      max_retries: rawSpecCompliance.max_retries,
+      block_on_failure: rawSpecCompliance.block_on_failure
+    } : void 0,
     progress_comments: rawProgress ? { enabled: rawProgress.enabled ?? false } : void 0,
     provider_options: {
       ...DEFAULT_CONFIG.provider_options || {},
@@ -1175,7 +1188,7 @@ async function startInfra(issueId, cwd, config) {
 function startReconciliationMonitor(source, issueId, config) {
   return source && config.reconciliation?.enabled ? startReconciliation(source, issueId, config.reconciliation, config.source_config) : null;
 }
-async function runProofOfWork(config, issue, models, cwd, logFile, workspace, lifecycleEnv, result) {
+async function runProofOfWork(config, issue, models, cwd, logFile, workspace, lifecycleEnv, _result) {
   if (!isProofOfWorkEnabled(config.proof_of_work)) return {};
   const pow = config.proof_of_work;
   let retriesLeft = pow?.max_retries ?? 2;
@@ -1229,6 +1242,90 @@ async function runProofOfWork(config, issue, models, cwd, logFile, workspace, li
     }
   }
 }
+async function runSpecCompliance(config, issue, models, cwd, baseBranch, logFile, workspace, lifecycleEnv) {
+  if (!isSpecComplianceEnabled(config.spec_compliance)) return {};
+  const criteria = extractAcceptanceCriteria(issue.description);
+  if (criteria.length === 0) {
+    warn(`No extractable acceptance criteria for ${issue.id}. Skipping spec compliance.`);
+    return {};
+  }
+  const sc = config.spec_compliance;
+  let retriesLeft = sc?.max_retries ?? 1;
+  while (true) {
+    if (reconciliationSet.has(issue.id)) {
+      reconciliationSet.delete(issue.id);
+      warn(`Issue ${issue.id} was closed/cancelled during spec compliance. Skipping.`);
+      return { reconciled: true };
+    }
+    startSpinner(`${issue.id} \u2014 checking spec compliance...`);
+    const diff = await getFullDiff(cwd, baseBranch);
+    if (!diff) {
+      stopSpinner();
+      warn(`No diff available for spec compliance on ${issue.id}. Skipping.`);
+      return {};
+    }
+    const compliancePrompt = buildCompliancePrompt(issue, criteria, diff);
+    const checkResult = await runWithFallback(
+      models,
+      compliancePrompt,
+      buildRunOptions(config, issue, cwd, logFile, workspace, lifecycleEnv)
+    );
+    stopSpinner();
+    if (!checkResult.success) {
+      warn(`Spec compliance check failed to run for ${issue.id}. Proceeding without it.`);
+      return {};
+    }
+    const compliance = parseComplianceResponse(checkResult.output);
+    if (!compliance) {
+      warn(
+        `Could not parse spec compliance response for ${issue.id}. Proceeding without it.`
+      );
+      return {};
+    }
+    if (compliance.passed) {
+      ok(`Spec compliance passed for ${issue.id}: ${compliance.summary}`);
+      return { result: compliance };
+    }
+    const unmet = compliance.criteria.filter((c) => !c.met);
+    warn(
+      `Spec compliance failed for ${issue.id}: ${compliance.summary} (${unmet.length} unmet)`
+    );
+    if (retriesLeft <= 0) {
+      if (sc?.block_on_failure) {
+        error(
+          `Spec compliance failed after max retries for ${issue.id}. Blocking PR creation.`
+        );
+        return { result: compliance, blocked: true };
+      }
+      warn(
+        `Spec compliance failed after max retries for ${issue.id}. Creating PR with failures noted.`
+      );
+      return { result: compliance };
+    }
+    retriesLeft--;
+    warn(
+      `Re-invoking agent to fix unmet criteria for ${issue.id} (${retriesLeft} retries left)...`
+    );
+    const recoveryPrompt = buildComplianceRecoveryPrompt(issue, unmet);
+    startSpinner(`${issue.id} \u2014 fixing unmet criteria...`);
+    const recoveryResult = await runWithFallback(
+      models,
+      recoveryPrompt,
+      buildRunOptions(config, issue, cwd, logFile, workspace, lifecycleEnv)
+    );
+    stopSpinner();
+    if (!recoveryResult.success) {
+      if (sc?.block_on_failure) {
+        error(`Spec compliance recovery failed for ${issue.id}. Blocking PR creation.`);
+        return { result: compliance, blocked: true };
+      }
+      warn(
+        `Spec compliance recovery failed for ${issue.id}. Creating PR with failures noted.`
+      );
+      return { result: compliance };
+    }
+  }
+}
 
 // src/loop/recovery.ts
 async function injectRejectedPrFeedback(workspace, issueId, prUrls) {
@@ -2794,6 +2891,29 @@ async function runManualWorktreeSession(config, issue, logFile, session, models,
   if (validationResults) {
     await reporter.update("validating", "Validation passed");
   }
+  const complianceResult = await runSpecCompliance(
+    config,
+    issue,
+    models,
+    worktreePath,
+    baseBranch,
+    logFile,
+    workspace,
+    lifecycleEnv
+  );
+  if (complianceResult.reconciled) {
+    await cleanupWorktree(repoPath, worktreePath);
+    return failureResult(result.providerUsed, result);
+  }
+  if (complianceResult.blocked) {
+    error(
+      `Skipping PR for ${issue.id} \u2014 spec compliance failed with block_on_failure enabled.`
+    );
+    await reporter.fail("Spec compliance failed");
+    await executeHook("before_remove", config.hooks, worktreePath, hookEnv);
+    await cleanupWorktree(repoPath, worktreePath);
+    return failureResult(result.providerUsed, result);
+  }
   const manifest = readManifestFile(manifestPath);
   let prUrl = manifest?.prUrl;
   if (!prUrl) {
@@ -2850,6 +2970,9 @@ async function runManualWorktreeSession(config, issue, logFile, session, models,
   if (validationResults) {
     await appendPlatformProofOfWork(prUrl, validationResults, config.platform);
   }
+  if (complianceResult.result) {
+    await appendPlatformSpecCompliance(prUrl, complianceResult.result, config.platform);
+  }
   if (isCiMonitorEnabled(config.ci_monitor)) {
     const manifestBranch = manifest?.branch ?? branchName;
     const ciResult = await monitorCi(
@@ -3308,6 +3431,26 @@ async function runBranchSession(config, issue, logFile, session, models, source,
   if (validationResults) {
     await reporter.update("validating", "Validation passed");
   }
+  const complianceResult = await runSpecCompliance(
+    config,
+    issue,
+    models,
+    workspace,
+    config.base_branch,
+    logFile,
+    workspace,
+    lifecycleEnv
+  );
+  if (complianceResult.reconciled) {
+    return failureResult(result.providerUsed, result);
+  }
+  if (complianceResult.blocked) {
+    error(
+      `Skipping PR for ${issue.id} \u2014 spec compliance failed with block_on_failure enabled.`
+    );
+    await reporter.fail("Spec compliance failed");
+    return failureResult(result.providerUsed, result);
+  }
   const manifest = readManifestFile(manifestPath);
   try {
     unlinkSync3(manifestPath);
@@ -3330,6 +3473,9 @@ async function runBranchSession(config, issue, logFile, session, models, source,
   if (validationResults) {
     await appendPlatformProofOfWork(prUrl, validationResults, config.platform);
   }
+  if (complianceResult.result) {
+    await appendPlatformSpecCompliance(prUrl, complianceResult.result, config.platform);
+  }
   if (isCiMonitorEnabled(config.ci_monitor)) {
     const manifestBranch = manifest?.branch;
     if (manifestBranch) {

package/dist/{chunk-IMIDFVMI.js → chunk-RQTH257A.js}

@@ -2745,6 +2745,150 @@ function isProofOfWorkEnabled(config) {
   return !!(config?.enabled && config.commands.length > 0);
 }
 
+// src/session/spec-compliance.ts
+import { execa } from "execa";
+function extractAcceptanceCriteria(description) {
+  const criteria = [];
+  const checklistRegex = /^[\t ]*- \[ \]\s*(.+)$/gm;
+  let match;
+  match = checklistRegex.exec(description);
+  while (match) {
+    if (match[1]) criteria.push(match[1].trim());
+    match = checklistRegex.exec(description);
+  }
+  if (criteria.length > 0) return criteria;
+  const headerRegex = /(?:acceptance criteria|critérios de aceite|expected behavior)[:\s]*\n/i;
+  const headerMatch = headerRegex.exec(description);
+  if (headerMatch) {
+    const afterHeader = description.slice(headerMatch.index + headerMatch[0].length);
+    const lines = afterHeader.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#") || trimmed.startsWith("---")) break;
+      const listMatch = /^[-*]\s+(.+)$/.exec(trimmed);
+      if (listMatch?.[1]) {
+        criteria.push(listMatch[1].trim());
+      }
+      const numberedMatch = /^\d+[.)]\s+(.+)$/.exec(trimmed);
+      if (numberedMatch?.[1]) {
+        criteria.push(numberedMatch[1].trim());
+      }
+    }
+  }
+  return criteria;
+}
+async function getFullDiff(cwd, baseBranch, maxChars = 3e4) {
+  try {
+    const { stdout } = await execa("git", ["diff", `${baseBranch}..HEAD`], {
+      cwd,
+      reject: false
+    });
+    const diff = stdout.trim();
+    if (diff.length <= maxChars) return diff;
+    return `${diff.slice(0, maxChars)}
+
+[... diff truncated at ${maxChars} characters ...]`;
+  } catch {
+    return "";
+  }
+}
+function buildCompliancePrompt(issue, criteria, diff) {
+  const criteriaList = criteria.map((c, i) => `${i + 1}. ${c}`).join("\n");
+  return `You are a spec compliance validator. Your ONLY task is to check if an implementation satisfies the acceptance criteria. Do NOT modify any files or run any commands.
+
+## Issue
+${issue.id}: ${issue.title}
+
+## Acceptance Criteria
+${criteriaList}
+
+## Implementation (git diff)
+\`\`\`diff
+${diff}
+\`\`\`
+
+## Task
+For each acceptance criterion above, determine if the implementation (git diff) satisfies it.
+
+Respond with ONLY a valid JSON object \u2014 no markdown fences, no explanation, no other text:
+
+{
+  "criteria": [
+    { "criterion": "the criterion text", "met": true, "evidence": "brief explanation of how it's met" },
+    { "criterion": "the criterion text", "met": false, "evidence": "what is missing or wrong" }
+  ],
+  "summary": "X/Y criteria met",
+  "passed": false
+}
+
+IMPORTANT:
+- Do NOT create, edit, or modify any files.
+- Do NOT run any shell commands.
+- Do NOT create branches or commits.
+- ONLY output the JSON object above.`;
+}
+function buildComplianceRecoveryPrompt(issue, unmetCriteria) {
+  const unmetList = unmetCriteria.map((c, i) => `${i + 1}. **${c.criterion}**
+   Reason: ${c.evidence}`).join("\n\n");
+  return `You are continuing work on issue ${issue.id}: "${issue.title}".
+
+Your implementation was checked against the acceptance criteria and the following were NOT met:
+
+${unmetList}
+
+Fix ONLY the unmet criteria above. Commit and push your changes.
+
+IMPORTANT:
+- Do NOT create a new branch \u2014 you are already on the correct branch.
+- Fix ONLY the unmet criteria listed above.
+- Commit and push your fixes.
+- Do NOT create a PR \u2014 that will be handled separately.`;
+}
+function parseComplianceResponse(output) {
+  const jsonPatterns = [
+    // Direct JSON object
+    /\{[\s\S]*"criteria"[\s\S]*\}/,
+    // Inside markdown code fence
+    /```(?:json)?\s*(\{[\s\S]*"criteria"[\s\S]*\})\s*```/
+  ];
+  for (const pattern of jsonPatterns) {
+    const match = pattern.exec(output);
+    if (match) {
+      const jsonStr = match[1] ?? match[0];
+      try {
+        const parsed = JSON.parse(jsonStr);
+        if (Array.isArray(parsed.criteria)) {
+          const allMet = parsed.criteria.every((c) => c.met);
+          return {
+            criteria: parsed.criteria,
+            passed: allMet,
+            summary: parsed.summary || `${parsed.criteria.filter((c) => c.met).length}/${parsed.criteria.length} criteria met`
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function isSpecComplianceEnabled(config) {
+  return config?.enabled === true;
+}
+function formatSpecCompliance(result) {
+  const lines = ["", "---", "## Spec Compliance", ""];
+  lines.push(`**${result.summary}**`);
+  lines.push("");
+  lines.push("| Criterion | Status | Evidence |");
+  lines.push("|-----------|--------|----------|");
+  for (const c of result.criteria) {
+    const status = c.met ? "Met" : "Not Met";
+    const evidence = c.evidence.replace(/\|/g, "\\|").replace(/\n/g, " ");
+    const criterion = c.criterion.replace(/\|/g, "\\|").replace(/\n/g, " ");
+    lines.push(`| ${criterion} | ${status} | ${evidence} |`);
+  }
+  return lines.join("\n");
+}
+
 // src/prompt.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { join as join5, resolve } from "path";
@@ -3117,7 +3261,7 @@ function isDirectory(path) {
 }
 
 // src/git/bitbucket.ts
-import { execa } from "execa";
+import { execa as execa2 } from "execa";
 var API_URL3 = "https://api.bitbucket.org/2.0";
 var REQUEST_TIMEOUT_MS2 = 3e4;
 var PROVIDER_DISPLAY_NAMES = {
@@ -3206,7 +3350,7 @@ async function appendPrBody2(prUrl, content) {
 }
 
 // src/git/gitlab.ts
-import { execa as execa2 } from "execa";
+import { execa as execa3 } from "execa";
 var REQUEST_TIMEOUT_MS3 = 3e4;
 var PROVIDER_DISPLAY_NAMES2 = {
   claude: "Claude Code",
@@ -3312,6 +3456,19 @@ async function appendPlatformProofOfWork(prUrl, results, platform2) {
   } catch {
   }
 }
+async function appendPlatformSpecCompliance(prUrl, result, platform2) {
+  const section = formatSpecCompliance(result);
+  try {
+    if (platform2 === "gitlab") {
+      await appendMrBody(prUrl, section);
+    } else if (platform2 === "bitbucket") {
+      await appendPrBody2(prUrl, section);
+    } else {
+      await appendPrBody(prUrl, section);
+    }
+  } catch {
+  }
+}
 function buildPrCreateInstruction(platform2, targetBranch) {
   const base = targetBranch ? ` --base ${targetBranch}` : "";
   if (platform2 === "gitlab") {
@@ -3939,12 +4096,19 @@ export {
   readContext,
   WATCH_POLL_INTERVAL_MS,
   resolveModels,
-  analyzeProject,
   runValidationCommands,
   buildValidationRecoveryPrompt,
   isProofOfWorkEnabled,
+  extractAcceptanceCriteria,
+  getFullDiff,
+  buildCompliancePrompt,
+  buildComplianceRecoveryPrompt,
+  parseComplianceResponse,
+  isSpecComplianceEnabled,
+  analyzeProject,
   appendPlatformAttribution,
   appendPlatformProofOfWork,
+  appendPlatformSpecCompliance,
   detectPackageManager,
   detectTestRunner,
   buildImplementPrompt,