@tarcisiopgs/lisa 1.19.3 → 1.20.1

package/dist/chunk-7CIXBENY.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+// src/version.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+var PACKAGE_NAME = "@tarcisiopgs/lisa";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+function getCachePath() {
+  let base;
+  if (process.env.XDG_CACHE_HOME) {
+    base = process.env.XDG_CACHE_HOME;
+  } else if (platform() === "darwin") {
+    base = join(homedir(), "Library", "Caches");
+  } else {
+    base = join(homedir(), ".cache");
+  }
+  return join(base, "lisa", "update-check.json");
+}
+function readCache() {
+  try {
+    const raw = readFileSync(getCachePath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    const path = getCachePath();
+    const dir = join(path, "..");
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(path, JSON.stringify(cache));
+  } catch {
+  }
+}
+function compareVersions(current, latest) {
+  const [cMajor = 0, cMinor = 0, cPatch = 0] = current.split(".").map(Number);
+  const [lMajor = 0, lMinor = 0, lPatch = 0] = latest.split(".").map(Number);
+  if (lMajor > cMajor) return "major";
+  if (lMajor === cMajor && lMinor > cMinor) return "minor";
+  if (lMajor === cMajor && lMinor === cMinor && lPatch > cPatch) return "patch";
+  return null;
+}
+var cachedResult;
+async function checkForUpdate(currentVersion) {
+  if (cachedResult !== void 0) return cachedResult;
+  try {
+    const cache = readCache();
+    if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
+      if (cache.latestVersion) {
+        const updateType = compareVersions(currentVersion, cache.latestVersion);
+        cachedResult = updateType ? { currentVersion, latestVersion: cache.latestVersion, updateType } : null;
+        return cachedResult;
+      }
+      cachedResult = null;
+      return null;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const response = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}/latest`,
+      { signal: controller.signal }
+    );
+    clearTimeout(timeout);
+    if (!response.ok) {
+      writeCache({ lastCheck: Date.now(), latestVersion: null });
+      cachedResult = null;
+      return null;
+    }
+    const data = await response.json();
+    const latestVersion = data.version ?? null;
+    writeCache({ lastCheck: Date.now(), latestVersion });
+    if (latestVersion) {
+      const updateType = compareVersions(currentVersion, latestVersion);
+      cachedResult = updateType ? { currentVersion, latestVersion, updateType } : null;
+      return cachedResult;
+    }
+    cachedResult = null;
+    return null;
+  } catch {
+    cachedResult = null;
+    return null;
+  }
+}
+function getCachedUpdateInfo() {
+  return cachedResult ?? null;
+}
+
+export {
+  checkForUpdate,
+  getCachedUpdateInfo
+};

package/dist/{chunk-2SHKSRQZ.js → chunk-HDOVPYNL.js}

@@ -80,6 +80,21 @@ function banner() {
   console.log(pc.yellow(`  \u2514${border}\u2518
 `));
 }
+function updateNotice(update) {
+  if (outputMode !== "default") return;
+  const msg = `Update available ${pc.dim(update.currentVersion)} \u2192 ${pc.green(pc.bold(update.latestVersion))}`;
+  const cmd = `Run ${pc.cyan("npm i -g @tarcisiopgs/lisa")} to update`;
+  const lines = [msg, cmd];
+  const strip = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+  const maxLen = Math.max(...lines.map((l) => strip(l).length));
+  const pad = (s) => s + " ".repeat(maxLen - strip(s).length);
+  console.log(pc.yellow(`  \u250C${"\u2500".repeat(maxLen + 2)}\u2510`));
+  for (const line of lines) {
+    console.log(pc.yellow("  \u2502 ") + pad(line) + pc.yellow(" \u2502"));
+  }
+  console.log(pc.yellow(`  \u2514${"\u2500".repeat(maxLen + 2)}\u2518
+`));
+}
 
 // src/sources/github-issues.ts
 var API_URL = "https://api.github.com";
@@ -838,6 +853,7 @@ export {
   ok,
   divider,
   banner,
+  updateNotice,
   GitHubIssuesSource,
   GitLabIssuesSource,
   kanbanEmitter,

package/dist/chunk-LAJNLRXO.js

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+
+// src/cli/detection.ts
+import { execSync } from "child_process";
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { tmpdir } from "os";
+import { join, resolve as resolvePath } from "path";
+import * as clack from "@clack/prompts";
+
+// src/git/github.ts
+import { execa } from "execa";
+
+// src/git/pr-body.ts
+var PROVIDER_ATTRIBUTION_RE = /claude\.ai|claude\s+code|gemini\s+cli|openai\s+codex|\bgoose\b|\baider\b|github\s+copilot|cursor\s+agent|\bopencode\b/i;
+var AI_COAUTHOR_RE = /co-authored-by:[^\n]*(anthropic|claude|gemini|openai|codex|goose|aider|copilot|cursor|google)/i;
+function stripProviderAttribution(body) {
+  let result = body;
+  while (true) {
+    const sepIndex = result.lastIndexOf("\n---");
+    if (sepIndex === -1) break;
+    const section = result.slice(sepIndex);
+    if (PROVIDER_ATTRIBUTION_RE.test(section) || AI_COAUTHOR_RE.test(section)) {
+      result = result.slice(0, sepIndex).trimEnd();
+    } else {
+      break;
+    }
+  }
+  result = result.replace(
+    /\n+Co-Authored-By:[^\n]*(anthropic|claude|gemini|openai|codex|goose|aider|copilot|cursor|google)[^\n]*/gi,
+    ""
+  );
+  return result.trimEnd();
+}
+
+// src/git/github.ts
+async function isGhCliAvailable() {
+  try {
+    await execa("gh", ["auth", "status"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var PROVIDER_DISPLAY_NAMES = {
+  claude: "Claude Code",
+  gemini: "Gemini CLI",
+  opencode: "OpenCode",
+  copilot: "GitHub Copilot CLI",
+  cursor: "Cursor Agent",
+  goose: "Goose",
+  aider: "Aider",
+  codex: "OpenAI Codex"
+};
+function formatProviderName(providerUsed) {
+  const providerKey = providerUsed.split("/")[0] ?? providerUsed;
+  return PROVIDER_DISPLAY_NAMES[providerKey] ?? providerKey;
+}
+async function deleteProviderComments(prUrl) {
+  try {
+    const match = prUrl.match(/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/);
+    if (!match) return;
+    const [, owner, repo, prNumber] = match;
+    const { stdout } = await execa("gh", [
+      "api",
+      "--paginate",
+      "--jq",
+      ".[]",
+      `/repos/${owner}/${repo}/issues/${prNumber}/comments`
+    ]);
+    const comments = stdout.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
+    for (const comment of comments) {
+      if (PROVIDER_ATTRIBUTION_RE.test(comment.body)) {
+        try {
+          await execa("gh", [
+            "api",
+            "--method",
+            "DELETE",
+            `/repos/${owner}/${repo}/issues/comments/${comment.id}`
+          ]);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+async function appendPrAttribution(prUrl, providerUsed) {
+  await deleteProviderComments(prUrl);
+  try {
+    const { stdout: bodyJson } = await execa("gh", ["pr", "view", prUrl, "--json", "body"]);
+    const { body } = JSON.parse(bodyJson);
+    const providerName = formatProviderName(providerUsed);
+    const attribution = `
+
+---
+\u{1F916} Resolved by [lisa](https://github.com/tarcisiopgs/lisa) using **${providerName}**`;
+    const newBody = stripProviderAttribution(body ?? "") + attribution;
+    await execa("gh", ["pr", "edit", prUrl, "--body", newBody]);
+  } catch {
+  }
+}
+
+// src/cli/detection.ts
+function getVersion() {
+  try {
+    const pkgPath = resolvePath(new URL(".", import.meta.url).pathname, "../package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+var CURSOR_FREE_PLAN_ERROR = "Free plans can only use Auto";
+async function isCursorFreePlan() {
+  const { mkdtempSync, unlinkSync, writeFileSync } = await import("fs");
+  const tmpDir = mkdtempSync(join(tmpdir(), "lisa-cursor-check-"));
+  const promptFile = join(tmpDir, "prompt.txt");
+  writeFileSync(promptFile, "test", "utf-8");
+  try {
+    const bin = ["agent", "cursor-agent"].find((b) => {
+      try {
+        execSync(`${b} --version`, { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    if (!bin) return false;
+    const output = execSync(`${bin} -p "$(cat '${promptFile}')" --output-format text`, {
+      cwd: process.cwd(),
+      encoding: "utf-8",
+      timeout: 3e4
+    });
+    return output.includes(CURSOR_FREE_PLAN_ERROR);
+  } catch (err) {
+    const errorOutput = err instanceof Error ? err.message : String(err);
+    return errorOutput.includes(CURSOR_FREE_PLAN_ERROR);
+  } finally {
+    try {
+      unlinkSync(promptFile);
+    } catch {
+    }
+    try {
+      execSync(`rm -rf ${tmpDir}`, { stdio: "ignore" });
+    } catch {
+    }
+  }
+}
+var CURSOR_PREFERRED_MODELS = [
+  "auto",
+  "composer-1.5",
+  "composer-1",
+  "gpt-5.3-codex",
+  "gpt-5.2",
+  "gpt-5.1-codex-max",
+  "opus-4.6-thinking",
+  "opus-4.6",
+  "sonnet-4.6-thinking",
+  "sonnet-4.6",
+  "gemini-3.1-pro",
+  "gemini-3-pro",
+  "grok",
+  "kimi-k2.5"
+];
+function fetchCursorModels() {
+  try {
+    const bin = ["agent", "cursor-agent"].find((b) => {
+      try {
+        execSync(`${b} --version`, { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    if (!bin) return CURSOR_PREFERRED_MODELS;
+    const raw = execSync(`${bin} --list-models`, { encoding: "utf-8", timeout: 1e4 });
+    const clean = raw.replace(/\x1b\[[0-9;]*[mGKHFA-Z]/g, "");
+    const all = clean.split("\n").map((l) => l.trim()).filter((l) => l.includes(" - ")).map((l) => (l.split(" - ")[0] ?? "").trim()).filter(Boolean);
+    const filtered = CURSOR_PREFERRED_MODELS.filter((m) => all.includes(m));
+    return filtered.length > 0 ? filtered : CURSOR_PREFERRED_MODELS;
+  } catch {
+    return CURSOR_PREFERRED_MODELS;
+  }
+}
+function fetchOpenCodeModels() {
+  try {
+    const raw = execSync("opencode models", { encoding: "utf-8", timeout: 1e4 });
+    const clean = raw.replace(/\x1b\[[0-9;]*[mGKHFA-Z]/g, "");
+    return clean.split("\n").map((l) => l.trim()).filter((m) => /^[a-z0-9][\w.-]*\/.+/i.test(m));
+  } catch {
+    return [];
+  }
+}
+function detectPlatformFromRemoteUrl(remoteUrl) {
+  if (/github\.com/.test(remoteUrl)) return "cli";
+  if (/gitlab\./.test(remoteUrl)) return "gitlab";
+  if (/bitbucket\.org/.test(remoteUrl)) return "bitbucket";
+  return null;
+}
+async function detectPlatform() {
+  let detectedPlatform = null;
+  try {
+    const remoteUrl = execSync("git remote get-url origin", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    detectedPlatform = detectPlatformFromRemoteUrl(remoteUrl);
+    if (detectedPlatform) {
+      const platformLabel = detectedPlatform === "cli" || detectedPlatform === "token" ? "GitHub" : detectedPlatform === "gitlab" ? "GitLab" : "Bitbucket";
+      clack.log.info(`Detected ${platformLabel} remote`);
+    }
+  } catch {
+  }
+  const initialValue = detectedPlatform ?? "cli";
+  const selected = await clack.select({
+    message: "How should Lisa create pull requests?",
+    initialValue,
+    options: [
+      { value: "cli", label: "GitHub CLI", hint: "uses `gh pr create` \u2014 recommended for GitHub" },
+      { value: "token", label: "GitHub API", hint: "uses GITHUB_TOKEN directly" },
+      { value: "gitlab", label: "GitLab API", hint: "uses GITLAB_TOKEN (glab or REST API)" },
+      { value: "bitbucket", label: "Bitbucket API", hint: "uses BITBUCKET_TOKEN (REST API)" }
+    ]
+  });
+  if (clack.isCancel(selected)) return process.exit(0);
+  const platform = selected;
+  await verifyPlatformCredential(platform);
+  return platform;
+}
+async function verifyPlatformCredential(platform) {
+  if (platform === "cli") {
+    const hasCli = await isGhCliAvailable();
+    if (!hasCli) {
+      clack.log.warning(
+        "GitHub CLI (`gh`) is not authenticated. Run `gh auth login` before using Lisa."
+      );
+    }
+    return;
+  }
+  if (platform === "token") {
+    if (!process.env.GITHUB_TOKEN) {
+      clack.log.warning("GITHUB_TOKEN is not set. Add it to your shell profile.");
+    }
+    return;
+  }
+  if (platform === "gitlab") {
+    if (!process.env.GITLAB_TOKEN) {
+      clack.log.warning("GITLAB_TOKEN is not set. Add it to your shell profile.");
+    }
+    return;
+  }
+  if (platform === "bitbucket") {
+    if (!process.env.BITBUCKET_TOKEN) {
+      clack.log.warning("BITBUCKET_TOKEN is not set. Add it to your shell profile.");
+    }
+    return;
+  }
+}
+async function detectGitRepos(existingRepos = []) {
+  const cwd = process.cwd();
+  if (existsSync(join(cwd, ".git"))) {
+    clack.log.info("Found a git repository in the current directory.");
+    return [];
+  }
+  const entries = readdirSync(cwd, { withFileTypes: true });
+  const gitDirs = entries.filter((e) => e.isDirectory() && existsSync(join(cwd, e.name, ".git"))).map((e) => e.name);
+  const existingDirs = existingRepos.map((r) => r.path.replace(/^\.\//, ""));
+  const missingDirs = existingDirs.filter((d) => !gitDirs.includes(d));
+  if (gitDirs.length === 0 && missingDirs.length === 0) {
+    return [];
+  }
+  const options = [
+    ...gitDirs.map((dir) => ({ value: dir, label: dir, disabled: false })),
+    ...missingDirs.map((dir) => ({
+      value: dir,
+      label: dir,
+      hint: "(not found on disk)",
+      disabled: true
+    }))
+  ];
+  const initialValues = existingDirs.filter((d) => gitDirs.includes(d));
+  const selected = await clack.multiselect({
+    message: "Multiple git repositories found \u2014 which ones should Lisa work on?",
+    options,
+    initialValues
+  });
+  if (clack.isCancel(selected)) return process.exit(0);
+  return selected.map((dir) => ({
+    name: getGitRepoName(join(cwd, dir)) ?? dir,
+    path: `./${dir}`,
+    match: existingRepos.find((r) => r.path === `./${dir}`)?.match ?? "",
+    base_branch: existingRepos.find((r) => r.path === `./${dir}`)?.base_branch ?? ""
+  }));
+}
+function detectDefaultBranch(repoPath) {
+  try {
+    const ref = execSync("git symbolic-ref refs/remotes/origin/HEAD --short", {
+      cwd: repoPath,
+      encoding: "utf-8"
+    }).trim();
+    return ref.replace("origin/", "");
+  } catch {
+    return "main";
+  }
+}
+function getGitRepoName(repoPath) {
+  try {
+    const url = execSync("git remote get-url origin", { cwd: repoPath, encoding: "utf-8" }).trim();
+    const match = url.match(/\/([^/]+?)(?:\.git)?$/) ?? url.match(/:([^/]+?)(?:\.git)?$/);
+    return match?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+async function getMissingEnvVars(source) {
+  const missing = [];
+  if (!process.env.GITHUB_TOKEN) {
+    const ghAvailable = await isGhCliAvailable();
+    if (!ghAvailable) missing.push("GITHUB_TOKEN");
+  }
+  if (source === "linear") {
+    if (!process.env.LINEAR_API_KEY) missing.push("LINEAR_API_KEY");
+  } else if (source === "trello") {
+    if (!process.env.TRELLO_API_KEY) missing.push("TRELLO_API_KEY");
+    if (!process.env.TRELLO_TOKEN) missing.push("TRELLO_TOKEN");
+  } else if (source === "github-issues") {
+  } else if (source === "gitlab-issues") {
+    if (!process.env.GITLAB_TOKEN) missing.push("GITLAB_TOKEN");
+  } else if (source === "plane") {
+    if (!process.env.PLANE_API_TOKEN) missing.push("PLANE_API_TOKEN");
+  } else if (source === "shortcut") {
+    if (!process.env.SHORTCUT_API_TOKEN) missing.push("SHORTCUT_API_TOKEN");
+  } else if (source === "jira") {
+    if (!process.env.JIRA_BASE_URL) missing.push("JIRA_BASE_URL");
+    if (!process.env.JIRA_EMAIL) missing.push("JIRA_EMAIL");
+    if (!process.env.JIRA_API_TOKEN) missing.push("JIRA_API_TOKEN");
+  }
+  return missing;
+}
+
+export {
+  stripProviderAttribution,
+  isGhCliAvailable,
+  appendPrAttribution,
+  getVersion,
+  isCursorFreePlan,
+  fetchCursorModels,
+  fetchOpenCodeModels,
+  detectPlatformFromRemoteUrl,
+  detectPlatform,
+  verifyPlatformCredential,
+  detectGitRepos,
+  detectDefaultBranch,
+  getGitRepoName,
+  getMissingEnvVars
+};

package/dist/detection-LALQE6Q3.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import {
+  detectDefaultBranch,
+  detectGitRepos,
+  detectPlatform,
+  detectPlatformFromRemoteUrl,
+  fetchCursorModels,
+  fetchOpenCodeModels,
+  getGitRepoName,
+  getMissingEnvVars,
+  getVersion,
+  isCursorFreePlan,
+  verifyPlatformCredential
+} from "./chunk-LAJNLRXO.js";
+export {
+  detectDefaultBranch,
+  detectGitRepos,
+  detectPlatform,
+  detectPlatformFromRemoteUrl,
+  fetchCursorModels,
+  fetchOpenCodeModels,
+  getGitRepoName,
+  getMissingEnvVars,
+  getVersion,
+  isCursorFreePlan,
+  verifyPlatformCredential
+};