@tarcisiopgs/lisa 1.28.1 → 1.29.0

package/README.md

@@ -31,7 +31,7 @@ lisa         # start the agent loop
   Plan → Create issues → Fetch → Implement → Push → Open PR → Update board → Next
 ```
 
-Lisa starts and shows a Kanban board. If the queue is empty, press `n` to plan — describe a goal and the AI decomposes it into atomic issues, created directly in your tracker. Press `r` to start processing. Lisa picks the highest-priority labeled issue, moves it to "In Progress", sends a structured prompt to the AI agent, and monitors execution. The agent works in an isolated git worktree, implements the change, runs tests, and commits. Lisa pushes, opens a PR, moves the ticket to "In Review", and picks up the next one.
+Lisa starts and shows a Kanban board. If the queue is empty, press `n` to plan — describe a goal and the AI brainstorms with you (asking clarifying questions), presents its understanding for your confirmation, then decomposes the goal into atomic issues created directly in your tracker. You can review, edit, reorder, delete, or regenerate the plan with feedback before approving. Press `r` to start processing. Lisa picks the highest-priority labeled issue, moves it to "In Progress", sends a structured prompt to the AI agent, and monitors execution. The agent works in an isolated git worktree, implements the change, runs tests, and commits. Lisa pushes, opens a PR, moves the ticket to "In Review", and picks up the next one.
 
 If something fails — pre-push hooks, quota limits, stuck processes — Lisa handles it: retries with error context, falls back to the next model, or kills and moves on.
 
@@ -39,7 +39,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 decomposes it into issues with dependencies, created in your tracker
+- **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
 - **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
@@ -90,9 +91,11 @@ lisa --watch                # poll for new issues after queue empties
 lisa -c 3                   # process 3 issues in parallel
 lisa --issue INT-42         # process a specific issue
 lisa --limit 5              # stop after 5 issues
-lisa plan "Add rate limiting" # decompose goal into issues via AI (CLI mode)
+lisa plan "Add rate limiting" # brainstorm + decompose goal into issues via AI
 lisa plan --issue EPIC-123  # decompose existing issue into sub-issues
 lisa plan --continue        # resume interrupted plan
+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 doctor                 # diagnose setup issues (config, provider, env, git)
@@ -214,6 +217,18 @@ lifecycle:
   mode: auto               # "auto", "skip" (default), "validate-only"
   timeout: 30
 
+proof_of_work:
+  enabled: true
+  block_on_failure: true   # skip PR when validation fails (default: false)
+  max_retries: 2           # retry agent on validation failure
+  commands:
+    - name: lint
+      run: pnpm run lint
+    - name: typecheck
+      run: pnpm run typecheck
+    - name: test
+      run: pnpm run test
+
 validation:
   require_acceptance_criteria: true
 ```
@@ -271,6 +286,8 @@ The real-time Kanban board shows issue progress, streams provider output, and de
 | `a` | Approve and create issues |
 | `Esc` | Cancel / 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.
+
 ## License
 
 [MIT](LICENSE)

package/dist/{chunk-42NKASE3.js → chunk-LQZQML3A.js}

@@ -2,7 +2,7 @@
 import {
   formatError,
   isGhCliAvailable
-} from "./chunk-2TW2MJXF.js";
+} from "./chunk-NMQ6YMBH.js";
 
 // src/cli/detection.ts
 import { execSync } from "child_process";

package/dist/{chunk-FCEUJ7VK.js → chunk-NDNEDFG5.js}

@@ -1,67 +1,27 @@
 #!/usr/bin/env node
 import {
   buildContextMdBlock,
-  readContext
-} from "./chunk-UXVSQQID.js";
+  readContext,
+  resolveModels,
+  runWithFallback
+} from "./chunk-YURAUUDI.js";
 import {
+  error,
+  log,
   normalizeLabels,
   ok,
   warn
 } from "./chunk-5N4BWHIT.js";
 
-// src/plan/create.ts
-async function createPlanIssues(source, config, plan) {
-  if (!source.createIssue) {
-    throw new Error(`Source "${source.name}" does not support createIssue`);
-  }
-  const labels = normalizeLabels(config);
-  const primaryLabel = labels[0] ?? "";
-  const sorted = [...plan.issues].sort((a, b) => a.order - b.order);
-  const createdIds = [];
-  const orderToId = /* @__PURE__ */ new Map();
-  for (const issue of sorted) {
-    let description = issue.description;
-    if (issue.dependsOn.length > 0 && !source.linkDependency) {
-      const depRefs = issue.dependsOn.map((depOrder) => {
-        const depId = orderToId.get(depOrder);
-        return depId ? `#${depId}` : `step ${depOrder}`;
-      }).join(", ");
-      description += `
-
----
-_Depends on: ${depRefs}_`;
-    }
-    const id = await source.createIssue(
-      {
-        title: issue.title,
-        description,
-        status: config.pick_from,
-        label: primaryLabel,
-        order: issue.order,
-        parentId: plan.sourceIssueId
-      },
-      config
-    );
-    createdIds.push(id);
-    orderToId.set(issue.order, id);
-    ok(`${id}: ${issue.title}`);
-    if (source.linkDependency && issue.dependsOn.length > 0) {
-      for (const depOrder of issue.dependsOn) {
-        const depId = orderToId.get(depOrder);
-        if (depId) {
-          try {
-            await source.linkDependency(id, depId);
-          } catch (err) {
-            warn(
-              `Could not link dependency ${id} \u2192 ${depId}: ${err instanceof Error ? err.message : String(err)}`
-            );
-          }
-        }
-      }
-    }
+// src/cli/error.ts
+var CliError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
   }
-  return createdIds;
-}
+};
 
 // src/plan/parser.ts
 function parsePlanResponse(raw) {
@@ -116,43 +76,296 @@ var PlanParseError = class extends Error {
   }
 };
 
-// src/plan/persistence.ts
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-function plansDir(workspace) {
-  return join(workspace, ".lisa", "plans");
+// src/plan/structured-output.ts
+function parseStructuredOutput(raw) {
+  const cleaned = stripAnsi(raw).trim();
+  const parsed = extractStructuredJson(cleaned);
+  if (parsed) {
+    if (parsed.type === "issues" && Array.isArray(parsed.issues)) {
+      try {
+        const issues = parsePlanResponse(JSON.stringify({ issues: parsed.issues }));
+        return { type: "issues", issues };
+      } catch {
+      }
+    }
+    if (parsed.type === "summary" && typeof parsed.text === "string") {
+      return { type: "summary", text: parsed.text };
+    }
+    if (parsed.type === "question" && typeof parsed.text === "string") {
+      return { type: "question", text: parsed.text };
+    }
+  }
+  try {
+    const issues = parsePlanResponse(cleaned);
+    return { type: "issues", issues };
+  } catch {
+  }
+  return { type: "question", text: extractCleanText(cleaned) };
 }
-function savePlan(workspace, plan) {
-  const dir = plansDir(workspace);
-  mkdirSync(dir, { recursive: true });
-  const filename = `${plan.createdAt.replace(/[:.]/g, "-")}.json`;
-  const filePath = join(dir, filename);
-  writeFileSync(filePath, JSON.stringify(plan, null, 2));
-  return filePath;
+function extractStructuredJson(text2) {
+  const fenceMatch = text2.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (fenceMatch) {
+    const result = tryParseStructured(fenceMatch[1].trim());
+    if (result) return result;
+  }
+  const bracePositions = [];
+  for (let i = text2.length - 1; i >= 0; i--) {
+    if (text2[i] === "}") {
+      bracePositions.push(i);
+    }
+  }
+  for (const endPos of bracePositions) {
+    let depth = 0;
+    let startPos = -1;
+    for (let i = endPos; i >= 0; i--) {
+      if (text2[i] === "}") depth++;
+      if (text2[i] === "{") depth--;
+      if (depth === 0) {
+        startPos = i;
+        break;
+      }
+    }
+    if (startPos !== -1) {
+      const candidate = text2.slice(startPos, endPos + 1);
+      const result = tryParseStructured(candidate);
+      if (result) return result;
+    }
+  }
+  return null;
 }
-function loadPlan(filePath) {
-  if (!existsSync(filePath)) return null;
+function tryParseStructured(jsonStr) {
   try {
-    return JSON.parse(readFileSync(filePath, "utf-8"));
+    const obj = JSON.parse(jsonStr);
+    if (typeof obj === "object" && obj !== null && typeof obj.type === "string") {
+      return obj;
+    }
   } catch {
-    return null;
   }
+  return null;
 }
-function loadLatestPlan(workspace) {
-  const dir = plansDir(workspace);
-  if (!existsSync(dir)) return null;
-  const files = readdirSync(dir).filter((f) => f.endsWith(".json")).sort().reverse();
-  for (const file of files) {
-    const filePath = join(dir, file);
-    const plan = loadPlan(filePath);
-    if (plan && plan.status !== "created") return [plan, filePath];
+function stripAnsi(text2) {
+  return text2.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "");
+}
+function extractCleanText(text2) {
+  if (text2.length < 500) return text2;
+  const lines = text2.split("\n").filter((l) => l.trim().length > 0);
+  return lines.slice(-10).join("\n");
+}
+
+// src/plan/create.ts
+async function createPlanIssues(source, config, plan) {
+  if (!source.createIssue) {
+    throw new Error(`Source "${source.name}" does not support createIssue`);
   }
-  return null;
+  const labels = normalizeLabels(config);
+  const primaryLabel = labels[0] ?? "";
+  const sorted = [...plan.issues].sort((a, b) => a.order - b.order);
+  const createdIds = [];
+  const orderToId = /* @__PURE__ */ new Map();
+  for (const issue of sorted) {
+    let description = issue.description;
+    if (issue.dependsOn.length > 0 && !source.linkDependency) {
+      const depRefs = issue.dependsOn.map((depOrder) => {
+        const depId = orderToId.get(depOrder);
+        return depId ? `#${depId}` : `step ${depOrder}`;
+      }).join(", ");
+      description += `
+
+---
+_Depends on: ${depRefs}_`;
+    }
+    const id = await source.createIssue(
+      {
+        title: issue.title,
+        description,
+        status: config.pick_from,
+        label: primaryLabel,
+        order: issue.order,
+        parentId: plan.sourceIssueId
+      },
+      config
+    );
+    createdIds.push(id);
+    orderToId.set(issue.order, id);
+    ok(`${id}: ${issue.title}`);
+    if (source.linkDependency && issue.dependsOn.length > 0) {
+      for (const depOrder of issue.dependsOn) {
+        const depId = orderToId.get(depOrder);
+        if (depId) {
+          try {
+            await source.linkDependency(id, depId);
+          } catch (err) {
+            warn(
+              `Could not link dependency ${id} \u2192 ${depId}: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      }
+    }
+  }
+  return createdIds;
 }
 
 // src/plan/prompt.ts
 import { resolve } from "path";
+
+// src/plan/language.ts
+var STOP_WORDS = {
+  pt: /* @__PURE__ */ new Set([
+    "n\xE3o",
+    "tamb\xE9m",
+    "j\xE1",
+    "est\xE1",
+    "s\xE3o",
+    "nos",
+    "das",
+    "dos",
+    "pelo",
+    "pela",
+    "uma",
+    "nas",
+    "aos",
+    "essa",
+    "esse",
+    "isso",
+    "aqui",
+    "muito",
+    "quando",
+    "como",
+    "mais",
+    "ainda",
+    "fazer",
+    "deve",
+    "pode",
+    "cada",
+    "todos",
+    "todas",
+    "entre",
+    "ap\xF3s",
+    "sobre",
+    "seus",
+    "suas",
+    "desta",
+    "deste",
+    "onde",
+    "apenas",
+    // Common contractions (preposition + article)
+    "na",
+    "no",
+    "da",
+    "do",
+    "ao",
+    "num",
+    "numa",
+    "para",
+    "com",
+    "sem",
+    "ou"
+  ]),
+  es: /* @__PURE__ */ new Set([
+    "tambi\xE9n",
+    "m\xE1s",
+    "pero",
+    "muy",
+    "est\xE1",
+    "est\xE1n",
+    "puede",
+    "todo",
+    "esta",
+    "este",
+    "como",
+    "cuando",
+    "donde",
+    "cada",
+    "entre",
+    "sobre",
+    "despu\xE9s",
+    "antes",
+    "desde",
+    "hasta",
+    "seg\xFAn",
+    "durante",
+    "todos",
+    "todas",
+    "otro",
+    "otra",
+    "otros",
+    "otras",
+    "hacer",
+    "debe",
+    "aqu\xED",
+    "ahora",
+    "siempre",
+    "nunca"
+  ]),
+  en: /* @__PURE__ */ new Set([
+    "the",
+    "is",
+    "are",
+    "was",
+    "were",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "having",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "might",
+    "shall",
+    "this",
+    "that",
+    "these",
+    "those",
+    "with",
+    "from",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "between",
+    "each",
+    "every",
+    "which",
+    "when",
+    "where",
+    "while"
+  ])
+};
+var LANGUAGE_NAMES = {
+  pt: "Portuguese",
+  es: "Spanish",
+  en: "English"
+};
+function detectLanguage(text2) {
+  const words = text2.toLowerCase().replace(/[^\p{L}\s]/gu, "").split(/\s+/).filter((w) => w.length > 1);
+  if (words.length === 0) return "en";
+  const scores = { pt: 0, es: 0, en: 0 };
+  for (const word of words) {
+    for (const [lang, stopWords] of Object.entries(STOP_WORDS)) {
+      if (stopWords.has(word)) {
+        scores[lang]++;
+      }
+    }
+  }
+  const best = Object.entries(scores).sort((a, b) => b[1] - a[1])[0];
+  return best[1] > 0 ? best[0] : "en";
+}
+function languageName(code) {
+  return LANGUAGE_NAMES[code] ?? "English";
+}
+
+// src/plan/prompt.ts
 function buildPlanningPrompt(goal, config, parentIssueDescription) {
+  const language = detectLanguage(goal);
   const workspace = resolve(config.workspace);
   const contextMd = readContext(workspace);
   const contextBlock = buildContextMdBlock(contextMd);
@@ -186,6 +399,10 @@ For each issue, provide:
 - **order**: Integer (1-based) \u2014 execution order based on dependencies
 - **dependsOn**: Array of order numbers this issue depends on (empty if independent)
 ${config.repos.length > 1 ? "- **repo**: Name of the target repository from the list above (required for multi-repo)\n" : ""}
+## Language
+
+Respond in ${languageName(language)}. Generate all issue titles, descriptions, and acceptance criteria in ${languageName(language)}.
+
 ## Rules
 
 1. Each issue MUST be self-contained and completable in a single session
@@ -203,13 +420,118 @@ Respond with ONLY this JSON structure (no wrapping, no markdown):
 {"issues":[{"title":"...","description":"...","acceptanceCriteria":["..."],"relevantFiles":["..."],"order":1,"dependsOn":[]${config.repos.length > 1 ? ',"repo":"..."' : ""}}]}`;
 }
 
+// src/plan/persistence.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+function plansDir(workspace) {
+  return join(workspace, ".lisa", "plans");
+}
+function savePlan(workspace, plan) {
+  const dir = plansDir(workspace);
+  mkdirSync(dir, { recursive: true });
+  const filename = `${plan.createdAt.replace(/[:.]/g, "-")}.json`;
+  const filePath = join(dir, filename);
+  writeFileSync(filePath, JSON.stringify(plan, null, 2));
+  return filePath;
+}
+function loadPlan(filePath) {
+  if (!existsSync(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function loadLatestPlan(workspace) {
+  const dir = plansDir(workspace);
+  if (!existsSync(dir)) return null;
+  const files = readdirSync(dir).filter((f) => f.endsWith(".json")).sort().reverse();
+  for (const file of files) {
+    const filePath = join(dir, file);
+    const plan = loadPlan(filePath);
+    if (plan && plan.status !== "created") return [plan, filePath];
+  }
+  return null;
+}
+
 // src/plan/wizard.ts
 import { execSync } from "child_process";
-import { mkdtempSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { tmpdir } from "os";
-import { join as join2 } from "path";
+import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join3 } from "path";
 import * as clack from "@clack/prompts";
 import pc from "picocolors";
+
+// src/plan/generate.ts
+import { mkdtempSync } from "fs";
+import { tmpdir } from "os";
+import { join as join2, resolve as resolve2 } from "path";
+var MAX_PARSE_RETRIES = 2;
+async function generatePlan(goal, config, opts) {
+  let prompt = buildPlanningPrompt(goal, config, opts?.parentDescription);
+  if (opts?.feedback) {
+    const previousBlock = opts.previousTitles && opts.previousTitles.length > 0 ? `
+The previous plan had ${opts.previousTitles.length} issues: ${opts.previousTitles.join(", ")}` : "";
+    prompt += `
+
+## Regeneration Feedback
+
+The user reviewed the previous plan and wants changes:${previousBlock}
+
+User feedback: ${opts.feedback}
+
+Regenerate the plan considering this feedback. Output ONLY the JSON structure defined above.`;
+  }
+  log("Analyzing codebase and decomposing goal...");
+  const models = resolveModels(config);
+  const logDir = mkdtempSync(join2(tmpdir(), "lisa-plan-"));
+  const logFile = join2(logDir, "plan.log");
+  const result = await runWithFallback(models, prompt, {
+    logFile,
+    cwd: resolve2(config.workspace),
+    sessionTimeout: 120
+  });
+  if (!result.success) {
+    throw new CliError(`AI provider failed to generate plan: ${result.output.slice(0, 200)}`);
+  }
+  let lastError = null;
+  for (let attempt = 0; attempt <= MAX_PARSE_RETRIES; attempt++) {
+    try {
+      if (attempt === 0) {
+        return parsePlanResponse(result.output);
+      }
+      const retryPrompt = `${prompt}
+
+## Previous Attempt Failed
+
+Your previous response could not be parsed: ${lastError.message}
+
+Please output ONLY valid JSON with the exact structure specified above.`;
+      const retryResult = await runWithFallback(models, retryPrompt, {
+        logFile,
+        cwd: resolve2(config.workspace),
+        sessionTimeout: 120
+      });
+      if (retryResult.success) {
+        return parsePlanResponse(retryResult.output);
+      }
+    } catch (err) {
+      if (err instanceof PlanParseError) {
+        lastError = err;
+        if (attempt < MAX_PARSE_RETRIES) {
+          warn(`Parse attempt ${attempt + 1} failed: ${err.message}. Retrying...`);
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+  throw new CliError(
+    `Failed to parse AI response after ${MAX_PARSE_RETRIES + 1} attempts: ${lastError?.message}`
+  );
+}
+
+// src/plan/wizard.ts
 async function runPlanWizard(plan, planPath, opts) {
   const workspace = opts.config.workspace;
   while (true) {
@@ -221,6 +543,10 @@ async function runPlanWizard(plan, planPath, opts) {
         { value: "edit", label: `${pc.yellow("Edit")} \u2014 edit an issue in $EDITOR` },
         { value: "delete", label: `${pc.red("Delete")} \u2014 remove an issue` },
         { value: "reorder", label: `${pc.cyan("Reorder")} \u2014 change execution order` },
+        {
+          value: "regenerate",
+          label: `${pc.magenta("Regenerate")} \u2014 regenerate plan with feedback`
+        },
         { value: "cancel", label: `${pc.gray("Cancel")} \u2014 save and exit` }
       ]
     });
@@ -246,6 +572,13 @@ async function runPlanWizard(plan, planPath, opts) {
       await reorderIssues(plan, workspace);
       savePlan(workspace, plan);
     }
+    if (action === "regenerate") {
+      const regenerated = await regeneratePlan(plan, opts);
+      if (regenerated) {
+        plan.issues = regenerated;
+        savePlan(workspace, plan);
+      }
+    }
   }
 }
 function displayPlan(plan) {
@@ -280,8 +613,8 @@ async function editIssue(plan, workspace) {
   if (clack.isCancel(choice)) return;
   const issue = plan.issues.find((i) => i.order === choice);
   if (!issue) return;
-  const tmpDir = mkdtempSync(join2(tmpdir(), "lisa-edit-"));
-  const tmpFile = join2(tmpDir, "issue.md");
+  const tmpDir = mkdtempSync2(join3(tmpdir2(), "lisa-edit-"));
+  const tmpFile = join3(tmpDir, "issue.md");
   writeFileSync2(tmpFile, issueToMarkdown(issue));
   const editor = process.env.EDITOR || process.env.VISUAL || "vi";
   try {
@@ -348,6 +681,28 @@ async function reorderIssues(plan, _workspace) {
   }
   clack.log.success("Issues reordered.");
 }
+async function regeneratePlan(plan, opts) {
+  const feedback = await clack.text({
+    message: "What would you like to change?",
+    placeholder: 'e.g., "Group into max 3 issues" or "Add tests for each issue"',
+    validate: (v) => !v?.trim() ? "Please describe what to change" : void 0
+  });
+  if (clack.isCancel(feedback)) return null;
+  const spinner2 = clack.spinner();
+  spinner2.start("Regenerating plan...");
+  try {
+    const issues = await generatePlan(plan.goal, opts.config, {
+      feedback,
+      previousTitles: plan.issues.map((i) => i.title)
+    });
+    spinner2.stop("Plan regenerated.");
+    return issues;
+  } catch (err) {
+    spinner2.stop("Regeneration failed.");
+    error(`Failed to regenerate: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
 function issueToMarkdown(issue) {
   let md = `# ${issue.title}
 
@@ -395,12 +750,15 @@ function markdownToIssue(content, original) {
 }
 
 export {
+  CliError,
+  detectLanguage,
+  languageName,
+  parseStructuredOutput,
   createPlanIssues,
-  parsePlanResponse,
-  PlanParseError,
+  buildPlanningPrompt,
+  generatePlan,
   savePlan,
   loadLatestPlan,
-  buildPlanningPrompt,
   runPlanWizard,
   issueToMarkdown,
   markdownToIssue