@mndrk/agx 2.4.10 → 2.4.11

package/cloud-runtime/standalone/apps/local/lib/git-diff-cli.ts

@@ -0,0 +1,232 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileP = promisify(execFile);
+
+const MAX_BUFFER = 64 * 1024 * 1024;
+
+/**
+ * Splits a single unified diff (output of `gh pr diff` or `git diff`) into per-file patches.
+ * Returns a map of `path` -> patch text starting at the first `@@` hunk header.
+ */
+export function splitUnifiedDiffByFile(diff: string): Map<string, string> {
+  const result = new Map<string, string>();
+  if (!diff) return result;
+
+  const lines = diff.split("\n");
+  let currentPath: string | null = null;
+  let buffer: string[] = [];
+  const flush = () => {
+    if (currentPath) {
+      const text = buffer.join("\n").trimEnd();
+      if (text.length > 0) result.set(currentPath, text);
+    }
+    buffer = [];
+  };
+
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      flush();
+      const m = line.match(/diff --git a\/(.+?) b\/(.+)$/);
+      currentPath = m ? m[2] : null;
+      continue;
+    }
+    if (!currentPath) continue;
+    if (
+      line.startsWith("index ") ||
+      line.startsWith("--- ") ||
+      line.startsWith("+++ ") ||
+      line.startsWith("new file mode") ||
+      line.startsWith("deleted file mode") ||
+      line.startsWith("similarity index") ||
+      line.startsWith("rename from") ||
+      line.startsWith("rename to") ||
+      line.startsWith("Binary files")
+    ) {
+      continue;
+    }
+    buffer.push(line);
+  }
+  flush();
+  return result;
+}
+
+export interface GitFileChange {
+  path: string;
+  status: "added" | "modified" | "removed" | "renamed";
+  additions: number;
+  deletions: number;
+  patch: string | null;
+}
+
+export interface GitDiffResult {
+  files: GitFileChange[];
+  base: string;
+  ref: string; // branch name OR "WORKING_TREE"
+  headSha: string;
+}
+
+function mapStatusLetter(letter: string): GitFileChange["status"] {
+  const c = letter.charAt(0).toUpperCase();
+  switch (c) {
+    case "A":
+      return "added";
+    case "D":
+      return "removed";
+    case "R":
+      return "renamed";
+    case "M":
+      return "modified";
+    default:
+      return "modified";
+  }
+}
+
+interface NumstatRow {
+  additions: number;
+  deletions: number;
+  path: string;
+}
+
+function parseNumstat(stdout: string): NumstatRow[] {
+  const rows: NumstatRow[] = [];
+  const lines = stdout.split("\n");
+  for (const line of lines) {
+    if (!line) continue;
+    const parts = line.split("\t");
+    if (parts.length < 3) continue;
+    const addRaw = parts[0];
+    const delRaw = parts[1];
+    // Path may be in parts[2], or for renames it could be a `{old => new}` form,
+    // or there may be additional path columns (parts[3] = new path).
+    let path: string;
+    if (parts.length >= 4 && parts[2] && parts[3]) {
+      // Rename form: `-\t-\told\tnew` or `1\t2\told\tnew`
+      path = parts[3];
+    } else {
+      const raw = parts[2];
+      const braceMatch = raw.match(/^(.*)\{([^{}]*)\s*=>\s*([^{}]*)\}(.*)$/);
+      if (braceMatch) {
+        const prefix = braceMatch[1];
+        const newMid = braceMatch[3].trim();
+        const suffix = braceMatch[4];
+        path = `${prefix}${newMid}${suffix}`.replace(/\/\//g, "/");
+      } else {
+        path = raw;
+      }
+    }
+    const additions = addRaw === "-" ? 0 : Number.parseInt(addRaw, 10) || 0;
+    const deletions = delRaw === "-" ? 0 : Number.parseInt(delRaw, 10) || 0;
+    rows.push({ additions, deletions, path });
+  }
+  return rows;
+}
+
+interface NameStatusRow {
+  status: GitFileChange["status"];
+  path: string;
+}
+
+function parseNameStatus(stdout: string): NameStatusRow[] {
+  const rows: NameStatusRow[] = [];
+  const lines = stdout.split("\n");
+  for (const line of lines) {
+    if (!line) continue;
+    const parts = line.split("\t");
+    if (parts.length < 2) continue;
+    const letter = parts[0];
+    const status = mapStatusLetter(letter);
+    // Renames: R100\told\tnew -- pull the new path
+    let path: string;
+    if (status === "renamed" && parts.length >= 3) {
+      path = parts[2];
+    } else {
+      path = parts[parts.length - 1];
+    }
+    rows.push({ status, path });
+  }
+  return rows;
+}
+
+async function runGit(repoPath: string, args: string[], opts?: { maxBuffer?: number }): Promise<string> {
+  const fullArgs = ["-C", repoPath, ...args];
+  const { stdout } = await execFileP("git", fullArgs, {
+    maxBuffer: opts?.maxBuffer ?? MAX_BUFFER,
+  });
+  return stdout;
+}
+
+async function buildResult(args: {
+  repoPath: string;
+  base: string;
+  ref: string;
+  numstatArgs: string[];
+  nameStatusArgs: string[];
+  patchArgs: string[];
+  headRevParseArg: string;
+}): Promise<GitDiffResult> {
+  const [numstatOut, nameStatusOut, patchOut, headShaRaw] = await Promise.all([
+    runGit(args.repoPath, args.numstatArgs),
+    runGit(args.repoPath, args.nameStatusArgs),
+    runGit(args.repoPath, args.patchArgs),
+    runGit(args.repoPath, ["rev-parse", args.headRevParseArg]),
+  ]);
+
+  const numstat = parseNumstat(numstatOut);
+  const nameStatus = parseNameStatus(nameStatusOut);
+  const patches = splitUnifiedDiffByFile(patchOut);
+
+  // Join by path. Use nameStatus order as canonical.
+  const numByPath = new Map<string, NumstatRow>();
+  for (const row of numstat) numByPath.set(row.path, row);
+
+  const files: GitFileChange[] = nameStatus.map((row) => {
+    const num = numByPath.get(row.path);
+    return {
+      path: row.path,
+      status: row.status,
+      additions: num?.additions ?? 0,
+      deletions: num?.deletions ?? 0,
+      patch: patches.get(row.path) ?? null,
+    };
+  });
+
+  return {
+    files,
+    base: args.base,
+    ref: args.ref,
+    headSha: headShaRaw.trim(),
+  };
+}
+
+export async function diffBranch(args: {
+  repoPath: string;
+  base: string;
+  ref: string;
+}): Promise<GitDiffResult> {
+  const range = `${args.base}...${args.ref}`;
+  return buildResult({
+    repoPath: args.repoPath,
+    base: args.base,
+    ref: args.ref,
+    numstatArgs: ["diff", "--numstat", range],
+    nameStatusArgs: ["diff", "--name-status", range],
+    patchArgs: ["diff", range],
+    headRevParseArg: args.ref,
+  });
+}
+
+export async function diffWorkingTree(args: {
+  repoPath: string;
+  base: string;
+}): Promise<GitDiffResult> {
+  return buildResult({
+    repoPath: args.repoPath,
+    base: args.base,
+    ref: "WORKING_TREE",
+    numstatArgs: ["diff", "--numstat", args.base],
+    nameStatusArgs: ["diff", "--name-status", args.base],
+    patchArgs: ["diff", args.base],
+    headRevParseArg: "HEAD",
+  });
+}

package/cloud-runtime/standalone/apps/local/lib/git-repo-index.ts

@@ -0,0 +1,144 @@
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+
+export interface RepoIndexEntry {
+  path: string;
+  discoveredAt: number;
+}
+
+export interface RepoIndex {
+  entries: RepoIndexEntry[];
+  scannedAt: number;
+}
+
+export const REPO_INDEX_PATH: string = path.join(
+  process.env.HOME || os.homedir(),
+  ".config",
+  "agx",
+  "git-index.json",
+);
+
+const PRUNE_NAMES = new Set<string>([
+  "node_modules",
+  ".next",
+  "dist",
+  "build",
+  ".cache",
+  "Library",
+  ".Trash",
+  ".git",
+  ".npm",
+  ".cargo",
+  ".rustup",
+  ".pyenv",
+  ".nvm",
+]);
+
+function shouldPrune(name: string): boolean {
+  if (PRUNE_NAMES.has(name)) return true;
+  if (name.startsWith(".") && name !== ".config") return true;
+  return false;
+}
+
+async function isRepo(dir: string): Promise<boolean> {
+  try {
+    const st = await fs.stat(path.join(dir, ".git"));
+    return st.isDirectory() || st.isFile();
+  } catch {
+    return false;
+  }
+}
+
+export async function loadRepoIndex(): Promise<RepoIndex | null> {
+  try {
+    const raw = await fs.readFile(REPO_INDEX_PATH, "utf8");
+    const parsed = JSON.parse(raw) as RepoIndex;
+    if (
+      !parsed ||
+      typeof parsed !== "object" ||
+      !Array.isArray(parsed.entries) ||
+      typeof parsed.scannedAt !== "number"
+    ) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+export async function saveRepoIndex(idx: RepoIndex): Promise<void> {
+  await fs.mkdir(path.dirname(REPO_INDEX_PATH), { recursive: true });
+  const tmp = `${REPO_INDEX_PATH}.tmp`;
+  await fs.writeFile(tmp, JSON.stringify(idx));
+  await fs.rename(tmp, REPO_INDEX_PATH);
+}
+
+export const RESCAN_TTL_MS = 24 * 60 * 60 * 1000;
+
+let scanning: Promise<RepoIndex> | null = null;
+
+export function isScanning(): boolean {
+  return scanning !== null;
+}
+
+export async function ensureFreshRepoIndex(opts?: {
+  ttlMs?: number;
+  scanner?: () => Promise<RepoIndex>;
+}): Promise<{ index: RepoIndex | null; scanning: boolean }> {
+  const ttlMs = opts?.ttlMs ?? RESCAN_TTL_MS;
+  const scanner = opts?.scanner ?? (() => scanForRepos());
+  const index = await loadRepoIndex();
+  const isStale = !index || Date.now() - index.scannedAt > ttlMs;
+
+  if (isStale && !scanning) {
+    const p = (async () => {
+      try {
+        const fresh = await scanner();
+        await saveRepoIndex(fresh);
+        return fresh;
+      } finally {
+        scanning = null;
+      }
+    })();
+    scanning = p;
+    p.catch((err) => {
+      console.error("Background repo index scan failed:", err);
+    });
+  }
+
+  return { index, scanning: scanning !== null };
+}
+
+export async function scanForRepos(opts?: {
+  root?: string;
+  maxDepth?: number;
+}): Promise<RepoIndex> {
+  const root = opts?.root ?? os.homedir();
+  const maxDepth = opts?.maxDepth ?? 5;
+  const entries: RepoIndexEntry[] = [];
+
+  async function walk(dir: string, depth: number): Promise<void> {
+    if (depth > maxDepth) return;
+    if (await isRepo(dir)) {
+      entries.push({ path: dir, discoveredAt: Date.now() });
+      return; // do not descend into a repo
+    }
+    if (depth === maxDepth) return;
+    let dirents;
+    try {
+      dirents = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const d of dirents) {
+      if (!d.isDirectory()) continue;
+      if (shouldPrune(d.name)) continue;
+      await walk(path.join(dir, d.name), depth + 1);
+    }
+  }
+
+  await walk(root, 0);
+  return { entries, scannedAt: Date.now() };
+}

package/cloud-runtime/standalone/apps/local/lib/git-workspaces.ts

@@ -0,0 +1,187 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import * as path from "node:path";
+
+const execFileP = promisify(execFile);
+
+export interface GitWorkspace {
+  repoPath: string;
+  kind: "worktree" | "branch";
+  path?: string;
+  branch: string;
+  isCheckedOut: boolean;
+  isCurrent: boolean;
+  defaultBranch: string | null;
+}
+
+const RESULT_LIMIT = 200;
+
+export async function getDefaultBranch(repoPath: string): Promise<string | null> {
+  try {
+    const { stdout } = await execFileP("git", [
+      "-C",
+      repoPath,
+      "symbolic-ref",
+      "refs/remotes/origin/HEAD",
+    ]);
+    const ref = stdout.trim();
+    // expected: refs/remotes/origin/<branch>
+    const m = ref.match(/^refs\/remotes\/origin\/(.+)$/);
+    if (m) return m[1];
+    // Fallback: strip "origin/" prefix if present
+    if (ref.startsWith("origin/")) return ref.slice("origin/".length);
+    return ref || null;
+  } catch {
+    return null;
+  }
+}
+
+interface WorktreeEntry {
+  path: string;
+  branch: string; // empty when detached
+}
+
+function parseWorktreeList(stdout: string): WorktreeEntry[] {
+  const entries: WorktreeEntry[] = [];
+  const blocks = stdout.split(/\n\s*\n/);
+  for (const block of blocks) {
+    const lines = block.split("\n").map((l) => l.trim()).filter(Boolean);
+    if (lines.length === 0) continue;
+    let wtPath = "";
+    let branch = "";
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) wtPath = line.slice("worktree ".length).trim();
+      else if (line.startsWith("branch ")) {
+        const ref = line.slice("branch ".length).trim();
+        branch = ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref;
+      }
+      // "detached" => no branch; leave empty
+    }
+    if (wtPath) entries.push({ path: wtPath, branch });
+  }
+  return entries;
+}
+
+interface BranchEntry {
+  name: string;
+  isCurrent: boolean;
+}
+
+function parseBranchList(stdout: string): BranchEntry[] {
+  const out: BranchEntry[] = [];
+  const lines = stdout.split("\n");
+  for (const raw of lines) {
+    if (!raw) continue;
+    const [name, head] = raw.split("\t");
+    if (!name) continue;
+    // Skip remote HEAD aliases like "origin/HEAD -> origin/main"
+    if (name.includes(" -> ")) continue;
+    out.push({ name, isCurrent: head === "*" });
+  }
+  return out;
+}
+
+async function collectFromRepo(
+  repoPath: string,
+  ticketIdLower: string,
+  defaultBranch: string | null,
+): Promise<GitWorkspace[]> {
+  let worktreeStdout: string;
+  let branchStdout: string;
+  try {
+    const wt = await execFileP("git", [
+      "-C",
+      repoPath,
+      "worktree",
+      "list",
+      "--porcelain",
+    ]);
+    worktreeStdout = wt.stdout;
+    const br = await execFileP("git", [
+      "-C",
+      repoPath,
+      "branch",
+      "--all",
+      "--format=%(refname:short)\t%(HEAD)",
+    ]);
+    branchStdout = br.stdout;
+  } catch {
+    return [];
+  }
+
+  const worktrees = parseWorktreeList(worktreeStdout);
+  const branches = parseBranchList(branchStdout);
+
+  // Set of branches that are currently checked out by some worktree.
+  const checkedOutBranches = new Set<string>();
+  for (const w of worktrees) {
+    if (w.branch) checkedOutBranches.add(w.branch);
+  }
+
+  const results: GitWorkspace[] = [];
+  const emittedWorktreeBranches = new Set<string>();
+
+  // Worktree rows first
+  for (const w of worktrees) {
+    const basename = path.basename(w.path);
+    const matchesBranch = w.branch.toLowerCase().includes(ticketIdLower);
+    const matchesPath = basename.toLowerCase().includes(ticketIdLower);
+    if (!matchesBranch && !matchesPath) continue;
+    results.push({
+      repoPath,
+      kind: "worktree",
+      path: w.path,
+      branch: w.branch,
+      isCheckedOut: true,
+      isCurrent: w.path === repoPath,
+      defaultBranch,
+    });
+    if (w.branch) emittedWorktreeBranches.add(w.branch);
+  }
+
+  // Branch rows (excluding ones already emitted as a worktree)
+  for (const b of branches) {
+    if (emittedWorktreeBranches.has(b.name)) continue;
+    if (!b.name.toLowerCase().includes(ticketIdLower)) continue;
+    results.push({
+      repoPath,
+      kind: "branch",
+      branch: b.name,
+      isCheckedOut: checkedOutBranches.has(b.name),
+      isCurrent: false,
+      defaultBranch,
+    });
+  }
+
+  return results;
+}
+
+export async function listMatchingWorkspaces(args: {
+  repoPaths: string[];
+  ticketId: string;
+}): Promise<GitWorkspace[]> {
+  const ticketIdLower = args.ticketId.toLowerCase();
+  if (!ticketIdLower) return [];
+
+  const out: GitWorkspace[] = [];
+  for (const repoPath of args.repoPaths) {
+    if (out.length >= RESULT_LIMIT) break;
+    let defaultBranch: string | null = null;
+    try {
+      defaultBranch = await getDefaultBranch(repoPath);
+    } catch {
+      defaultBranch = null;
+    }
+    let entries: GitWorkspace[];
+    try {
+      entries = await collectFromRepo(repoPath, ticketIdLower, defaultBranch);
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (out.length >= RESULT_LIMIT) break;
+      out.push(e);
+    }
+  }
+  return out;
+}

package/cloud-runtime/standalone/apps/local/lib/provider-clis.ts

@@ -1,4 +1,4 @@
-export type ProviderId = "claude" | "gemini" | "ollama" | "codex" | "zai";
+export type ProviderId = "claude" | "gemini" | "ollama" | "codex" | "zai" | "kimi";
 
 export interface ProviderCliDefinition {
   id: ProviderId;
@@ -65,6 +65,17 @@ export const PROVIDER_CLIS: ProviderCliDefinition[] = [
     statusLabel: "Installed",
     authCheck: { cmd: "ollama list 2>/dev/null", timeout: 5_000 },
   },
+  {
+    id: "kimi",
+    label: "Kimi Code",
+    bin: "kimi",
+    description: "Moonshot's Kimi Code CLI.",
+    installCmd: "npm install -g @moonshot/kimi-code",
+    docsUrl: "https://www.kimi.com/code/docs/en/kimi-code-cli/core-operations.html",
+    statusLabel: "Installed",
+    authCheck: { cmd: "kimi --version 2>/dev/null", timeout: 5_000 },
+    authCmd: { cmd: "kimi", description: "Opens Kimi login flow" },
+  },
   {
     id: "zai",
     label: "Z.AI",

package/cloud-runtime/standalone/apps/local/lib/repo-suggestions.ts

@@ -0,0 +1,104 @@
+import * as path from "path";
+
+export type SuggestionMatch = "basename" | "segment" | "none";
+
+export interface SuggestedRepo {
+  path: string;
+  basename: string;
+  matchedOn: SuggestionMatch;
+  hasGit: true;
+}
+
+function normalize(value: string | null | undefined): string {
+  return (value ?? "").trim().toLowerCase();
+}
+
+/**
+ * Score a single repo path against the project slug/name.
+ *
+ * Returns:
+ *   { matchedOn: "basename", score: 3 } when basename equals slug or name (case-insensitive)
+ *   { matchedOn: "segment",  score: 2 } when basename includes either as substring
+ *   { matchedOn: "segment",  score: 1 } when any other path segment includes either
+ *   null                                  when no match (and at least one term provided)
+ *
+ * If neither slug nor name is provided, returns { matchedOn: "none", score: 0 } so
+ * the caller can include all repos.
+ */
+export function scoreRepoMatch(
+  repoPath: string,
+  projectSlug?: string | null,
+  projectName?: string | null,
+): { matchedOn: SuggestionMatch; score: number } | null {
+  const slug = normalize(projectSlug);
+  const name = normalize(projectName);
+  const terms = [slug, name].filter((t) => t.length > 0);
+
+  if (terms.length === 0) {
+    return { matchedOn: "none", score: 0 };
+  }
+
+  const segments = repoPath.split(path.sep).filter((s) => s.length > 0);
+  const basename = segments.length > 0 ? segments[segments.length - 1] : "";
+  const basenameLower = basename.toLowerCase();
+
+  // Exact basename match wins
+  if (terms.some((t) => basenameLower === t)) {
+    return { matchedOn: "basename", score: 3 };
+  }
+
+  // Substring match on basename
+  if (terms.some((t) => basenameLower.includes(t))) {
+    return { matchedOn: "segment", score: 2 };
+  }
+
+  // Substring match on any other segment
+  const otherSegments = segments.slice(0, -1).map((s) => s.toLowerCase());
+  if (otherSegments.some((seg) => terms.some((t) => seg.includes(t)))) {
+    return { matchedOn: "segment", score: 1 };
+  }
+
+  return null;
+}
+
+/**
+ * Filter, score, and sort indexed repo paths against a project slug / name.
+ * Tie-breaks higher scores first; on ties, shorter paths first; then lexicographic.
+ */
+export function suggestRepos(
+  repoPaths: readonly string[],
+  opts: { projectSlug?: string | null; projectName?: string | null; limit?: number } = {},
+): SuggestedRepo[] {
+  const { projectSlug, projectName, limit } = opts;
+
+  const scored: Array<{ repo: SuggestedRepo; score: number }> = [];
+  for (const repoPath of repoPaths) {
+    const result = scoreRepoMatch(repoPath, projectSlug, projectName);
+    if (!result) continue;
+    const segments = repoPath.split(path.sep).filter((s) => s.length > 0);
+    const basename = segments.length > 0 ? segments[segments.length - 1] : repoPath;
+    scored.push({
+      repo: {
+        path: repoPath,
+        basename,
+        matchedOn: result.matchedOn,
+        hasGit: true,
+      },
+      score: result.score,
+    });
+  }
+
+  scored.sort((a, b) => {
+    if (a.score !== b.score) return b.score - a.score;
+    if (a.repo.path.length !== b.repo.path.length) {
+      return a.repo.path.length - b.repo.path.length;
+    }
+    return a.repo.path.localeCompare(b.repo.path);
+  });
+
+  const out = scored.map((s) => s.repo);
+  if (typeof limit === "number" && limit >= 0) {
+    return out.slice(0, limit);
+  }
+  return out;
+}

package/cloud-runtime/standalone/apps/local/lib/stream-multiplexer.ts

@@ -44,6 +44,7 @@ function buildFilesystemAccessContext(p: Participant): string | null {
     case "codex":
     case "gemini":
     case "zai":
+    case "kimi":
       return `<filesystem-access>
 Current CLI access includes the project working directory and ${homeDir}.
 Treat ~/.agx as accessible from this chat because it lives under ${homeDir}.

package/cloud-runtime/standalone/apps/local/lib/types.ts

@@ -1,6 +1,6 @@
 import type { ThreadStatus } from "./storage/thread-adapter";
 
-export type ChatProvider = "claude" | "gemini" | "ollama" | "codex" | "zai";
+export type ChatProvider = "claude" | "gemini" | "ollama" | "codex" | "zai" | "kimi";
 
 export interface Conversation {
   id: string;