@gaia-ai/gaia 0.2.0 → 0.4.0

package/dist/src/plugins/plugins.d.ts

@@ -1,38 +0,0 @@
-import type { DropSHPlugin } from 'dropsh/plugin';
-import type { ConductorFileConfig } from '../types.js';
-import type { GaiaAgent } from './agent/agent.js';
-import type { GaiaExecutor } from './executor/executor.js';
-import type { GaiaRemote } from './remote/remote.js';
-import type { GaiaWorkspace } from './workspace/workspace.js';
-export interface RemotePlugin extends DropSHPlugin {
-    readonly kind: 'remote';
-    readonly id: string;
-    readonly requiredModules: string[];
-    createRemote(config: ConductorFileConfig): Promise<GaiaRemote>;
-}
-export interface ExecutorPlugin extends DropSHPlugin {
-    readonly kind: 'executor';
-    readonly id: string;
-    readonly requiredModules: string[];
-    createExecutor(config: ConductorFileConfig): Promise<GaiaExecutor>;
-}
-export interface WorkspacePlugin extends DropSHPlugin {
-    readonly kind: 'workspace';
-    readonly id: string;
-    readonly requiredModules: string[];
-    createWorkspace(config: ConductorFileConfig): Promise<GaiaWorkspace>;
-}
-export interface AgentPlugin extends DropSHPlugin {
-    readonly kind: 'agent';
-    readonly id: string;
-    readonly requiredModules: string[];
-    createAgent(config: ConductorFileConfig): Promise<GaiaAgent>;
-}
-/** Resolves the remote from its named config slot. */
-export declare function selectRemote(config: ConductorFileConfig): Promise<GaiaRemote>;
-/** Resolves the executor from its named config slot. */
-export declare function selectExecutor(config: ConductorFileConfig): Promise<GaiaExecutor>;
-/** Resolves the workspace from its named config slot. */
-export declare function selectWorkspace(config: ConductorFileConfig): Promise<GaiaWorkspace>;
-/** Resolves the agent from its named config slot. */
-export declare function selectAgent(config: ConductorFileConfig): Promise<GaiaAgent>;

package/dist/src/plugins/plugins.js

@@ -1,16 +0,0 @@
-/** Resolves the remote from its named config slot. */
-export async function selectRemote(config) {
-    return config.remote.createRemote(config);
-}
-/** Resolves the executor from its named config slot. */
-export async function selectExecutor(config) {
-    return config.executor.createExecutor(config);
-}
-/** Resolves the workspace from its named config slot. */
-export async function selectWorkspace(config) {
-    return config.workspace.createWorkspace(config);
-}
-/** Resolves the agent from its named config slot. */
-export async function selectAgent(config) {
-    return config.agent.createAgent(config);
-}

package/dist/src/plugins/registry-exports.d.ts

@@ -1,6 +0,0 @@
-export { basicAuthProvider } from './auth/basic.js';
-export { selectAgent, selectExecutor, selectRemote, selectWorkspace, } from './plugins.js';
-export { DrupalGaiaRemote, drupalRemote } from './remote/drupal.js';
-export { FakeGaiaRemote, fakeRemote } from './remote/fake.js';
-export { FakeWorkspace, fakeWorkspace } from './workspace/fake.js';
-export { GitWorkspace, gitWorkspace } from './workspace/git.js';

package/dist/src/plugins/registry-exports.js

@@ -1,6 +0,0 @@
-export { basicAuthProvider } from './auth/basic.js';
-export { selectAgent, selectExecutor, selectRemote, selectWorkspace, } from './plugins.js';
-export { DrupalGaiaRemote, drupalRemote } from './remote/drupal.js';
-export { FakeGaiaRemote, fakeRemote } from './remote/fake.js';
-export { FakeWorkspace, fakeWorkspace } from './workspace/fake.js';
-export { GitWorkspace, gitWorkspace } from './workspace/git.js';

package/dist/src/plugins/remote/drupal.d.ts

@@ -1,47 +0,0 @@
-import type { JsonApiClient } from 'dropsh/plugin';
-import type { RemotePlugin } from '../plugins.js';
-import type { ActiveRun, ClaimedRun, ClaimOptions, ConductorRegistration, ConductorStatus, FinalizableRun, FinalizableTicket, GaiaRemote, RunWriteAttributes, Ticket, TicketComment } from './remote.js';
-interface JsonApiResource {
-    type?: string;
-    id?: string;
-    attributes?: Record<string, unknown>;
-}
-/**
- * Extracts gaia_comment resources from a JSON:API `included` array into
- * conductor-facing TicketComments. JSON:API renames the comment entity's `type`
- * field to `gaia_comment_type` (the bare `type` is the reserved resource type),
- * and serialises the text_long `body` as `{value, format, processed}`. Resources
- * of other types are ignored; the server already returns them created-ASC.
- */
-export declare function parseTicketComments(included: JsonApiResource[] | undefined): TicketComment[];
-export declare class DrupalGaiaRemote implements GaiaRemote {
-    private readonly api;
-    constructor(api: JsonApiClient);
-    fetchActiveRuns(id: string): Promise<ActiveRun[]>;
-    activeRunCount(id: string): Promise<number>;
-    claimNext(c: ClaimOptions): Promise<ClaimedRun | null>;
-    getTicket(uuid: string): Promise<Ticket>;
-    getRunWorktree(uuid: string): Promise<string>;
-    getRunTicketIdentifier(uuid: string): Promise<string>;
-    getRunTicketBranchName(uuid: string): Promise<string>;
-    registerConductor(reg: ConductorRegistration): Promise<string>;
-    heartbeat(reg: ConductorRegistration, load: number, lease?: number): Promise<string>;
-    getConductorStatus(id: string): Promise<string | null>;
-    setConductorStatus(id: string, status: string): Promise<void>;
-    listConductors(owner?: 'me'): Promise<ConductorStatus[]>;
-    markRunning(uuid: string, attrs?: RunWriteAttributes): Promise<void>;
-    fetchFinalizableRuns(id: string): Promise<FinalizableRun[]>;
-    finalizeRun(uuid: string, log: string): Promise<void>;
-    fetchFinalizableTickets(id: string): Promise<FinalizableTicket[]>;
-    closeTicket(uuid: string): Promise<void>;
-    /**
-     * Absolute worktree path of the ticket's latest run (highest run id with a
-     * non-empty worktree_path), or '' when none — the cwd the cleanup command
-     * runs in. The conductor persists worktree_path on markRunning, so a done
-     * ticket's run carries the path even after the run closed.
-     */
-    private latestRunWorktree;
-    private projectUuid;
-}
-export declare function drupalRemote(): RemotePlugin;
-export {};

package/dist/src/plugins/remote/drupal.js

@@ -1,337 +0,0 @@
-import { resolveAuth } from 'dropsh';
-import { createHttpClient, createJsonApiClient } from 'dropsh/plugin';
-const ACTIVE = ['claimed', 'running'];
-/**
- * Extracts gaia_comment resources from a JSON:API `included` array into
- * conductor-facing TicketComments. JSON:API renames the comment entity's `type`
- * field to `gaia_comment_type` (the bare `type` is the reserved resource type),
- * and serialises the text_long `body` as `{value, format, processed}`. Resources
- * of other types are ignored; the server already returns them created-ASC.
- */
-export function parseTicketComments(included) {
-    if (!Array.isArray(included)) {
-        return [];
-    }
-    const comments = [];
-    for (const res of included) {
-        if (res?.type !== 'gaia_comment--gaia_comment') {
-            continue;
-        }
-        const attrs = res.attributes ?? {};
-        const body = attrs.body;
-        const value = typeof body === 'string'
-            ? body
-            : typeof body?.value === 'string'
-                ? body.value
-                : '';
-        comments.push({
-            type: typeof attrs.gaia_comment_type === 'string'
-                ? attrs.gaia_comment_type
-                : 'comment',
-            body: value,
-            created: typeof attrs.created === 'string' ? attrs.created : '',
-        });
-    }
-    return comments;
-}
-export class DrupalGaiaRemote {
-    api;
-    constructor(api) {
-        this.api = api;
-    }
-    async fetchActiveRuns(id) {
-        // The conductor identity `id` is the machine_id (hash of hostname+path).
-        // gaia_run links to its owning conductor via the `conductor_id` entity-ref;
-        // filter on the related conductor's `machine_id` (nested relationship filter).
-        const rows = await this.api
-            .collection('gaia_run')
-            .where('conductor_id.machine_id', '=', id)
-            .whereIn('state', ACTIVE)
-            .fields(['state', 'state_at_start', 'worktree_path'])
-            .page(100)
-            .list();
-        return Promise.all(rows.map(async (r) => ({
-            runUuid: r.id,
-            ticketUuid: r.rel('ticket_id') ?? '',
-            ticketIdentifier: await this.getRunTicketIdentifier(r.id),
-            branchName: await this.getRunTicketBranchName(r.id),
-            state: r.attr('state') ?? '',
-            stateAtStart: r.attr('state_at_start') ?? '',
-            worktreePath: r.attr('worktree_path') ?? '',
-        })));
-    }
-    async activeRunCount(id) {
-        // Filter on the related conductor's `machine_id` (nested relationship filter).
-        return this.api
-            .collection('gaia_run')
-            .where('conductor_id.machine_id', '=', id)
-            .whereIn('state', ACTIVE)
-            .fields(['drupal_internal__id'])
-            .page(100)
-            .count();
-    }
-    async claimNext(c) {
-        const res = (await this.api.post('gaia/claim-next', {
-            data: {
-                attributes: {
-                    lease_seconds: c.leaseSeconds,
-                    // Server (`ConductorResolverTrait`) narrows to the caller's conductor
-                    // by the `machine_id` attribute; `c.conductorId` IS the machine_id.
-                    machine_id: c.conductorId,
-                },
-            },
-        }));
-        if (!res?.data) {
-            return null;
-        }
-        const d = res.data;
-        const rawId = d.attributes?.drupal_internal__id;
-        if (rawId === undefined || rawId === null) {
-            throw new Error(`claimNext: missing drupal_internal__id on run ${d.id}`);
-        }
-        return {
-            runUuid: d.id,
-            runId: Number(rawId),
-            ticketUuid: d.relationships?.ticket_id?.data?.id ?? '',
-            stateAtStart: String(d.attributes?.state_at_start ?? ''),
-            // handler_id was dropped; the handler is the work the run does, i.e. the
-            // ticket state the run started in.
-            handler: String(d.attributes?.state_at_start ?? ''),
-        };
-    }
-    async getTicket(uuid) {
-        // `?include=comments` sideloads the ticket's comments in one request so the
-        // conductor can render them into the dispatch prompt (review→coding bounce
-        // must carry the review summary to the coder). `comments` is a computed
-        // entity_reference field (CommentsItemList, ordered created ASC), so the
-        // included resources arrive oldest-first. We use the raw client here rather
-        // than `resource()` because `resource()` discards the `included` array.
-        const doc = (await this.api.get(`gaia_ticket/gaia_ticket/${uuid}?include=comments`));
-        const attrs = doc.data?.attributes ?? {};
-        const issueUrl = typeof attrs.origin === 'string' ? attrs.origin : undefined;
-        return {
-            uuid: doc.data?.id ?? uuid,
-            identifier: typeof attrs.identifier === 'string' ? attrs.identifier : uuid,
-            title: typeof attrs.title === 'string' ? attrs.title : '',
-            state: typeof attrs.state === 'string' ? attrs.state : '',
-            branchName: typeof attrs.branch_name === 'string' ? attrs.branch_name : '',
-            ...(typeof attrs.base_branch === 'string' && attrs.base_branch !== ''
-                ? { baseBranch: attrs.base_branch }
-                : {}),
-            comments: parseTicketComments(doc.included),
-            ...(issueUrl ? { issueUrl } : {}),
-        };
-    }
-    async getRunWorktree(uuid) {
-        const r = await this.api.resource('gaia_run', uuid);
-        return r.attr('worktree_path') ?? '';
-    }
-    async getRunTicketIdentifier(uuid) {
-        const run = await this.api.resource('gaia_run', uuid);
-        const ticketUuid = run.rel('ticket_id');
-        if (!ticketUuid) {
-            return '';
-        }
-        const ticket = await this.api.resource('gaia_ticket', ticketUuid);
-        return ticket.attr('identifier') ?? '';
-    }
-    async getRunTicketBranchName(uuid) {
-        const run = await this.api.resource('gaia_run', uuid);
-        const ticketUuid = run.rel('ticket_id');
-        if (!ticketUuid) {
-            return '';
-        }
-        const ticket = await this.api.resource('gaia_ticket', ticketUuid);
-        return ticket.attr('branch_name') ?? '';
-    }
-    async registerConductor(reg) {
-        const r = await this.api.upsert('gaia_conductor', { path: 'machine_id', value: reg.id }, {
-            attributes: {
-                machine_id: reg.id,
-                status: 'online',
-                workspace_root: reg.workspace,
-                label: reg.label,
-                states: reg.states,
-                max_parallel: reg.max_parallel,
-            },
-            relationships: {
-                owner_user_id: {
-                    data: { type: 'user--user', id: await this.api.me() },
-                },
-                project_id: {
-                    data: {
-                        type: 'gaia_project--gaia_project',
-                        id: await this.projectUuid(reg.project),
-                    },
-                },
-            },
-        });
-        return r.id; // drupal uuid
-    }
-    async heartbeat(reg, load, lease = 300) {
-        // Server-side upsert by machine_id (see HeartbeatResource): never 404s,
-        // heals a vanished registration, and returns the resulting status. Sending
-        // the full registration lets the server recreate the entity when missing.
-        const res = (await this.api.post('gaia/heartbeat', {
-            data: {
-                attributes: {
-                    machine_id: reg.id,
-                    project: reg.project,
-                    states: reg.states,
-                    workspace_root: reg.workspace,
-                    label: reg.label,
-                    max_parallel: reg.max_parallel,
-                    current_load: load,
-                    lease_seconds: lease,
-                },
-            },
-        }));
-        const status = res?.data?.attributes?.status;
-        return typeof status === 'string' ? status : 'online';
-    }
-    async getConductorStatus(id) {
-        const c = await this.api
-            .collection('gaia_conductor')
-            .where('machine_id', '=', id)
-            .fields(['status'])
-            .first();
-        return c ? (c.attr('status') ?? null) : null;
-    }
-    async setConductorStatus(id, status) {
-        const c = await this.api
-            .collection('gaia_conductor')
-            .where('machine_id', '=', id)
-            .first();
-        if (c) {
-            await this.api.update('gaia_conductor', c.id, { attributes: { status } });
-        }
-    }
-    async listConductors(owner) {
-        let col = this.api.collection('gaia_conductor');
-        if (owner === 'me') {
-            col = col.where('owner_user_id.id', '=', await this.api.me());
-        }
-        const rows = await col.page(200).list();
-        return rows.map((r) => ({
-            id: r.attr('machine_id') ?? r.id,
-            project: '',
-            label: r.attr('label') ?? '',
-            status: r.attr('status') ?? '',
-            lastSeen: r.attr('last_seen') ?? 0,
-            load: r.attr('current_load') ?? 0,
-        }));
-    }
-    async markRunning(uuid, attrs) {
-        const t = Math.floor(Date.now() / 1000);
-        await this.api.update('gaia_run', uuid, {
-            attributes: {
-                state: 'running',
-                heartbeat: t,
-                ...(attrs?.worktree_path ? { worktree_path: attrs.worktree_path } : {}),
-            },
-        });
-    }
-    async fetchFinalizableRuns(id) {
-        const rows = await this.api
-            .collection('gaia_run')
-            .where('conductor_id.machine_id', '=', id)
-            .where('state', '=', 'done')
-            .where('closed', '=', '0')
-            .fields(['worktree_path'])
-            .page(100)
-            .list();
-        return rows.map((r) => ({
-            runUuid: r.id,
-            worktreePath: r.attr('worktree_path') ?? '',
-        }));
-    }
-    async finalizeRun(uuid, log) {
-        const t = Math.floor(Date.now() / 1000);
-        await this.api.update('gaia_run', uuid, {
-            attributes: {
-                closed: true,
-                closed_date: t,
-                ...(log ? { log } : {}),
-            },
-        }); // NO state — the run is already done.
-    }
-    async fetchFinalizableTickets(id) {
-        // Symmetric to fetchFinalizableRuns, on the ticket axis: this conductor's
-        // tickets that reached done but were never closed. Nested relationship
-        // filter on the owning conductor's machine_id (`id` IS the machine_id).
-        const rows = await this.api
-            .collection('gaia_ticket')
-            .where('conductor_id.machine_id', '=', id)
-            .where('state', '=', 'done')
-            .where('closed', '=', '0')
-            .fields(['branch_name'])
-            .page(100)
-            .list();
-        return Promise.all(rows.map(async (r) => ({
-            ticketUuid: r.id,
-            branchName: r.attr('branch_name') ?? '',
-            worktreePath: await this.latestRunWorktree(r.id),
-        })));
-    }
-    async closeTicket(uuid) {
-        const t = Math.floor(Date.now() / 1000);
-        await this.api.update('gaia_ticket', uuid, {
-            attributes: { closed: true, closed_date: t },
-        }); // NO state — the ticket is already done.
-    }
-    /**
-     * Absolute worktree path of the ticket's latest run (highest run id with a
-     * non-empty worktree_path), or '' when none — the cwd the cleanup command
-     * runs in. The conductor persists worktree_path on markRunning, so a done
-     * ticket's run carries the path even after the run closed.
-     */
-    async latestRunWorktree(ticketUuid) {
-        const rows = await this.api
-            .collection('gaia_run')
-            .where('ticket_id.id', '=', ticketUuid)
-            .fields(['worktree_path', 'drupal_internal__id'])
-            .sort('-drupal_internal__id')
-            .page(100)
-            .list();
-        for (const r of rows) {
-            const path = r.attr('worktree_path');
-            if (path) {
-                return path;
-            }
-        }
-        return '';
-    }
-    async projectUuid(name) {
-        const p = await this.api
-            .collection('gaia_project')
-            .where('name', '=', name)
-            .first();
-        if (!p) {
-            throw new Error(`gaia project "${name}" not found`);
-        }
-        return p.id;
-    }
-}
-export function drupalRemote() {
-    return {
-        kind: 'remote',
-        id: 'drupal',
-        requiredModules: [],
-        async createRemote(config) {
-            const http = createHttpClient();
-            const auth = await resolveAuth({
-                baseUrl: config.site.base_url,
-                plugins: config.plugins ?? [],
-                http,
-                now: Date.now,
-                // stateDir omitted → dropsh defaultStateDir() (~/.config/dropsh)
-            });
-            return new DrupalGaiaRemote(createJsonApiClient({
-                baseUrl: config.site.base_url,
-                prefix: config.site.jsonapi_prefix,
-                http,
-                auth: auth,
-            }));
-        },
-    };
-}

package/dist/src/plugins/remote/fake.d.ts

@@ -1,81 +0,0 @@
-import type { RemotePlugin } from '../plugins.js';
-import type { ActiveRun, ClaimedRun, ClaimOptions, ConductorRegistration, ConductorStatus, FinalizableRun, FinalizableTicket, GaiaRemote, RunWriteAttributes, Ticket, TicketComment } from './remote.js';
-export interface FakeSeedRun {
-    runUuid: string;
-    /** Numeric (drupal_internal__id) run id. Defaults to a stable 1-based counter when omitted. */
-    id?: number;
-    ticketUuid: string;
-    stateAtStart: string;
-    /** Override the initial state (defaults to stateAtStart). */
-    state?: string;
-    handler?: string;
-    worktreePath?: string;
-    closed?: boolean;
-}
-export interface FakeSeedTicket {
-    identifier: string;
-    title: string;
-    state: string;
-    branchName?: string;
-    /** Computed base branch (parent branch / project default / 'main'). */
-    baseBranch?: string;
-    url?: string;
-    workflow?: string;
-    comments?: TicketComment[];
-    /** Whether the ticket is already closed (excluded from the cleanup query). */
-    closed?: boolean;
-}
-export interface FakeRemoteSeed {
-    runs?: FakeSeedRun[];
-    tickets?: Record<string, FakeSeedTicket>;
-}
-export interface MarkRunningCall {
-    runUuid: string;
-    attrs?: {
-        worktree_path?: string;
-    };
-}
-export interface FinalizeRunCall {
-    runUuid: string;
-    log: string;
-}
-export declare class FakeGaiaRemote implements GaiaRemote {
-    readonly calls: {
-        markRunning: MarkRunningCall[];
-        finalizeRun: FinalizeRunCall[];
-        closeTicket: string[];
-    };
-    /**
-     * Override for reconcile tests: when set, `fetchActiveRuns` returns this
-     * list verbatim instead of deriving it from the internal runs map.
-     */
-    activeRuns: ActiveRun[] | null;
-    private readonly runs;
-    private readonly queue;
-    private readonly tickets;
-    private conductorStatus;
-    /** Stable counter for assigning numeric ids to unseeded runs. */
-    private runIdCounter;
-    constructor(seed?: FakeRemoteSeed);
-    registerConductor(_reg: ConductorRegistration): Promise<string>;
-    heartbeat(): Promise<string>;
-    getConductorStatus(_conductorId: string): Promise<string | null>;
-    setConductorStatus(_conductorId: string, status: 'offline' | 'online'): Promise<void>;
-    listConductors(_owner?: 'me'): Promise<ConductorStatus[]>;
-    activeRunCount(_conductorId: string): Promise<number>;
-    fetchActiveRuns(_conductorId: string): Promise<ActiveRun[]>;
-    claimNext(_claim: ClaimOptions): Promise<ClaimedRun | null>;
-    getTicket(ticketUuid: string): Promise<Ticket>;
-    getRunWorktree(runUuid: string): Promise<string>;
-    getRunTicketIdentifier(runUuid: string): Promise<string>;
-    getRunTicketBranchName(runUuid: string): Promise<string>;
-    markRunning(runUuid: string, attrs?: RunWriteAttributes): Promise<void>;
-    fetchFinalizableRuns(_conductorId: string): Promise<FinalizableRun[]>;
-    finalizeRun(runUuid: string, log: string): Promise<void>;
-    fetchFinalizableTickets(_conductorId: string): Promise<FinalizableTicket[]>;
-    closeTicket(uuid: string): Promise<void>;
-    /** Worktree path of the ticket's most recently seeded run, or '' when none. */
-    private latestRunWorktree;
-    private internalActiveRuns;
-}
-export declare function fakeRemote(seed?: FakeRemoteSeed): RemotePlugin;