@phnx-labs/agents-cli 1.22.112 → 1.22.114

package/dist/lib/fuzzy.d.ts

@@ -11,7 +11,7 @@ export declare function levenshtein(a: string, b: string): number;
  * "one misspelling."
  */
 export declare function damerauLevenshtein(a: string, b: string): number;
-export interface FuzzyOptions {
+interface FuzzyOptions {
     /** Absolute max edit distance allowed. */
     maxDistance?: number;
     /** Max ratio of distance to input length. If set, effective threshold = min(maxDistance, floor(len * maxRatio)). */
@@ -61,3 +61,4 @@ export declare const FUZZY_PRESETS: {
         readonly maxRatio: 0.3;
     };
 };
+export {};

package/dist/lib/gemini-settings.d.ts

@@ -1,3 +1,2 @@
 export declare function readGeminiSettings(settingsPath: string): Record<string, unknown>;
-export declare function writeGeminiSettings(settingsPath: string, settings: Record<string, unknown>): void;
 export declare function updateGeminiSettings(settingsPath: string, mutate: (settings: Record<string, unknown>) => void): Record<string, unknown>;

package/dist/lib/gemini-settings.js

@@ -26,7 +26,7 @@ export function readGeminiSettings(settingsPath) {
     }
     return parsed;
 }
-export function writeGeminiSettings(settingsPath, settings) {
+function writeGeminiSettings(settingsPath, settings) {
     fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
 }

package/dist/lib/git.d.ts

@@ -48,7 +48,7 @@ export declare function assertValidBranchName(branch: string): void;
  */
 export declare function pushOrigin(git: SimpleGit, branch: string, targetBranch?: string): Promise<void>;
 /** Parsed representation of a git source string (GitHub, generic URL, or local path). */
-export interface GitSource {
+interface GitSource {
     type: 'github' | 'url' | 'local';
     url: string;
     ref?: string;
@@ -71,30 +71,19 @@ export interface GitSource {
  *   ./relative/path                  -> local path
  */
 export declare function parseSource(source: string): GitSource;
-/** Clone a remote repo or pull updates if it already exists locally. */
-export declare function cloneOrPull(source: GitSource, targetDir: string): Promise<{
-    isNew: boolean;
-    commit: string;
-}>;
 /** Clone a repository from a source string, returning the local path and commit hash. */
 export declare function cloneRepo(source: string): Promise<{
     localPath: string;
     commit: string;
     isNew: boolean;
 }>;
-/** Clone a package from a source string into the packages directory. */
-export declare function clonePackage(source: string): Promise<{
-    localPath: string;
-    commit: string;
-    isNew: boolean;
-}>;
 /** Get the short commit hash (8 chars) of the latest commit in a repo. */
 export declare function getRepoCommit(repoPath: string): Promise<string>;
 /** Compact, self-contained state of a git repo — branch, short HEAD, and a
  *  dirty flag — for cross-device comparison (RUSH-2027). Synchronous and
  *  best-effort: a non-repo or unreadable path yields `null` fields, never a
  *  throw, so a device's `doctor --json` payload always serializes. */
-export interface RepoStateSnapshot {
+interface RepoStateSnapshot {
     branch: string | null;
     head: string | null;
     dirty: boolean;
@@ -117,11 +106,6 @@ export declare function readRepoState(repoPath: string): RepoStateSnapshot | nul
 export declare function resolveSnapshotSha(repoRoot: string): string | undefined;
 /** Test seam: clear the memoized snapshot-sha cache between test cases. */
 export declare function _resetSnapshotShaCacheForTest(): void;
-/**
- * Get the current GitHub username using gh CLI.
- * Returns null if gh is not installed or user is not authenticated.
- */
-export declare function getGitHubUsername(): Promise<string | null>;
 /**
  * Resolve the GitHub username synchronously for `agents artifacts share`. Order:
  *   1. `AGENTS_SHARE_GITHUB_USER` env override
@@ -142,8 +126,6 @@ export declare function resolveGitHubUsername(): Promise<string | null>;
  * Get the remote URL for origin in a git repo.
  */
 export declare function getRemoteUrl(repoPath: string): Promise<string | null>;
-/** The repo's checked-out branch, or 'main' on a detached HEAD / read failure. */
-export declare function getCurrentBranch(repoPath: string): Promise<string>;
 /**
  * Canonical `host/owner/repo` form of a git remote, transport-agnostic, so the
  * same repo cloned over SSH vs HTTPS compares equal. Strips protocol, any
@@ -178,16 +160,8 @@ export declare function isSystemRepoRemote(remote: string | null | undefined): b
 export declare function isExpectedSystemRepoRemote(remote: string | null | undefined): boolean;
 /** True when two git remote URLs point at the same repo across transport forms. */
 export declare function sameGitRemote(a: string | null | undefined, b: string | null | undefined): boolean;
-/**
- * Set the remote URL for origin in a git repo.
- */
-export declare function setRemoteUrl(repoPath: string, url: string): Promise<void>;
-/**
- * Check if a GitHub repo exists.
- */
-export declare function checkGitHubRepoExists(owner: string, repo: string): Promise<boolean>;
 /** Result of {@link commitAndPush}. */
-export type CommitAndPushResult = {
+type CommitAndPushResult = {
     success: boolean;
     error?: string;
     /** Human detail for success: "already up to date", "pushed abc..def", "committed and pushed …". */
@@ -318,7 +292,7 @@ export declare function resolveUserRepoRemoteUrl(dir: string): string | null;
  * real local edit and left alone — it surfaces as a modified path instead.
  */
 export declare function isStaleAgentsYamlStub(local: string, committed: string): boolean;
-export interface AdoptInPlaceResult {
+interface AdoptInPlaceResult {
     success: boolean;
     commit: string;
     /** Tracked files that were absent locally and materialized from origin/main. */
@@ -384,10 +358,6 @@ export declare function adoptUserRepoIfNeeded(dir: string, opts?: {
  * {@link isSystemRepoRemote}.
  */
 export declare function isSystemRepoOrigin(dir: string): Promise<boolean>;
-/**
- * Check if repo has uncommitted changes (including untracked files).
- */
-export declare function hasLocalChanges(dir: string): Promise<boolean>;
 /**
  * Render an absolute path in ~-relative form with forward slashes, matching the
  * way the rest of the CLI prints home-anchored paths (e.g. `~/.agents/.system`).
@@ -468,7 +438,7 @@ export declare function syncRepoGit(dir: string, opts: {
  * Get git status for sync display.
  * Returns files categorized by their status relative to HEAD.
  */
-export interface GitSyncStatus {
+interface GitSyncStatus {
     /** Tracked and unchanged files. */
     synced: string[];
     /** Modified but not staged files. */
@@ -486,38 +456,9 @@ export declare function getGitSyncStatus(dir: string, subdir?: string): Promise<
  * Get list of files tracked by git in a directory.
  */
 export declare function getTrackedFiles(dir: string, subdir?: string): Promise<string[]>;
-/**
- * Check if upstream remote is configured.
- */
-export declare function hasUpstreamRemote(dir: string): Promise<boolean>;
-/**
- * Get the upstream remote fetch URL, or null if none configured.
- */
-export declare function getUpstreamUrl(dir: string): Promise<string | null>;
-/**
- * Add or update the upstream remote.
- */
-export declare function setUpstreamRemote(dir: string, url: string): Promise<void>;
-/**
- * Pull from upstream remote (merge updates from system repo).
- */
-export declare function pullFromUpstream(dir: string): Promise<{
-    success: boolean;
-    commit: string;
-    error?: string;
-}>;
-/**
- * Try to auto-pull a git repo if it's clean and has a remote.
- * Uses --ff-only for safety (fails if diverged instead of creating merge commits).
- * Returns silently on success, returns error message on failure.
- */
-export declare function tryAutoPull(dir: string): Promise<{
-    pulled: boolean;
-    error?: string;
-}>;
 /** Result of {@link tryAutoPullSystemRepo}. `refused` is set only when the pull
  *  was blocked because origin is not the expected system remote. */
-export interface SystemRepoPullResult {
+interface SystemRepoPullResult {
     pulled: boolean;
     error?: string;
     /** True when origin is present but is NOT the expected system remote; no
@@ -552,3 +493,4 @@ export declare function commitsBehindUpstream(dir: string): {
     behind: number;
     branch: string;
 } | null;
+export {};

package/dist/lib/git.js

@@ -269,7 +269,7 @@ export function parseSource(source) {
     throw new Error(`Invalid source: ${source}. Supported formats: gh:owner/repo, owner/repo, github.com/owner/repo, https://github.com/owner/repo, or local path`);
 }
 /** Clone a remote repo or pull updates if it already exists locally. */
-export async function cloneOrPull(source, targetDir) {
+async function cloneOrPull(source, targetDir) {
     const git = simpleGit();
     if (source.type === 'local') {
         return { isNew: false, commit: 'local' };
@@ -313,24 +313,6 @@ export async function cloneRepo(source) {
         isNew: result.isNew,
     };
 }
-/** Clone a package from a source string into the packages directory. */
-export async function clonePackage(source) {
-    const parsed = parseSource(source);
-    if (parsed.type === 'local') {
-        return {
-            localPath: parsed.url,
-            commit: 'local',
-            isNew: false,
-        };
-    }
-    const localPath = getPackageLocalPath(source);
-    const result = await cloneOrPull(parsed, localPath);
-    return {
-        localPath,
-        commit: result.commit,
-        isNew: result.isNew,
-    };
-}
 /** Get the short commit hash (8 chars) of the latest commit in a repo. */
 export async function getRepoCommit(repoPath) {
     try {
@@ -411,7 +393,7 @@ export function _resetSnapshotShaCacheForTest() {
  * Get the current GitHub username using gh CLI.
  * Returns null if gh is not installed or user is not authenticated.
  */
-export async function getGitHubUsername() {
+async function getGitHubUsername() {
     try {
         const { exec } = await import('child_process');
         const { promisify } = await import('util');
@@ -480,16 +462,6 @@ export async function getRemoteUrl(repoPath) {
         return null;
     }
 }
-/** The repo's checked-out branch, or 'main' on a detached HEAD / read failure. */
-export async function getCurrentBranch(repoPath) {
-    try {
-        const status = await simpleGit(repoPath).status();
-        return status.current || 'main';
-    }
-    catch {
-        return 'main';
-    }
-}
 /**
  * Canonical `host/owner/repo` form of a git remote, transport-agnostic, so the
  * same repo cloned over SSH vs HTTPS compares equal. Strips protocol, any
@@ -570,36 +542,6 @@ export function sameGitRemote(a, b) {
         return false;
     return canonicalGitRemote(a) === canonicalGitRemote(b);
 }
-/**
- * Set the remote URL for origin in a git repo.
- */
-export async function setRemoteUrl(repoPath, url) {
-    const git = simpleGit(repoPath);
-    const remotes = await git.getRemotes(true);
-    const hasOrigin = remotes.some(r => r.name === 'origin');
-    if (hasOrigin) {
-        await git.remote(['set-url', 'origin', url]);
-    }
-    else {
-        await git.remote(['add', 'origin', url]);
-    }
-}
-/**
- * Check if a GitHub repo exists.
- */
-export async function checkGitHubRepoExists(owner, repo) {
-    try {
-        const { execFile } = await import('child_process');
-        const { promisify } = await import('util');
-        const execFileAsync = promisify(execFile);
-        await execFileAsync('gh', ['repo', 'view', `${owner}/${repo}`, '--json', 'name']);
-        return true;
-    }
-    catch {
-        /* repo not found or gh CLI unavailable */
-        return false;
-    }
-}
 /**
  * Commit (if dirty) and push a repo.
  *
@@ -1136,20 +1078,6 @@ export async function isSystemRepoOrigin(dir) {
         return false;
     }
 }
-/**
- * Check if repo has uncommitted changes (including untracked files).
- */
-export async function hasLocalChanges(dir) {
-    try {
-        const git = simpleGit(dir);
-        const status = await git.status();
-        return !status.isClean();
-    }
-    catch {
-        /* not a git repo */
-        return false;
-    }
-}
 /**
  * Render an absolute path in ~-relative form with forward slashes, matching the
  * way the rest of the CLI prints home-anchored paths (e.g. `~/.agents/.system`).
@@ -1587,79 +1515,12 @@ export async function getTrackedFiles(dir, subdir) {
         return [];
     }
 }
-/**
- * Check if upstream remote is configured.
- */
-export async function hasUpstreamRemote(dir) {
-    try {
-        const git = simpleGit(dir);
-        const remotes = await git.getRemotes(true);
-        return remotes.some(r => r.name === 'upstream');
-    }
-    catch {
-        /* not a git repo */
-        return false;
-    }
-}
-/**
- * Get the upstream remote fetch URL, or null if none configured.
- */
-export async function getUpstreamUrl(dir) {
-    try {
-        const git = simpleGit(dir);
-        const remotes = await git.getRemotes(true);
-        const upstream = remotes.find(r => r.name === 'upstream');
-        return upstream?.refs?.fetch ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Add or update the upstream remote.
- */
-export async function setUpstreamRemote(dir, url) {
-    const git = simpleGit(dir);
-    const remotes = await git.getRemotes(true);
-    const hasUpstream = remotes.some(r => r.name === 'upstream');
-    if (hasUpstream) {
-        await git.remote(['set-url', 'upstream', url]);
-    }
-    else {
-        await git.remote(['add', 'upstream', url]);
-    }
-}
-/**
- * Pull from upstream remote (merge updates from system repo).
- */
-export async function pullFromUpstream(dir) {
-    try {
-        const git = simpleGit(dir);
-        // Check if upstream exists
-        const remotes = await git.getRemotes(true);
-        const upstream = remotes.find(r => r.name === 'upstream');
-        if (!upstream) {
-            return { success: false, commit: '', error: 'No upstream remote configured. Run `agents fork` first.' };
-        }
-        // Fetch and merge from upstream
-        await git.fetch('upstream');
-        await git.merge(['upstream/main']);
-        const log = await git.log({ maxCount: 1 });
-        return {
-            success: true,
-            commit: log.latest?.hash.slice(0, 8) || 'unknown',
-        };
-    }
-    catch (err) {
-        return { success: false, commit: '', error: err.message };
-    }
-}
 /**
  * Try to auto-pull a git repo if it's clean and has a remote.
  * Uses --ff-only for safety (fails if diverged instead of creating merge commits).
  * Returns silently on success, returns error message on failure.
  */
-export async function tryAutoPull(dir) {
+async function tryAutoPull(dir) {
     // Must be a git repo
     if (!isGitRepo(dir)) {
         return { pulled: false };

package/dist/lib/github/gh-overload.d.ts

@@ -49,10 +49,6 @@ export declare function renderRollup(input: RollupItem[], json: boolean): string
  * forever and never posts a run, exactly what `gh pr checks` also ignores.
  */
 export declare function isSettled(rollup: RollupItem[], pendingSuites: number): boolean;
-/** Eager REST watch: poll to a terminal state, re-anchored to the live head SHA. */
-export declare function watchChecks(target: Target, json: boolean, realGh: string): Promise<number>;
-/** Lazy one-shot: real gh first; translate to REST only on the exact rate-limit signal. */
-export declare function checksOnce(target: Target | null, json: boolean, realGh: string, ghArgs: string[]): Promise<number>;
 /** Entry point for the `__gh` early branch in index.ts. */
 export declare function runGhOverload(argv: string[], cwd?: string): Promise<number>;
 export {};

package/dist/lib/github/gh-overload.js

@@ -168,7 +168,7 @@ export function isSettled(rollup, pendingSuites) {
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /** Eager REST watch: poll to a terminal state, re-anchored to the live head SHA. */
-export async function watchChecks(target, json, realGh) {
+async function watchChecks(target, json, realGh) {
     const gh = restExec(realGh);
     const deadline = Date.now() + 30 * 60_000; // 30-min guard against a hung matrix
     let last = '';
@@ -201,7 +201,7 @@ export async function watchChecks(target, json, realGh) {
     }
 }
 /** Lazy one-shot: real gh first; translate to REST only on the exact rate-limit signal. */
-export async function checksOnce(target, json, realGh, ghArgs) {
+async function checksOnce(target, json, realGh, ghArgs) {
     // Try real gh, capturing output so we can detect the rate-limit signal.
     try {
         const { stdout } = await execFileAsync(realGh, ghArgs, { env: ghChildEnv(), maxBuffer: 16 * 1024 * 1024 });

package/dist/lib/github/project-prs.d.ts

@@ -0,0 +1,118 @@
+/**
+ * `agents projects prs <PROJECT>` — every OPEN pull request across a project's
+ * attached repositories, as one machine-readable envelope for AGI Menu.
+ *
+ * Why this exists: `agents projects status`'s `openPrs` only carries the PRs the
+ * fleet's own SESSIONS opened (the session rollup), so a project's board of open
+ * PRs — drafts, other people's PRs, anything not tied to a live session — is
+ * invisible to it. This reads the truth straight from GitHub.
+ *
+ * Design constraints (see docs conventions + the contract in
+ * `.agents/scratch/contracts-status.json`):
+ *   - Repos come ONLY from the ProjectDef's own attached slugs
+ *     ({@link projectRepoSlugs}); `--repo` is refused unless it is one of them.
+ *   - The list is REST + paginated (`gh api repos/{repo}/pulls?state=open
+ *     --paginate`), includes drafts, and applies NO author filter — it is the
+ *     whole open board, not this user's mergeable set. REST is the budget the
+ *     fleet's GraphQL poll loops do not drain (PHNX-3501).
+ *   - `checks` / `reviewDecision` are null in the list; `--number N` enriches
+ *     exactly that one PR against its live head SHA (checks via REST
+ *     {@link rollupForSha}, reviewDecision via a single lazy `gh pr view`).
+ *   - A per-repo fetch failure is reported as `repositories[].error` and flips
+ *     `partial` — it is NEVER relabeled as "zero open PRs".
+ */
+import { type GhExec } from './pr-mergeable.js';
+import { type RollupItem } from './rest.js';
+import type { ProjectDef } from '../projects.js';
+/** The author of a PR, as the menu renders it (login + avatar). */
+export interface ProjectPrAuthor {
+    login: string;
+    avatarUrl: string;
+}
+/** One open PR row. `checks`/`reviewDecision` are null unless the PR was enriched. */
+export interface ProjectPr {
+    number: number;
+    title: string;
+    url: string;
+    isDraft: boolean;
+    /** Upper-cased GitHub state — always `OPEN` here (only open PRs are listed). */
+    state: string;
+    updatedAt: string;
+    author: ProjectPrAuthor;
+    headRefName: string;
+    baseRefName: string;
+    headSha: string;
+    body: string;
+    /** Populated only for the `--number` PR: the head-SHA status-check rollup. */
+    checks: RollupItem[] | null;
+    /** Populated only for the `--number` PR: GitHub's computed review decision. */
+    reviewDecision: string | null;
+}
+/** One repository's open PRs, or the error that stopped its fetch. */
+export interface ProjectRepoPrs {
+    slug: string;
+    pullRequests: ProjectPr[];
+    /** Non-null when the fetch failed — the list is then NOT authoritative. */
+    error: string | null;
+}
+/** The full `projects prs --json` envelope. */
+export interface ProjectPrsEnvelope {
+    project: {
+        name: string;
+        linearProjectId: string | null;
+    };
+    repositories: ProjectRepoPrs[];
+    /** True when at least one repository fetch failed (its list is incomplete). */
+    partial: boolean;
+}
+/** Options for one `projects prs` run. `number` requires `repo`. */
+export interface ProjectPrsOptions {
+    /** Restrict to one attached repo (canonicalized, membership-checked). */
+    repo?: string;
+    /** Lazy detail: enrich exactly this PR's checks + reviewDecision. */
+    number?: number;
+}
+/** Build a {@link ProjectPr} from the flattened jq row. checks/reviewDecision start null. */
+export declare function rowToProjectPr(row: Record<string, unknown>): ProjectPr;
+/**
+ * Every OPEN PR for one repo, over REST, fully paginated, drafts included, no
+ * author filter. `--paginate` follows Link headers; `--jq` streams one flattened
+ * object per line so a multi-page result stays parseable.
+ */
+export declare function listOpenPrs(repo: string, gh?: GhExec): Promise<ProjectPr[]>;
+/** One PR by number, over REST (`GET repos/{repo}/pulls/{n}`). Throws if it is gone. */
+export declare function fetchOnePr(repo: string, number: number, gh?: GhExec): Promise<ProjectPr>;
+/**
+ * GitHub's computed review decision AND the PR's current head oid, from ONE lazy
+ * `gh pr view` (GraphQL). reviewDecision is deliberately NOT REST-derived: it is
+ * a branch-protection / CODEOWNERS decision REST cannot compute, and
+ * approximating it could mislead a merge decision (PHNX-3501 note). `headRefOid`
+ * rides the same call so the checks and the review verdict can be anchored to the
+ * SAME head — a PR that advanced between the REST read and this call would
+ * otherwise pair a stale check rollup with a current review. One call per
+ * `--number`, never a poll loop, so it does not drain the shared GraphQL budget.
+ */
+export declare function fetchReviewAndHead(repo: string, number: number, gh?: GhExec): Promise<{
+    reviewDecision: string | null;
+    headRefOid: string | null;
+}>;
+/**
+ * Enrich one PR with its checks + reviewDecision, both anchored to the SAME head.
+ * `gh pr view` gives the authoritative current head oid; the check rollup is run
+ * against THAT (not the possibly-staler REST head SHA), and `headSha` is updated
+ * to match, so checks and reviewDecision can never describe two different heads.
+ */
+export declare function enrichPr(repo: string, pr: ProjectPr, gh?: GhExec): Promise<ProjectPr>;
+/**
+ * Resolve which repositories a run targets, restricted to the project's own
+ * attached repos. Slugs are canonicalized (a renamed repo lists nothing under
+ * its old name — `phnx-labs/agents-cli` → `phnx-labs/agi-cli`). A `--repo` that
+ * is not one of the project's attached repos (raw or canonical) is refused.
+ */
+export declare function resolveTargetSlugs(def: ProjectDef, repo: string | undefined, gh: GhExec): Promise<string[]>;
+/**
+ * Build the full envelope. `number` (which the command requires alongside
+ * `repo`) fetches and enriches exactly that one PR; otherwise every target
+ * repo's open PRs are listed with checks/reviewDecision left null.
+ */
+export declare function buildProjectPrs(def: ProjectDef, opts?: ProjectPrsOptions, gh?: GhExec): Promise<ProjectPrsEnvelope>;