@mndrk/agx 2.4.10 → 2.4.11

package/cloud-runtime/standalone/apps/local/components/tracker/WorkspacePicker.tsx

@@ -0,0 +1,338 @@
+"use client";
+
+import React, { useEffect, useMemo, useRef, useState } from "react";
+import { ChevronDown, RefreshCw } from "lucide-react";
+import type { GitWorkspace } from "@/lib/git-workspaces";
+// type-only import; runtime module is server-only.
+
+interface Props {
+  workspaces: GitWorkspace[];
+  selected: { repoPath: string; ref: string } | null;
+  onSelect: (sel: { repoPath: string; ref: string }) => void;
+  onRescan: () => void;
+  rescanning: boolean;
+}
+
+function basename(p: string): string {
+  if (!p) return p;
+  const cleaned = p.replace(/\/+$/, "");
+  const idx = cleaned.lastIndexOf("/");
+  return idx >= 0 ? cleaned.slice(idx + 1) : cleaned;
+}
+
+export function WorkspacePicker({
+  workspaces,
+  selected,
+  onSelect,
+  onRescan,
+  rescanning,
+}: Props) {
+  const [open, setOpen] = useState(false);
+  const wrapperRef = useRef<HTMLDivElement | null>(null);
+
+  useEffect(() => {
+    if (!open) return;
+    const handlePointerDown = (event: PointerEvent) => {
+      if (wrapperRef.current && !wrapperRef.current.contains(event.target as Node)) {
+        setOpen(false);
+      }
+    };
+    document.addEventListener("pointerdown", handlePointerDown);
+    return () => document.removeEventListener("pointerdown", handlePointerDown);
+  }, [open]);
+
+  const grouped = useMemo(() => {
+    const map = new Map<string, GitWorkspace[]>();
+    for (const ws of workspaces) {
+      const list = map.get(ws.repoPath) ?? [];
+      list.push(ws);
+      map.set(ws.repoPath, list);
+    }
+    return Array.from(map.entries());
+  }, [workspaces]);
+
+  const selectedLabel = useMemo(() => {
+    if (!selected) return "Select workspace";
+    if (selected.ref === "WORKING_TREE") {
+      return `${basename(selected.repoPath)} · working tree`;
+    }
+    const match = workspaces.find(
+      (w) => w.repoPath === selected.repoPath && w.branch === selected.ref,
+    );
+    if (match) {
+      return `${basename(match.repoPath)} · ${match.branch}`;
+    }
+    return `${basename(selected.repoPath)} · ${selected.ref}`;
+  }, [selected, workspaces]);
+
+  const choose = (sel: { repoPath: string; ref: string }) => {
+    onSelect(sel);
+    setOpen(false);
+  };
+
+  return (
+    <div className="relative" ref={wrapperRef}>
+      <button
+        type="button"
+        aria-haspopup="listbox"
+        aria-expanded={open}
+        onClick={() => setOpen((v) => !v)}
+        style={{
+          display: "inline-flex",
+          alignItems: "center",
+          gap: 6,
+          height: 26,
+          padding: "0 10px",
+          borderRadius: 4,
+          border: "1px solid var(--card-border)",
+          background: "var(--card-bg)",
+          color: "var(--foreground)",
+          fontFamily: "var(--font-jetbrains-mono), ui-monospace, Menlo, monospace",
+          fontSize: 11,
+          fontWeight: 600,
+          cursor: "pointer",
+          maxWidth: 320,
+        }}
+      >
+        <span
+          style={{
+            overflow: "hidden",
+            textOverflow: "ellipsis",
+            whiteSpace: "nowrap",
+            maxWidth: 280,
+          }}
+        >
+          {selectedLabel}
+        </span>
+        <ChevronDown size={12} className={open ? "rotate-180" : ""} />
+      </button>
+      {open ? (
+        <div
+          role="listbox"
+          aria-label="Select workspace"
+          style={{
+            position: "absolute",
+            top: "100%",
+            left: 0,
+            zIndex: 50,
+            marginTop: 4,
+            minWidth: 320,
+            maxHeight: 420,
+            overflowY: "auto",
+            background: "var(--card-bg)",
+            border: "1px solid var(--card-border)",
+            borderRadius: 8,
+            boxShadow: "0 8px 24px rgba(0,0,0,0.18)",
+            padding: 4,
+          }}
+        >
+          {grouped.length === 0 ? (
+            <div
+              style={{
+                padding: "10px 12px",
+                fontSize: 12,
+                color: "var(--muted-foreground)",
+              }}
+            >
+              No matching workspaces.
+            </div>
+          ) : null}
+          {grouped.map(([repoPath, items]) => {
+            const repoName = basename(repoPath);
+            const isWorkingTreeSelected =
+              selected?.repoPath === repoPath && selected.ref === "WORKING_TREE";
+            return (
+              <div key={repoPath} style={{ marginBottom: 6 }}>
+                <div
+                  style={{
+                    padding: "6px 10px 4px",
+                    fontSize: 10,
+                    letterSpacing: "0.12em",
+                    textTransform: "uppercase",
+                    color: "var(--muted-foreground)",
+                    fontFamily:
+                      "var(--font-jetbrains-mono), ui-monospace, Menlo, monospace",
+                  }}
+                  title={repoPath}
+                >
+                  {repoName}
+                </div>
+                <button
+                  type="button"
+                  role="option"
+                  aria-selected={isWorkingTreeSelected}
+                  onClick={() => choose({ repoPath, ref: "WORKING_TREE" })}
+                  style={{
+                    display: "flex",
+                    alignItems: "center",
+                    gap: 8,
+                    width: "100%",
+                    padding: "6px 10px",
+                    border: "none",
+                    background: isWorkingTreeSelected
+                      ? "var(--background)"
+                      : "transparent",
+                    color: "var(--foreground)",
+                    cursor: "pointer",
+                    borderRadius: 6,
+                    textAlign: "left",
+                    fontSize: 12,
+                  }}
+                >
+                  <span
+                    style={{
+                      fontFamily:
+                        "var(--font-jetbrains-mono), ui-monospace, Menlo, monospace",
+                      fontSize: 11,
+                      fontWeight: 600,
+                    }}
+                  >
+                    Working tree
+                  </span>
+                  <Chip>working tree</Chip>
+                </button>
+                {items.map((ws) => {
+                  const isSel =
+                    selected?.repoPath === ws.repoPath &&
+                    selected.ref === ws.branch;
+                  return (
+                    <button
+                      key={`${ws.repoPath}::${ws.kind}::${ws.branch}::${ws.path ?? ""}`}
+                      type="button"
+                      role="option"
+                      aria-selected={isSel}
+                      onClick={() =>
+                        choose({ repoPath: ws.repoPath, ref: ws.branch })
+                      }
+                      style={{
+                        display: "flex",
+                        flexDirection: "column",
+                        alignItems: "flex-start",
+                        gap: 2,
+                        width: "100%",
+                        padding: "6px 10px",
+                        border: "none",
+                        background: isSel ? "var(--background)" : "transparent",
+                        color: "var(--foreground)",
+                        cursor: "pointer",
+                        borderRadius: 6,
+                        textAlign: "left",
+                      }}
+                    >
+                      <div
+                        style={{
+                          display: "flex",
+                          alignItems: "center",
+                          gap: 6,
+                          minWidth: 0,
+                          width: "100%",
+                        }}
+                      >
+                        <span
+                          style={{
+                            fontFamily:
+                              "var(--font-jetbrains-mono), ui-monospace, Menlo, monospace",
+                            fontSize: 11,
+                            fontWeight: 600,
+                            overflow: "hidden",
+                            textOverflow: "ellipsis",
+                            whiteSpace: "nowrap",
+                            maxWidth: 220,
+                          }}
+                        >
+                          {ws.branch || "(detached)"}
+                        </span>
+                        <Chip>{ws.kind}</Chip>
+                        {ws.isCurrent ? <Chip accent>current</Chip> : null}
+                      </div>
+                      {ws.path ? (
+                        <div
+                          style={{
+                            fontSize: 10,
+                            color: "var(--muted-foreground)",
+                            fontFamily:
+                              "var(--font-jetbrains-mono), ui-monospace, Menlo, monospace",
+                            overflow: "hidden",
+                            textOverflow: "ellipsis",
+                            whiteSpace: "nowrap",
+                            maxWidth: 280,
+                          }}
+                          title={ws.path}
+                        >
+                          {basename(ws.path)}
+                        </div>
+                      ) : null}
+                    </button>
+                  );
+                })}
+              </div>
+            );
+          })}
+          <div
+            style={{
+              borderTop: "1px solid var(--card-border)",
+              padding: "6px 10px",
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "flex-end",
+            }}
+          >
+            <button
+              type="button"
+              onClick={() => onRescan()}
+              disabled={rescanning}
+              style={{
+                display: "inline-flex",
+                alignItems: "center",
+                gap: 6,
+                background: "transparent",
+                border: "none",
+                color: "var(--muted-foreground)",
+                fontSize: 11,
+                cursor: rescanning ? "default" : "pointer",
+              }}
+            >
+              <RefreshCw
+                size={11}
+                className={rescanning ? "animate-spin" : undefined}
+              />
+              Rescan ~
+            </button>
+          </div>
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
+function Chip({
+  children,
+  accent,
+}: {
+  children: React.ReactNode;
+  accent?: boolean;
+}) {
+  return (
+    <span
+      style={{
+        display: "inline-flex",
+        alignItems: "center",
+        padding: "0 6px",
+        height: 16,
+        borderRadius: 999,
+        border: "1px solid var(--card-border)",
+        background: accent ? "var(--primary)" : "transparent",
+        color: accent ? "var(--primary-foreground)" : "var(--muted-foreground)",
+        fontSize: 9,
+        letterSpacing: "0.06em",
+        textTransform: "uppercase",
+        fontFamily:
+          "var(--font-jetbrains-mono), ui-monospace, Menlo, monospace",
+        whiteSpace: "nowrap",
+      }}
+    >
+      {children}
+    </span>
+  );
+}
+

package/cloud-runtime/standalone/apps/local/hooks/useProviders.ts

@@ -8,6 +8,7 @@ const FALLBACK: Provider[] = [
   { id: "ollama", label: "Ollama" },
   { id: "codex", label: "Codex" },
   { id: "zai", label: "Z.AI" },
+  { id: "kimi", label: "Kimi Code" },
 ];
 
 export function useProviders() {

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

@@ -337,6 +337,7 @@ const AGX_WRAPPED_PROVIDERS: ReadonlySet<ChatProvider> = new Set([
   "gemini",
   "ollama",
   "codex",
+  "kimi",
 ]);
 
 function providerNativeCommand({
@@ -410,6 +411,19 @@ function providerNativeCommand({
         parser: "codex-json",
       };
     }
+    case "kimi": {
+      // Kimi Code CLI mirrors Claude Code's flag surface (--print, -p, --output-format=stream-json).
+      const kimiArgs = [
+        "--print",
+        "-p",
+        prompt,
+        "--output-format",
+        "stream-json",
+      ];
+      if (model) kimiArgs.push("--model", model);
+      if (systemPrompt) kimiArgs.push("--system-prompt", systemPrompt);
+      return { command: "kimi", args: kimiArgs, parser: "claude-stream-json" };
+    }
     case "zai": {
       // Z.AI exposes an Anthropic-compatible endpoint at https://api.z.ai/api/anthropic.
       // Runs `claude` with ANTHROPIC_BASE_URL override (same pattern as Ollama through agx).
@@ -448,6 +462,7 @@ function providerAccessPassthrough(provider: ChatProvider): string[] {
     case "claude":
     case "zai":
     case "codex":
+    case "kimi":
       return ["--add-dir", homeDir];
     case "gemini":
       return ["--include-directories", homeDir];
@@ -466,6 +481,11 @@ function agxStreamingPassthrough(provider: ChatProvider): {
         args: ["--verbose", "--output-format", "stream-json", "--include-partial-messages"],
         parser: "claude-stream-json",
       };
+    case "kimi":
+      return {
+        args: ["--print", "--output-format", "stream-json"],
+        parser: "claude-stream-json",
+      };
     case "gemini":
       return { args: ["-o", "stream-json"], parser: "gemini-stream-json" };
     case "codex":

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

@@ -0,0 +1,56 @@
+// apps/local/lib/diff-parser.ts
+export type DiffLineKind = "ctx" | "add" | "del";
+
+export interface DiffLine {
+  o: number | null;
+  n: number | null;
+  k: DiffLineKind;
+  t: string;
+}
+
+export interface DiffHunk {
+  head: string;
+  section: string;
+  lines: DiffLine[];
+}
+
+const HUNK_RE = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@(.*)$/;
+
+export function parseUnifiedDiff(patch: string | null | undefined): DiffHunk[] {
+  if (!patch) return [];
+  const lines = patch.split("\n");
+  const hunks: DiffHunk[] = [];
+  let current: DiffHunk | null = null;
+  let oldLine = 0;
+  let newLine = 0;
+
+  for (const raw of lines) {
+    const m = HUNK_RE.exec(raw);
+    if (m) {
+      if (current) hunks.push(current);
+      oldLine = Number(m[1]);
+      newLine = Number(m[2]);
+      current = { head: raw, section: m[3].trim(), lines: [] };
+      continue;
+    }
+    if (!current) continue;
+    if (raw.startsWith("\\ ")) continue; // ""
+
+    const ch = raw[0];
+    const text = raw.slice(1);
+    if (ch === "+") {
+      current.lines.push({ o: null, n: newLine, k: "add", t: text });
+      newLine++;
+    } else if (ch === "-") {
+      current.lines.push({ o: oldLine, n: null, k: "del", t: text });
+      oldLine++;
+    } else {
+      // context (space prefix) or empty line that we treat as context
+      current.lines.push({ o: oldLine, n: newLine, k: "ctx", t: text });
+      oldLine++;
+      newLine++;
+    }
+  }
+  if (current) hunks.push(current);
+  return hunks;
+}

package/cloud-runtime/standalone/apps/local/lib/gh-pr-cli.ts

@@ -0,0 +1,198 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import type {
+  GithubPr,
+  GithubPrFile,
+  GithubPrComment,
+} from "./github-types";
+import { splitUnifiedDiffByFile } from "./git-diff-cli";
+
+export { splitUnifiedDiffByFile };
+
+const execFileP = promisify(execFile);
+
+const VIEW_FIELDS = [
+  "number",
+  "title",
+  "body",
+  "state",
+  "isDraft",
+  "author",
+  "headRefName",
+  "headRefOid",
+  "baseRefName",
+  "url",
+  "additions",
+  "deletions",
+  "changedFiles",
+  "labels",
+  "assignees",
+  "reviewRequests",
+  "createdAt",
+  "updatedAt",
+  "mergedAt",
+  "closedAt",
+  "statusCheckRollup",
+  "reviewDecision",
+  "files",
+].join(",");
+
+interface GhView {
+  number: number;
+  title: string;
+  body: string;
+  state: string;
+  isDraft: boolean;
+  author: { login: string } | null;
+  headRefName: string;
+  headRefOid: string;
+  baseRefName: string;
+  url: string;
+  additions: number;
+  deletions: number;
+  changedFiles: number;
+  labels: { name: string }[];
+  assignees: { login: string }[];
+  reviewRequests: { login?: string; name?: string }[];
+  createdAt: string;
+  updatedAt: string;
+  mergedAt: string | null;
+  closedAt: string | null;
+  statusCheckRollup: { conclusion?: string; status?: string }[];
+  reviewDecision: string;
+  files: { path: string; additions: number; deletions: number; changeType: string }[];
+}
+
+function parseRepoId(repoId: string): { owner: string; name: string; number: number } | null {
+  const m = repoId.match(/^([^/]+)\/([^#]+)#(\d+)$/);
+  if (!m) return null;
+  return { owner: m[1], name: m[2], number: Number(m[3]) };
+}
+
+function epoch(iso: string | null): number | null {
+  if (!iso) return null;
+  const t = Date.parse(iso);
+  return Number.isFinite(t) ? t : null;
+}
+
+function ciStatusFromRollup(rollup: GhView["statusCheckRollup"]): GithubPr["ciStatus"] {
+  if (!rollup || rollup.length === 0) return null;
+  const concs = rollup.map((c) => (c.conclusion || c.status || "").toLowerCase());
+  if (concs.some((c) => c === "failure" || c === "error" || c === "cancelled" || c === "timed_out")) return "failure";
+  if (concs.some((c) => c === "" || c === "in_progress" || c === "queued" || c === "pending")) return "pending";
+  if (concs.every((c) => c === "success" || c === "neutral" || c === "skipped")) return "success";
+  return "pending";
+}
+
+function reviewDecisionFromGh(d: string): GithubPr["reviewDecision"] {
+  switch (d) {
+    case "APPROVED":
+      return "approved";
+    case "CHANGES_REQUESTED":
+      return "changes_requested";
+    case "REVIEW_REQUIRED":
+      return "review_required";
+    default:
+      return null;
+  }
+}
+
+function stateFromGh(s: string, mergedAt: string | null): GithubPr["state"] {
+  if (mergedAt) return "merged";
+  switch (s.toUpperCase()) {
+    case "OPEN":
+      return "open";
+    case "CLOSED":
+      return "closed";
+    case "MERGED":
+      return "merged";
+    default:
+      return "open";
+  }
+}
+
+interface FetchResult {
+  pr: GithubPr;
+  files: GithubPrFile[];
+  comments: GithubPrComment[];
+}
+
+/**
+ * Fetches a PR via `gh` CLI. Returns null when the PR cannot be resolved.
+ * Throws when `gh` is missing or returns a non-zero exit for an unknown reason.
+ */
+export async function fetchPrViaGh(prId: string): Promise<FetchResult | null> {
+  const parsed = parseRepoId(prId);
+  if (!parsed) return null;
+  const repoSlug = `${parsed.owner}/${parsed.name}`;
+  const numberStr = String(parsed.number);
+
+  let viewRaw: string;
+  try {
+    const { stdout } = await execFileP("gh", [
+      "pr",
+      "view",
+      numberStr,
+      "--repo",
+      repoSlug,
+      "--json",
+      VIEW_FIELDS,
+    ]);
+    viewRaw = stdout;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/could not resolve|not found/i.test(msg)) return null;
+    throw err;
+  }
+
+  const view = JSON.parse(viewRaw) as GhView;
+
+  const { stdout: diffRaw } = await execFileP(
+    "gh",
+    ["pr", "diff", numberStr, "--repo", repoSlug],
+    { maxBuffer: 64 * 1024 * 1024 },
+  );
+  const patches = splitUnifiedDiffByFile(diffRaw);
+
+  const now = Date.now();
+  const pr: GithubPr = {
+    id: prId,
+    repoId: repoSlug,
+    number: view.number,
+    title: view.title,
+    body: view.body,
+    state: stateFromGh(view.state, view.mergedAt),
+    draft: !!view.isDraft,
+    authorLogin: view.author?.login ?? "",
+    headRef: view.headRefName,
+    headSha: view.headRefOid,
+    baseRef: view.baseRefName,
+    url: view.url,
+    ciStatus: ciStatusFromRollup(view.statusCheckRollup ?? []),
+    reviewDecision: reviewDecisionFromGh(view.reviewDecision),
+    assignees: (view.assignees ?? []).map((a) => a.login),
+    reviewers: (view.reviewRequests ?? []).map((r) => ({
+      login: r.login ?? r.name ?? "",
+      state: "pending",
+    })),
+    labels: (view.labels ?? []).map((l) => l.name),
+    createdAt: epoch(view.createdAt) ?? now,
+    updatedAt: epoch(view.updatedAt) ?? now,
+    mergedAt: epoch(view.mergedAt),
+    closedAt: epoch(view.closedAt),
+    lastSyncedAt: now,
+  };
+
+  const files: GithubPrFile[] = (view.files ?? []).map((f) => ({
+    prId,
+    path: f.path,
+    status: f.changeType.toLowerCase(),
+    additions: f.additions,
+    deletions: f.deletions,
+    changes: f.additions + f.deletions,
+    patch: patches.get(f.path) ?? null,
+    lastSyncedAt: now,
+  }));
+
+  return { pr, files, comments: [] };
+}