shiva-code 0.2.1 → 0.3.0

package/dist/chunk-66D4NGIK.js

@@ -0,0 +1,560 @@
+import {
+  cache
+} from "./chunk-G2G6UUWM.js";
+
+// src/services/github.ts
+import { execSync, spawnSync } from "child_process";
+function isGhInstalled() {
+  try {
+    execSync("which gh", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isGhAuthenticated() {
+  try {
+    const result = spawnSync("gh", ["auth", "status"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+function getGhUser() {
+  try {
+    const result = spawnSync("gh", ["api", "user", "--jq", ".login"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.status === 0 && result.stdout) {
+      return result.stdout.trim();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function runGh(args, cwd) {
+  try {
+    const result = spawnSync("gh", args, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd
+    });
+    if (result.status === 0 && result.stdout) {
+      return JSON.parse(result.stdout);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function runGhRaw(args, cwd) {
+  try {
+    const result = spawnSync("gh", args, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd
+    });
+    if (result.status === 0 && result.stdout) {
+      return result.stdout.trim();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function isGitRepo(projectPath) {
+  try {
+    const result = spawnSync("git", ["rev-parse", "--git-dir"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: projectPath
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+function getCurrentBranch(projectPath) {
+  try {
+    const result = spawnSync("git", ["branch", "--show-current"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: projectPath
+    });
+    if (result.status === 0 && result.stdout) {
+      return result.stdout.trim() || "HEAD";
+    }
+    return "HEAD";
+  } catch {
+    return "HEAD";
+  }
+}
+function getRecentCommits(projectPath, count = 5) {
+  try {
+    const format = '{"sha": "%h", "message": "%s", "author": "%an", "date": "%ci"}';
+    const result = spawnSync(
+      "git",
+      ["log", `-${count}`, `--pretty=format:${format}`],
+      {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: projectPath
+      }
+    );
+    if (result.status === 0 && result.stdout) {
+      const lines = result.stdout.trim().split("\n").filter(Boolean);
+      return lines.map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter((c) => c !== null);
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+function getGitHubRemote(projectPath) {
+  try {
+    const result = spawnSync("git", ["remote", "get-url", "origin"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: projectPath
+    });
+    if (result.status === 0 && result.stdout) {
+      const url = result.stdout.trim();
+      if (url.includes("github.com")) {
+        return url;
+      }
+    }
+    const remotesResult = spawnSync("git", ["remote", "-v"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: projectPath
+    });
+    if (remotesResult.status === 0 && remotesResult.stdout) {
+      const lines = remotesResult.stdout.split("\n");
+      for (const line of lines) {
+        if (line.includes("github.com") && line.includes("(fetch)")) {
+          const match = line.match(/\s+(.+)\s+\(fetch\)/);
+          if (match) return match[1];
+        }
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function parseGitHubUrl(url) {
+  const sshMatch = url.match(/git@github\.com:([^/]+)\/([^.]+)(?:\.git)?/);
+  if (sshMatch) {
+    return { owner: sshMatch[1], name: sshMatch[2] };
+  }
+  const httpsMatch = url.match(/https:\/\/github\.com\/([^/]+)\/([^/.]+)(?:\.git)?/);
+  if (httpsMatch) {
+    return { owner: httpsMatch[1], name: httpsMatch[2] };
+  }
+  return null;
+}
+function getRepoInfo(projectPath) {
+  if (!isGitRepo(projectPath)) {
+    return null;
+  }
+  const remoteUrl = getGitHubRemote(projectPath);
+  if (!remoteUrl) {
+    return null;
+  }
+  const parsed = parseGitHubUrl(remoteUrl);
+  if (!parsed) {
+    return null;
+  }
+  const repoData = runGh(
+    ["repo", "view", `${parsed.owner}/${parsed.name}`, "--json", "defaultBranchRef,isPrivate,url"],
+    projectPath
+  );
+  return {
+    owner: parsed.owner,
+    name: parsed.name,
+    fullName: `${parsed.owner}/${parsed.name}`,
+    url: repoData?.url || `https://github.com/${parsed.owner}/${parsed.name}`,
+    defaultBranch: repoData?.defaultBranchRef?.name || "main",
+    isPrivate: repoData?.isPrivate || false
+  };
+}
+function isGitHubRepo(projectPath) {
+  return getRepoInfo(projectPath) !== null;
+}
+function getOpenIssues(repo, options) {
+  const cacheKey = `${repo}:${options?.assignee || ""}:${options?.labels?.join(",") || ""}`;
+  if (!options?.skipCache && !options?.assignee && !options?.labels) {
+    const cached = cache.getGitHubIssues(repo);
+    if (cached) {
+      return options?.limit ? cached.slice(0, options.limit) : cached;
+    }
+  }
+  const args = [
+    "issue",
+    "list",
+    "-R",
+    repo,
+    "--json",
+    "number,title,state,author,assignees,labels,body,url,createdAt,updatedAt"
+  ];
+  if (options?.assignee) {
+    args.push("--assignee", options.assignee);
+  }
+  if (options?.labels && options.labels.length > 0) {
+    args.push("--label", options.labels.join(","));
+  }
+  if (options?.limit) {
+    args.push("--limit", String(options.limit));
+  }
+  const issues = runGh(args);
+  if (!issues) {
+    return [];
+  }
+  const mappedIssues = issues.map((issue) => ({
+    number: issue.number,
+    title: issue.title,
+    state: issue.state.toLowerCase(),
+    author: issue.author?.login || "unknown",
+    assignees: issue.assignees?.map((a) => a.login) || [],
+    labels: issue.labels?.map((l) => l.name) || [],
+    body: issue.body || "",
+    url: issue.url,
+    createdAt: issue.createdAt,
+    updatedAt: issue.updatedAt,
+    repo
+  }));
+  if (!options?.assignee && !options?.labels) {
+    cache.setGitHubIssues(repo, mappedIssues);
+  }
+  return mappedIssues;
+}
+function getIssue(repo, number) {
+  const issue = runGh(
+    ["issue", "view", String(number), "-R", repo, "--json", "number,title,state,author,assignees,labels,body,url,createdAt,updatedAt"]
+  );
+  if (!issue) {
+    return null;
+  }
+  return {
+    number: issue.number,
+    title: issue.title,
+    state: issue.state.toLowerCase(),
+    author: issue.author?.login || "unknown",
+    assignees: issue.assignees?.map((a) => a.login) || [],
+    labels: issue.labels?.map((l) => l.name) || [],
+    body: issue.body || "",
+    url: issue.url,
+    createdAt: issue.createdAt,
+    updatedAt: issue.updatedAt,
+    repo
+  };
+}
+function findMentionedIssueNumbers(text) {
+  const matches = text.match(/#(\d+)/g);
+  if (!matches) {
+    return [];
+  }
+  return [...new Set(matches.map((m) => parseInt(m.slice(1), 10)))];
+}
+function getOpenPRs(repo, options) {
+  if (!options?.skipCache && !options?.author && (!options?.state || options.state === "open")) {
+    const cached = cache.getGitHubPRs(repo);
+    if (cached) {
+      return options?.limit ? cached.slice(0, options.limit) : cached;
+    }
+  }
+  const args = [
+    "pr",
+    "list",
+    "-R",
+    repo,
+    "--json",
+    "number,title,state,author,headRefName,baseRefName,isDraft,reviewDecision,statusCheckRollup,url,body,createdAt,updatedAt"
+  ];
+  if (options?.author) {
+    args.push("--author", options.author);
+  }
+  if (options?.state && options.state !== "all") {
+    args.push("--state", options.state);
+  }
+  if (options?.limit) {
+    args.push("--limit", String(options.limit));
+  }
+  const prs = runGh(args);
+  if (!prs) {
+    return [];
+  }
+  const mappedPRs = prs.map((pr) => ({
+    number: pr.number,
+    title: pr.title,
+    state: pr.state.toLowerCase(),
+    author: pr.author?.login || "unknown",
+    headBranch: pr.headRefName,
+    baseBranch: pr.baseRefName,
+    isDraft: pr.isDraft,
+    reviewDecision: mapReviewDecision(pr.reviewDecision),
+    checksStatus: mapChecksStatus(pr.statusCheckRollup),
+    url: pr.url,
+    body: pr.body || "",
+    repo,
+    createdAt: pr.createdAt,
+    updatedAt: pr.updatedAt
+  }));
+  if (!options?.author && (!options?.state || options.state === "open")) {
+    cache.setGitHubPRs(repo, mappedPRs);
+  }
+  return mappedPRs;
+}
+function getPRForBranch(repo, branch) {
+  const prs = runGh(
+    ["pr", "list", "-R", repo, "--head", branch, "--json", "number,title,state,author,headRefName,baseRefName,isDraft,reviewDecision,statusCheckRollup,url,body,createdAt,updatedAt"]
+  );
+  if (!prs || prs.length === 0) {
+    return null;
+  }
+  const pr = prs[0];
+  return {
+    number: pr.number,
+    title: pr.title,
+    state: pr.state.toLowerCase(),
+    author: pr.author?.login || "unknown",
+    headBranch: pr.headRefName,
+    baseBranch: pr.baseRefName,
+    isDraft: pr.isDraft,
+    reviewDecision: mapReviewDecision(pr.reviewDecision),
+    checksStatus: mapChecksStatus(pr.statusCheckRollup),
+    url: pr.url,
+    body: pr.body || "",
+    repo,
+    createdAt: pr.createdAt,
+    updatedAt: pr.updatedAt
+  };
+}
+function getPR(repo, number) {
+  const pr = runGh(
+    ["pr", "view", String(number), "-R", repo, "--json", "number,title,state,author,headRefName,baseRefName,isDraft,reviewDecision,statusCheckRollup,url,body,createdAt,updatedAt"]
+  );
+  if (!pr) {
+    return null;
+  }
+  return {
+    number: pr.number,
+    title: pr.title,
+    state: pr.state.toLowerCase(),
+    author: pr.author?.login || "unknown",
+    headBranch: pr.headRefName,
+    baseBranch: pr.baseRefName,
+    isDraft: pr.isDraft,
+    reviewDecision: mapReviewDecision(pr.reviewDecision),
+    checksStatus: mapChecksStatus(pr.statusCheckRollup),
+    url: pr.url,
+    body: pr.body || "",
+    repo,
+    createdAt: pr.createdAt,
+    updatedAt: pr.updatedAt
+  };
+}
+function mapReviewDecision(decision) {
+  if (!decision) return null;
+  const lower = decision.toLowerCase();
+  if (lower === "approved") return "approved";
+  if (lower === "changes_requested") return "changes_requested";
+  if (lower === "review_required") return "review_required";
+  return null;
+}
+function mapChecksStatus(checks) {
+  if (!checks || checks.length === 0) return null;
+  const hasFailure = checks.some((c) => c.conclusion === "FAILURE");
+  const hasPending = checks.some((c) => c.status !== "COMPLETED");
+  if (hasFailure) return "failure";
+  if (hasPending) return "pending";
+  return "success";
+}
+function getCIStatus(repo, branch) {
+  const runs = runGh(
+    ["run", "list", "-R", repo, "--branch", branch, "--limit", "1", "--json", "status,conclusion"]
+  );
+  if (!runs || runs.length === 0) {
+    return "none";
+  }
+  const run = runs[0];
+  if (run.status !== "completed") {
+    return "pending";
+  }
+  if (run.conclusion === "success") {
+    return "success";
+  }
+  return "failure";
+}
+async function generateGitHubContext(projectPath, skipCache = false) {
+  if (!skipCache) {
+    const cached = cache.getGitHubContext(projectPath);
+    if (cached) {
+      return cached;
+    }
+  }
+  if (!isGhInstalled() || !isGhAuthenticated()) {
+    return null;
+  }
+  const repo = getRepoInfo(projectPath);
+  if (!repo) {
+    return null;
+  }
+  const currentBranch = getCurrentBranch(projectPath);
+  const currentUser = getGhUser();
+  const currentPR = getPRForBranch(repo.fullName, currentBranch);
+  const openPRs = getOpenPRs(repo.fullName, { limit: 10, skipCache });
+  const assignedIssues = currentUser ? getOpenIssues(repo.fullName, { assignee: currentUser, limit: 10, skipCache }) : [];
+  const recentCommits = getRecentCommits(projectPath, 5);
+  const ciStatus = getCIStatus(repo.fullName, currentBranch);
+  const mentionedNumbers = /* @__PURE__ */ new Set();
+  findMentionedIssueNumbers(currentBranch).forEach((n) => mentionedNumbers.add(n));
+  recentCommits.forEach((c) => {
+    findMentionedIssueNumbers(c.message).forEach((n) => mentionedNumbers.add(n));
+  });
+  const assignedNumbers = new Set(assignedIssues.map((i) => i.number));
+  const mentionedIssues = [];
+  for (const num of mentionedNumbers) {
+    if (!assignedNumbers.has(num)) {
+      const issue = getIssue(repo.fullName, num);
+      if (issue && issue.state === "open") {
+        mentionedIssues.push(issue);
+      }
+    }
+  }
+  const context = {
+    repo,
+    currentBranch,
+    currentPR,
+    openPRs,
+    assignedIssues,
+    mentionedIssues,
+    recentCommits,
+    ciStatus,
+    lastFetched: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  cache.setGitHubContext(projectPath, context);
+  return context;
+}
+function invalidateGitHubCache(repo) {
+  if (repo) {
+    cache.invalidateGitHubRepo(repo);
+  } else {
+    cache.invalidateGitHub();
+  }
+}
+function formatContextAsMarkdown(context) {
+  const lines = [];
+  lines.push("# GitHub Context");
+  lines.push("");
+  if (context.repo) {
+    const visibility = context.repo.isPrivate ? "private" : "public";
+    lines.push(`## Repository`);
+    lines.push(`**${context.repo.fullName}** (${visibility})`);
+    lines.push(`Branch: \`${context.currentBranch}\` \u2192 \`${context.repo.defaultBranch}\``);
+    lines.push("");
+  }
+  if (context.currentPR) {
+    const pr = context.currentPR;
+    const statusIcons = {
+      success: "\u2713",
+      failure: "\u2717",
+      pending: "\u23F3",
+      null: "\u25CB"
+    };
+    const reviewIcons = {
+      approved: "\u2713 Approved",
+      changes_requested: "\u274C Changes requested",
+      review_required: "\u{1F440} Review required",
+      null: "No review"
+    };
+    lines.push("## Your Current PR");
+    lines.push(`### #${pr.number}: ${pr.title}`);
+    lines.push(`- Status: ${pr.state}`);
+    lines.push(`- CI: ${statusIcons[pr.checksStatus || "null"]} ${pr.checksStatus || "none"}`);
+    lines.push(`- Review: ${reviewIcons[pr.reviewDecision || "null"]}`);
+    lines.push(`- Branch: \`${pr.headBranch}\` \u2192 \`${pr.baseBranch}\``);
+    lines.push("");
+  }
+  if (context.assignedIssues.length > 0) {
+    lines.push("## Assigned to You");
+    for (const issue of context.assignedIssues) {
+      const labels = issue.labels.length > 0 ? ` [${issue.labels.join(", ")}]` : "";
+      lines.push(`- \u{1F534} #${issue.number}: ${issue.title}${labels}`);
+    }
+    lines.push("");
+  }
+  if (context.mentionedIssues.length > 0) {
+    lines.push("## Related Issues (mentioned in branch/commits)");
+    for (const issue of context.mentionedIssues) {
+      lines.push(`- #${issue.number}: ${issue.title}`);
+    }
+    lines.push("");
+  }
+  const otherPRs = context.openPRs.filter((pr) => pr.number !== context.currentPR?.number);
+  if (otherPRs.length > 0) {
+    lines.push("## Other Open PRs");
+    for (const pr of otherPRs.slice(0, 5)) {
+      const ciIcon = pr.checksStatus === "success" ? "\u2713" : pr.checksStatus === "failure" ? "\u2717" : "\u25CB";
+      lines.push(`- #${pr.number}: ${pr.title} (${ciIcon} @${pr.author})`);
+    }
+    lines.push("");
+  }
+  if (context.recentCommits.length > 0) {
+    lines.push("## Recent Commits");
+    for (const commit of context.recentCommits) {
+      lines.push(`- \`${commit.sha}\` ${commit.message}`);
+    }
+    lines.push("");
+  }
+  if (context.ciStatus !== "none") {
+    const statusText = {
+      success: "\u2713 All checks passed",
+      failure: "\u2717 Checks failing",
+      pending: "\u23F3 Checks running",
+      none: "No checks"
+    };
+    lines.push("## CI/CD");
+    lines.push(`Status: ${statusText[context.ciStatus]}`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("*Context generated by SHIVA Code*");
+  return lines.join("\n");
+}
+
+export {
+  isGhInstalled,
+  isGhAuthenticated,
+  getGhUser,
+  runGh,
+  runGhRaw,
+  isGitRepo,
+  getCurrentBranch,
+  getRecentCommits,
+  getGitHubRemote,
+  parseGitHubUrl,
+  getRepoInfo,
+  isGitHubRepo,
+  getOpenIssues,
+  getIssue,
+  findMentionedIssueNumbers,
+  getOpenPRs,
+  getPRForBranch,
+  getPR,
+  getCIStatus,
+  generateGitHubContext,
+  invalidateGitHubCache,
+  formatContextAsMarkdown
+};