@phnx-labs/agents-cli 1.22.34 → 1.22.37

package/dist/lib/auto-dispatch-linear.js

@@ -1,107 +0,0 @@
-/**
- * Concrete Linear gateway for auto-dispatch.
- *
- * Talks to the Linear GraphQL API. The API key is read from the LINEAR_API_KEY
- * env var, falling back to the macOS keychain generic-password `linear-api-key`
- * (how the rest of the stack stores it). If no key is resolvable, the gateway is
- * absent and the daemon skips auto-dispatch entirely.
- *
- * "Started" (Doing) and "unstarted" (Todo) are Linear state *types*, so we never
- * hardcode a team's custom state names. `startIssue` resolves the team's first
- * started-type state (cached per team) and moves the issue there — the existing
- * factory webhook turns that transition into a real run.
- */
-import { execFileSync } from 'child_process';
-const LINEAR_API = 'https://api.linear.app/graphql';
-/** Resolve the Linear API key from env or (on macOS) the keychain. Null if absent. */
-export function resolveLinearApiKey() {
-    const fromEnv = process.env.LINEAR_API_KEY?.trim();
-    if (fromEnv)
-        return fromEnv;
-    if (process.platform === 'darwin') {
-        try {
-            const out = execFileSync('security', ['find-generic-password', '-s', 'linear-api-key', '-w'], {
-                encoding: 'utf-8',
-                stdio: ['ignore', 'pipe', 'ignore'],
-            });
-            const key = out.trim();
-            if (key)
-                return key;
-        }
-        catch {
-            // not in keychain — fall through
-        }
-    }
-    return null;
-}
-async function gql(apiKey, query, variables) {
-    const res = await fetch(LINEAR_API, {
-        method: 'POST',
-        headers: { Authorization: apiKey, 'Content-Type': 'application/json' },
-        body: JSON.stringify({ query, variables }),
-    });
-    if (!res.ok)
-        throw new Error(`Linear API HTTP ${res.status}`);
-    const json = (await res.json());
-    if (json.errors?.length)
-        throw new Error(`Linear API: ${json.errors.map((e) => e.message).join('; ')}`);
-    if (!json.data)
-        throw new Error('Linear API: empty response');
-    return json.data;
-}
-/** Build a real Linear gateway, or null when no API key is configured. */
-export function createLinearGateway() {
-    const apiKey = resolveLinearApiKey();
-    if (!apiKey)
-        return null;
-    // Cache the resolved started-state id per team so we don't re-query each dispatch.
-    const startedStateByTeam = new Map();
-    async function resolveStartedState(teamId) {
-        const cached = startedStateByTeam.get(teamId);
-        if (cached)
-            return cached;
-        const data = await gql(apiKey, `query($t:String!){ workflowStates(filter:{ team:{ id:{ eq:$t } }, type:{ eq:"started" } }, first:10){ nodes{ id type position } } }`, { t: teamId });
-        const nodes = data.workflowStates.nodes.slice().sort((a, b) => a.position - b.position);
-        const state = nodes[0];
-        if (!state)
-            throw new Error(`no started-type workflow state for team ${teamId}`);
-        startedStateByTeam.set(teamId, state.id);
-        return state.id;
-    }
-    // team id per issue, captured during fetchDelegatedTodo, so startIssue can resolve state.
-    const teamByIssue = new Map();
-    return {
-        async countInFlight(linearProjectId) {
-            const data = await gql(apiKey, `query($p:ID!){ issues(filter:{ project:{ id:{ eq:$p } }, state:{ type:{ eq:"started" } }, delegate:{ null:false } }, first:250){ nodes{ id } } }`, { p: linearProjectId });
-            return data.issues.nodes.length;
-        },
-        async fetchDelegatedTodo(linearProjectId) {
-            const data = await gql(apiKey, `query($p:ID!){ issues(filter:{ project:{ id:{ eq:$p } }, state:{ type:{ eq:"unstarted" } }, delegate:{ null:false } }, first:50){ nodes{ id identifier title priority delegate{ name } team{ id } } } }`, { p: linearProjectId });
-            const out = [];
-            for (const n of data.issues.nodes) {
-                if (!n.delegate?.name)
-                    continue;
-                if (n.team?.id)
-                    teamByIssue.set(n.id, n.team.id);
-                out.push({ id: n.id, identifier: n.identifier, title: n.title ?? '', priority: n.priority ?? 0, delegateName: n.delegate.name });
-            }
-            return out;
-        },
-        async markStarted(issueId, delegateName) {
-            const teamId = teamByIssue.get(issueId);
-            if (!teamId)
-                throw new Error(`unknown team for issue ${issueId} (fetch it first)`);
-            const stateId = await resolveStartedState(teamId);
-            const data = await gql(apiKey, `mutation($id:String!,$s:String!){ issueUpdate(id:$id, input:{ stateId:$s }){ success } }`, { id: issueId, s: stateId });
-            if (!data.issueUpdate.success)
-                throw new Error(`issueUpdate failed for ${issueId}`);
-            // Leave a trail so the auto-dispatch is visible in the ticket history.
-            try {
-                await gql(apiKey, `mutation($i:String!,$b:String!){ commentCreate(input:{ issueId:$i, body:$b }){ success } }`, { i: issueId, b: `Auto-dispatched to **${delegateName}** by the factory (moved Todo → Doing).` });
-            }
-            catch {
-                // comment is best-effort — the state change is what matters
-            }
-        },
-    };
-}

package/dist/lib/auto-dispatch-provider.d.ts

@@ -1,10 +0,0 @@
-/**
- * Concrete Dispatcher for auto-dispatch — runs a ticket through agents-cli's own
- * cloud-provider abstraction (`resolveProvider().dispatch()`), the same layer as
- * `agents cloud run`. Rush (Prix) is one provider among rush/codex/factory; a
- * project pins its provider via `provider` in projects.json, else the delegate
- * agent's native cloud is used. This is what removes the hidden Prix coupling —
- * auto-dispatch no longer depends on the prix/api webhook.
- */
-import type { Dispatcher } from './auto-dispatch.js';
-export declare function createProviderDispatcher(): Dispatcher;

package/dist/lib/auto-dispatch-provider.js

@@ -1,30 +0,0 @@
-/**
- * Concrete Dispatcher for auto-dispatch — runs a ticket through agents-cli's own
- * cloud-provider abstraction (`resolveProvider().dispatch()`), the same layer as
- * `agents cloud run`. Rush (Prix) is one provider among rush/codex/factory; a
- * project pins its provider via `provider` in projects.json, else the delegate
- * agent's native cloud is used. This is what removes the hidden Prix coupling —
- * auto-dispatch no longer depends on the prix/api webhook.
- */
-import { resolveProvider } from './cloud/registry.js';
-export function createProviderDispatcher() {
-    return {
-        async dispatch({ agent, prompt, repo, provider, host }) {
-            const p = resolveProvider(provider, agent);
-            const caps = p.capabilities();
-            if (!caps.available) {
-                throw new Error(`cloud provider '${p.id}' is not available (auth/binary missing)`);
-            }
-            if (!caps.dispatch) {
-                throw new Error(`cloud provider '${p.id}' does not support dispatch`);
-            }
-            // The host provider clones nothing — a repo target is meaningless there
-            // and its dispatch() rejects it; a ticket project pinned to 'host' relies
-            // on the machine's own checkout (the project's `host` names the machine).
-            const task = p.id === 'host'
-                ? await p.dispatch({ agent, prompt, providerOptions: { host } })
-                : await p.dispatch({ agent, prompt, repo });
-            return { id: task.id };
-        },
-    };
-}

package/dist/lib/auto-dispatch.d.ts

@@ -1,93 +0,0 @@
-/**
- * Auto-dispatch — pull side of the factory dispatch loop.
- *
- * Polls Linear for issues that are delegated to an agent and still in Todo for a
- * managed project, and — up to a per-project concurrency cap — DISPATCHES each
- * through agents-cli's own cloud-provider abstraction (`resolveProvider().dispatch()`),
- * then marks the ticket Doing so it isn't picked up twice.
- *
- * The dispatch goes through the same provider layer as `agents cloud run`, so Rush
- * (Prix) is just one provider among rush/codex/factory — NOT a hidden requirement.
- * A project pins its provider via `dispatch.provider` in its
- * ~/.agents/projects/<name>.yaml definition.
- *
- * OPT-IN: a project auto-dispatches ONLY when `dispatch.enabled: true` AND
- * `dispatch.maxAgents > 0` AND it has a `linear.projectId`. Nothing is on by default.
- */
-/** The subset of a project definition this module needs. */
-export interface AutoDispatchProject {
-    id: string;
-    name: string;
-    linearProjectId?: string;
-    repoSlug?: string;
-    autoDispatch?: boolean;
-    maxAgents?: number;
-    provider?: string;
-    host?: string;
-}
-/** A Linear issue that is a candidate for dispatch. */
-export interface DelegatedIssue {
-    id: string;
-    identifier: string;
-    title: string;
-    delegateName: string;
-    priority: number;
-}
-/** One planned dispatch: which issue, to which agent, in which project. */
-export interface PlannedDispatch {
-    projectId: string;
-    repoSlug?: string;
-    provider?: string;
-    host?: string;
-    issueId: string;
-    identifier: string;
-    title: string;
-    delegateName: string;
-}
-/**
- * Read auto-dispatch candidates from canonical project YAML definitions
- * (~/.agents/projects/<name>.yaml). Only projects with `dispatch.enabled: true`
- * are returned; the caller's `isEligible` gate then checks the cap and Linear id.
- */
-export declare function readAutoDispatchProjects(): AutoDispatchProject[];
-/** A project is eligible only when it has explicitly opted in with a positive cap. */
-export declare function isEligible(p: AutoDispatchProject): boolean;
-/**
- * PURE planner. Given eligible projects, in-flight counts, and delegated-Todo
- * issues per project, decide which issues to dispatch — never exceeding
- * `maxAgents` in-flight. Highest Linear priority first.
- */
-export declare function planAutoDispatch(projects: AutoDispatchProject[], inFlightByProject: Record<string, number>, delegatedTodoByProject: Record<string, DelegatedIssue[]>): PlannedDispatch[];
-/** Map Linear priority to a sortable rank (urgent first, none last). */
-export declare function priorityRank(priority: number): number;
-/** Build the prompt an auto-dispatched agent receives for a ticket. */
-export declare function dispatchPrompt(identifier: string, title: string): string;
-/** Linear I/O surface — discovery + bookkeeping (NOT the dispatch trigger). */
-export interface LinearGateway {
-    /** Count issues in a started ("Doing") state whose delegate is set, per project. */
-    countInFlight(linearProjectId: string): Promise<number>;
-    /** Fetch delegated issues in an unstarted ("Todo") state for a project. */
-    fetchDelegatedTodo(linearProjectId: string): Promise<DelegatedIssue[]>;
-    /** After a successful dispatch: move the issue Todo -> Doing so it isn't re-picked. */
-    markStarted(issueId: string, delegateName: string): Promise<void>;
-}
-/** Dispatch surface — runs a ticket through agents-cli's cloud/local provider layer. */
-export interface Dispatcher {
-    dispatch(opts: {
-        agent: string;
-        prompt: string;
-        repo?: string;
-        provider?: string;
-        host?: string;
-    }): Promise<{
-        id: string;
-    }>;
-}
-export interface AutoDispatchDeps {
-    projects: AutoDispatchProject[];
-    linear: LinearGateway;
-    dispatcher: Dispatcher;
-    log?: (level: 'INFO' | 'WARN' | 'ERROR', msg: string) => void;
-}
-/** One tick: read state per eligible project, plan, dispatch, then mark started. */
-export declare function autoDispatchTick(deps: AutoDispatchDeps): Promise<PlannedDispatch[]>;

package/dist/lib/auto-dispatch.js

@@ -1,128 +0,0 @@
-/**
- * Auto-dispatch — pull side of the factory dispatch loop.
- *
- * Polls Linear for issues that are delegated to an agent and still in Todo for a
- * managed project, and — up to a per-project concurrency cap — DISPATCHES each
- * through agents-cli's own cloud-provider abstraction (`resolveProvider().dispatch()`),
- * then marks the ticket Doing so it isn't picked up twice.
- *
- * The dispatch goes through the same provider layer as `agents cloud run`, so Rush
- * (Prix) is just one provider among rush/codex/factory — NOT a hidden requirement.
- * A project pins its provider via `dispatch.provider` in its
- * ~/.agents/projects/<name>.yaml definition.
- *
- * OPT-IN: a project auto-dispatches ONLY when `dispatch.enabled: true` AND
- * `dispatch.maxAgents > 0` AND it has a `linear.projectId`. Nothing is on by default.
- */
-import { listProjectDefs } from './projects.js';
-/**
- * Read auto-dispatch candidates from canonical project YAML definitions
- * (~/.agents/projects/<name>.yaml). Only projects with `dispatch.enabled: true`
- * are returned; the caller's `isEligible` gate then checks the cap and Linear id.
- */
-export function readAutoDispatchProjects() {
-    return listProjectDefs()
-        .filter((d) => d.dispatch?.enabled === true)
-        .map((d) => ({
-        id: d.name,
-        name: d.name,
-        linearProjectId: d.linear?.projectId,
-        repoSlug: d.repo ?? d.repos?.[0]?.slug,
-        autoDispatch: d.dispatch?.enabled ?? false,
-        maxAgents: d.dispatch?.maxAgents,
-        provider: d.dispatch?.provider,
-        host: d.dispatch?.host,
-    }));
-}
-/** A project is eligible only when it has explicitly opted in with a positive cap. */
-export function isEligible(p) {
-    return p.autoDispatch === true && typeof p.maxAgents === 'number' && p.maxAgents > 0 && !!p.linearProjectId;
-}
-/**
- * PURE planner. Given eligible projects, in-flight counts, and delegated-Todo
- * issues per project, decide which issues to dispatch — never exceeding
- * `maxAgents` in-flight. Highest Linear priority first.
- */
-export function planAutoDispatch(projects, inFlightByProject, delegatedTodoByProject) {
-    const plan = [];
-    for (const p of projects) {
-        if (!isEligible(p))
-            continue;
-        const cap = p.maxAgents;
-        const slots = cap - (inFlightByProject[p.id] ?? 0);
-        if (slots <= 0)
-            continue;
-        const candidates = (delegatedTodoByProject[p.id] ?? [])
-            .slice()
-            .sort((a, b) => priorityRank(a.priority) - priorityRank(b.priority));
-        for (const issue of candidates.slice(0, slots)) {
-            plan.push({
-                projectId: p.id,
-                repoSlug: p.repoSlug,
-                provider: p.provider,
-                host: p.host,
-                issueId: issue.id,
-                identifier: issue.identifier,
-                title: issue.title,
-                delegateName: issue.delegateName,
-            });
-        }
-    }
-    return plan;
-}
-/** Map Linear priority to a sortable rank (urgent first, none last). */
-export function priorityRank(priority) {
-    return priority === 0 ? 5 : priority;
-}
-/** Build the prompt an auto-dispatched agent receives for a ticket. */
-export function dispatchPrompt(identifier, title) {
-    return `Work on Linear ticket ${identifier}: ${title}. Read the ticket for full context, implement it, and open a PR when done.`;
-}
-/** One tick: read state per eligible project, plan, dispatch, then mark started. */
-export async function autoDispatchTick(deps) {
-    const log = deps.log ?? (() => { });
-    const eligible = deps.projects.filter(isEligible);
-    if (eligible.length === 0)
-        return [];
-    const inFlight = {};
-    const todo = {};
-    for (const p of eligible) {
-        const pid = p.linearProjectId;
-        try {
-            inFlight[p.id] = await deps.linear.countInFlight(pid);
-            todo[p.id] = await deps.linear.fetchDelegatedTodo(pid);
-        }
-        catch (err) {
-            log('WARN', `auto-dispatch: failed to read Linear state for '${p.name}': ${err.message}`);
-            inFlight[p.id] = Number.MAX_SAFE_INTEGER; // fail closed for this project
-            todo[p.id] = [];
-        }
-    }
-    const plan = planAutoDispatch(eligible, inFlight, todo);
-    const dispatched = [];
-    for (const d of plan) {
-        try {
-            const task = await deps.dispatcher.dispatch({
-                agent: d.delegateName.trim().toLowerCase(),
-                prompt: dispatchPrompt(d.identifier, d.title),
-                repo: d.repoSlug,
-                provider: d.provider,
-                host: d.host,
-            });
-            // Bookkeeping only — dispatch already happened; moving to Doing keeps the
-            // ticket out of the next Todo poll. A failure here is non-fatal.
-            try {
-                await deps.linear.markStarted(d.issueId, d.delegateName);
-            }
-            catch (err) {
-                log('WARN', `auto-dispatch: dispatched ${d.identifier} but failed to mark Doing: ${err.message}`);
-            }
-            dispatched.push(d);
-            log('INFO', `auto-dispatch: dispatched ${d.identifier} to ${d.delegateName} (task ${task.id})`);
-        }
-        catch (err) {
-            log('WARN', `auto-dispatch: failed to dispatch ${d.identifier}: ${err.message}`);
-        }
-    }
-    return dispatched;
-}

package/dist/lib/export.d.ts

@@ -1,72 +0,0 @@
-import type { AgentId } from './types.js';
-export type ExportMode = 'merge' | 'replace' | 'staged';
-/** Filename of the provenance receipt written into the agent's config dir. */
-export declare const RECEIPT_NAME = ".agents-cli-export.json";
-/** Suffix for the incoming copy of a file the user already has. */
-export declare const CONFLICT_SUFFIX = ".from-agents-cli";
-/** Why an export cannot proceed. Each maps to a distinct user-facing remedy. */
-export type ExportBlocker = {
-    kind: 'not-installed';
-} | {
-    kind: 'not-isolated';
-} | {
-    kind: 'no-config';
-    source: string;
-} | {
-    kind: 'dest-adopted';
-    realPath: string;
-    adoptedVersion: string;
-};
-/** What the destination `~/.<agent>` currently is. */
-export type DestKind = 'absent' | 'real-dir' | 'foreign-symlink';
-/** One file the export would place, relative to the config dir root. */
-export interface ExportEntry {
-    /** Path relative to the config dir, e.g. `prompts/review.md`. */
-    rel: string;
-    /** Absolute source file inside the isolated home. */
-    source: string;
-    /** Absolute path this file will be written to. */
-    target: string;
-    /**
-     * Set when the user already has `rel`. `target` then points at the
-     * `.from-agents-cli` sibling, and `existing` is the untouched original.
-     */
-    existing?: string;
-}
-export interface ExportPlan {
-    agent: AgentId;
-    version: string;
-    mode: ExportMode;
-    /** The isolated config dir, e.g. `<versionDir>/home/.codex`. */
-    source: string;
-    /** The user's real config dir, e.g. `~/.codex`. */
-    dest: string;
-    destKind: DestKind;
-    /** Files with no counterpart in `dest` — written in place. */
-    writes: ExportEntry[];
-    /** Files the user already has — written alongside, never over. */
-    conflicts: ExportEntry[];
-    /** replace mode only: where `dest` gets moved first. */
-    backupPath: string | null;
-    /** staged mode only: the subdirectory receiving the whole tree. */
-    stagedPath: string | null;
-    receiptPath: string;
-    blocker: ExportBlocker | null;
-}
-export interface ExportResult {
-    exported: boolean;
-    dest: string;
-    written: string[];
-    conflicts: Array<{
-        path: string;
-        theirs: string;
-    }>;
-    backupPath: string | null;
-    stagedPath: string | null;
-    receiptPath: string | null;
-    errors: string[];
-}
-/** Build a read-only plan. Performs no mutations. */
-export declare function planExport(agent: AgentId, version: string, timestamp: number, mode?: ExportMode): ExportPlan;
-/** Execute a plan from {@link planExport}. */
-export declare function executeExport(plan: ExportPlan, timestamp: number): ExportResult;