@tarcisiopgs/lisa 1.26.2 → 1.28.0

package/dist/chunk-FCEUJ7VK.js

@@ -0,0 +1,407 @@
+#!/usr/bin/env node
+import {
+  buildContextMdBlock,
+  readContext
+} from "./chunk-UXVSQQID.js";
+import {
+  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)}`
+            );
+          }
+        }
+      }
+    }
+  }
+  return createdIds;
+}
+
+// src/plan/parser.ts
+function parsePlanResponse(raw) {
+  let cleaned = raw.trim();
+  const fenceMatch = cleaned.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (fenceMatch) {
+    cleaned = fenceMatch[1].trim();
+  }
+  const jsonStart = cleaned.indexOf("{");
+  const jsonEnd = cleaned.lastIndexOf("}");
+  if (jsonStart === -1 || jsonEnd === -1) {
+    throw new PlanParseError("No JSON object found in AI response");
+  }
+  cleaned = cleaned.slice(jsonStart, jsonEnd + 1);
+  let parsed;
+  try {
+    parsed = JSON.parse(cleaned);
+  } catch (err) {
+    throw new PlanParseError(`Invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!Array.isArray(parsed.issues) || parsed.issues.length === 0) {
+    throw new PlanParseError("Response must contain a non-empty 'issues' array");
+  }
+  if (parsed.issues.length > 12) {
+    throw new PlanParseError(
+      `Too many issues (${parsed.issues.length}). Decompose into 2-8 atomic issues.`
+    );
+  }
+  const issues = parsed.issues.map((issue, idx) => {
+    if (!issue.title || typeof issue.title !== "string") {
+      throw new PlanParseError(`Issue ${idx + 1}: missing or invalid 'title'`);
+    }
+    if (!issue.description || typeof issue.description !== "string") {
+      throw new PlanParseError(`Issue ${idx + 1}: missing or invalid 'description'`);
+    }
+    return {
+      title: issue.title,
+      description: issue.description,
+      acceptanceCriteria: Array.isArray(issue.acceptanceCriteria) ? issue.acceptanceCriteria.filter((c) => typeof c === "string") : [],
+      relevantFiles: Array.isArray(issue.relevantFiles) ? issue.relevantFiles.filter((f) => typeof f === "string") : [],
+      order: typeof issue.order === "number" ? issue.order : idx + 1,
+      dependsOn: Array.isArray(issue.dependsOn) ? issue.dependsOn.filter((d) => typeof d === "number") : [],
+      repo: typeof issue.repo === "string" ? issue.repo : void 0
+    };
+  });
+  return issues;
+}
+var PlanParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PlanParseError";
+  }
+};
+
+// 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/prompt.ts
+import { resolve } from "path";
+function buildPlanningPrompt(goal, config, parentIssueDescription) {
+  const workspace = resolve(config.workspace);
+  const contextMd = readContext(workspace);
+  const contextBlock = buildContextMdBlock(contextMd);
+  const repoBlock = config.repos.length > 0 ? config.repos.map(
+    (r) => `- **${r.name}**: \`${resolve(workspace, r.path)}\` (base: \`${r.base_branch}\`)`
+  ).join("\n") : `- **${workspace}** (single-repo, base: \`${config.base_branch}\`)`;
+  const parentBlock = parentIssueDescription ? `
+## Parent Issue Description
+
+${parentIssueDescription}
+` : "";
+  return `You are a project planning agent. Your job is to decompose a high-level goal into atomic, implementable issues.
+
+## Goal
+
+${goal}
+${parentBlock}
+## Available Repositories
+
+${repoBlock}
+${contextBlock}
+## Instructions
+
+Analyze the goal and the codebase context above. Decompose the goal into **2-8 atomic issues** that can each be completed in a single AI coding session (under 1 hour of agent work).
+
+For each issue, provide:
+- **title**: Short, descriptive title (imperative: "Add X", "Fix Y", "Create Z")
+- **description**: Full markdown description with context, approach, and acceptance criteria as a \`- [ ]\` checklist
+- **acceptanceCriteria**: Array of the checklist items as plain strings
+- **relevantFiles**: Array of file paths in the codebase that will be modified or created
+- **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" : ""}
+## Rules
+
+1. Each issue MUST be self-contained and completable in a single session
+2. Each issue MUST have at least 2 acceptance criteria
+3. Each issue MUST reference specific file paths (existing or to be created)
+4. Issues MUST include test expectations in their acceptance criteria
+5. Order issues so dependencies come first (lower order = executes first)
+6. Use clear, specific titles \u2014 not vague ("Improve X" is bad, "Add rate limit middleware to /api/users" is good)
+7. Output ONLY valid JSON \u2014 no markdown code fences, no explanation text
+
+## Output Format
+
+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/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 * as clack from "@clack/prompts";
+import pc from "picocolors";
+async function runPlanWizard(plan, planPath, opts) {
+  const workspace = opts.config.workspace;
+  while (true) {
+    displayPlan(plan);
+    const action = await clack.select({
+      message: "What would you like to do?",
+      options: [
+        { value: "approve", label: `${pc.green("Approve all")} \u2014 create issues in source` },
+        { 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: "cancel", label: `${pc.gray("Cancel")} \u2014 save and exit` }
+      ]
+    });
+    if (clack.isCancel(action) || action === "cancel") {
+      plan.status = "draft";
+      savePlan(workspace, plan);
+      return false;
+    }
+    if (action === "approve") {
+      plan.status = "approved";
+      savePlan(workspace, plan);
+      return true;
+    }
+    if (action === "edit") {
+      await editIssue(plan, workspace);
+      savePlan(workspace, plan);
+    }
+    if (action === "delete") {
+      await deleteIssue(plan, workspace);
+      savePlan(workspace, plan);
+    }
+    if (action === "reorder") {
+      await reorderIssues(plan, workspace);
+      savePlan(workspace, plan);
+    }
+  }
+}
+function displayPlan(plan) {
+  clack.log.info(`${pc.bold("Goal:")} ${plan.goal}`);
+  clack.log.info("");
+  const sorted = [...plan.issues].sort((a, b) => a.order - b.order);
+  for (const issue of sorted) {
+    const deps = issue.dependsOn.length > 0 ? pc.gray(` \u2192 depends on: ${issue.dependsOn.map((d) => `#${d}`).join(", ")}`) : "";
+    const repo = issue.repo ? pc.cyan(` [${issue.repo}]`) : "";
+    const files = issue.relevantFiles.length > 0 ? pc.gray(
+      `
+     Files: ${issue.relevantFiles.slice(0, 3).join(", ")}${issue.relevantFiles.length > 3 ? ` +${issue.relevantFiles.length - 3}` : ""}`
+    ) : "";
+    clack.log.info(
+      `  ${pc.yellow(String(issue.order))}. ${pc.bold(issue.title)}${repo}${deps}${files}`
+    );
+  }
+  clack.log.info("");
+}
+async function editIssue(plan, workspace) {
+  if (plan.issues.length === 0) {
+    clack.log.warning("No issues to edit.");
+    return;
+  }
+  const choice = await clack.select({
+    message: "Which issue to edit?",
+    options: plan.issues.map((issue2) => ({
+      value: issue2.order,
+      label: `${issue2.order}. ${issue2.title}`
+    }))
+  });
+  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");
+  writeFileSync2(tmpFile, issueToMarkdown(issue));
+  const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+  try {
+    execSync(`${editor} "${tmpFile}"`, { stdio: "inherit" });
+  } catch {
+    clack.log.error("Editor failed. Issue unchanged.");
+    return;
+  }
+  const content = readFileSync2(tmpFile, "utf-8");
+  const updated = markdownToIssue(content, issue);
+  Object.assign(issue, updated);
+  clack.log.success(`Updated: ${issue.title}`);
+}
+async function deleteIssue(plan, _workspace) {
+  if (plan.issues.length === 0) {
+    clack.log.warning("No issues to delete.");
+    return;
+  }
+  const choice = await clack.select({
+    message: "Which issue to delete?",
+    options: plan.issues.map((issue) => ({
+      value: issue.order,
+      label: `${issue.order}. ${issue.title}`
+    }))
+  });
+  if (clack.isCancel(choice)) return;
+  const idx = plan.issues.findIndex((i) => i.order === choice);
+  if (idx === -1) return;
+  const removed = plan.issues.splice(idx, 1)[0];
+  for (const issue of plan.issues) {
+    issue.dependsOn = issue.dependsOn.filter((d) => d !== removed.order);
+  }
+  clack.log.success(`Deleted: ${removed.title}`);
+}
+async function reorderIssues(plan, _workspace) {
+  if (plan.issues.length <= 1) {
+    clack.log.warning("Need at least 2 issues to reorder.");
+    return;
+  }
+  clack.log.info("Enter new order (comma-separated issue numbers):");
+  clack.log.info(
+    `Current: ${plan.issues.sort((a, b) => a.order - b.order).map((i) => i.order).join(", ")}`
+  );
+  const answer = await clack.text({
+    message: "New order (e.g., 3,1,2,4):",
+    validate: (input = "") => {
+      const nums = input.split(",").map((n) => Number(n.trim()));
+      if (nums.some(Number.isNaN)) return "Enter comma-separated numbers";
+      if (nums.length !== plan.issues.length) return `Expected ${plan.issues.length} numbers`;
+      return void 0;
+    }
+  });
+  if (clack.isCancel(answer)) return;
+  const newOrder = answer.split(",").map((n) => Number(n.trim()));
+  const oldOrderMap = /* @__PURE__ */ new Map();
+  for (const issue of plan.issues) {
+    oldOrderMap.set(issue.order, issue);
+  }
+  for (let i = 0; i < newOrder.length; i++) {
+    const issue = oldOrderMap.get(newOrder[i]);
+    if (issue) {
+      issue.order = i + 1;
+    }
+  }
+  clack.log.success("Issues reordered.");
+}
+function issueToMarkdown(issue) {
+  let md = `# ${issue.title}
+
+`;
+  md += `${issue.description}
+`;
+  if (issue.relevantFiles.length > 0) {
+    md += `
+## Relevant Files
+
+`;
+    for (const f of issue.relevantFiles) {
+      md += `- ${f}
+`;
+    }
+  }
+  return md;
+}
+function markdownToIssue(content, original) {
+  const lines = content.split("\n");
+  const titleLine = lines.find((l) => l.startsWith("# "));
+  const title = titleLine ? titleLine.replace(/^#\s+/, "").trim() : original.title;
+  const titleIdx = lines.indexOf(titleLine ?? "");
+  const filesIdx = lines.findIndex((l) => l.startsWith("## Relevant Files"));
+  const descLines = filesIdx > 0 ? lines.slice(titleIdx + 1, filesIdx) : lines.slice(titleIdx + 1);
+  const description = descLines.join("\n").trim();
+  const acceptanceCriteria = descLines.filter((l) => l.trim().startsWith("- [ ]") || l.trim().startsWith("- [x]")).map((l) => l.trim().replace(/^- \[[ x]\]\s*/, ""));
+  const relevantFiles = [];
+  if (filesIdx > 0) {
+    for (let i = filesIdx + 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith("- ")) {
+        relevantFiles.push(line.replace(/^- /, ""));
+      } else if (line.startsWith("#")) {
+        break;
+      }
+    }
+  }
+  return {
+    title,
+    description: description || original.description,
+    acceptanceCriteria: acceptanceCriteria.length > 0 ? acceptanceCriteria : original.acceptanceCriteria,
+    relevantFiles: relevantFiles.length > 0 ? relevantFiles : original.relevantFiles
+  };
+}
+
+export {
+  createPlanIssues,
+  parsePlanResponse,
+  PlanParseError,
+  savePlan,
+  loadLatestPlan,
+  buildPlanningPrompt,
+  runPlanWizard,
+  issueToMarkdown,
+  markdownToIssue
+};