@voidlabs.gg/voidshift-agents 0.4.3 → 0.4.5

package/dist/tracker.js

@@ -0,0 +1,36 @@
+import { createLinear } from "./linear.js";
+import { readSecret } from "./secrets.js";
+import { createVoidTrack } from "./voidtrack.js";
+export const TRACKERS = {
+    linear: { name: 'Linear', keyHint: 'Linear > Settings > Security & access > API keys' },
+    voidtrack: { name: 'VoidTrack', keyHint: 'VoidTrack > Settings > API keys' },
+};
+export function trackersFor(configDir) {
+    const open = new Map();
+    return (kind) => {
+        let t = open.get(kind);
+        if (!t) {
+            const key = readSecret(configDir, kind);
+            if (!key)
+                throw new Error(`No ${TRACKERS[kind].name} API key. Run vsf agents key${kind === 'linear' ? '' : ` --${kind}`}`);
+            t = kind === 'voidtrack' ? createVoidTrack(key) : createLinear(key);
+            open.set(kind, t);
+        }
+        return t;
+    };
+}
+// Stands in for a tracker on a scheduled run, which has no card: reads find
+// nothing and writes go nowhere.
+export const noTracker = {
+    viewer: async () => ({ id: '', name: '' }),
+    myCardsWithLabel: async () => [],
+    card: async (id) => {
+        throw new Error(`a scheduled run has no card ${id}`);
+    },
+    comments: async () => [],
+    comment: async () => { },
+    setLabels: async (card, next) => {
+        card.labels = next;
+    },
+    moveTo: async () => false,
+};

package/dist/voidtrack.d.ts

@@ -0,0 +1,18 @@
+import type { Card } from './linear.ts';
+export declare const branchFor: (identifier: string) => string;
+export declare function mapIssue(i: any, web: string): Card;
+export declare function createVoidTrack(apiKey: string, fetcher?: typeof fetch): {
+    viewer(): Promise<{
+        id: string;
+        name: string;
+    }>;
+    myCardsWithLabel(label: string, team: string): Promise<Card[]>;
+    card(identifier: string): Promise<Card>;
+    comments(identifier: string): Promise<{
+        body: string;
+        createdAt: string;
+    }[]>;
+    comment(card: Card, body: string): Promise<void>;
+    setLabels(card: Card, next: string[]): Promise<void>;
+    moveTo(card: Card, stateName: string): Promise<boolean>;
+};

package/dist/voidtrack.js

@@ -0,0 +1,89 @@
+// VoidTrack over its REST API with a bearer key. Self hosted installs set
+// VOIDTRACK_API_URL; the web app lives at the same address without /api.
+const apiBase = () => (process.env.VOIDTRACK_API_URL ?? 'https://web.voidtrack.app/api').replace(/\/$/, '');
+// One branch per card that survives a retitle: GitHub closes a pull request
+// whose branch is renamed.
+export const branchFor = (identifier) => identifier.toLowerCase();
+export function mapIssue(i, web) {
+    return {
+        id: i.id,
+        identifier: i.identifier,
+        title: i.title,
+        description: i.description ?? undefined,
+        url: `${web}/issue/${i.identifier}`,
+        branchName: branchFor(i.identifier),
+        teamId: i.team?.id ?? '',
+        teamKey: i.team?.key ?? i.identifier.split('-')[0],
+        projectName: i.project?.name ?? undefined,
+        labels: (i.labels ?? []).map((l) => (typeof l === 'string' ? l : l.name)),
+    };
+}
+export function createVoidTrack(apiKey, fetcher = fetch) {
+    const base = apiBase();
+    const web = base.replace(/\/api$/, '');
+    async function call(method, path, body) {
+        let res;
+        try {
+            res = await fetcher(`${base}${path}`, {
+                method,
+                signal: AbortSignal.timeout(30_000),
+                headers: { Authorization: `Bearer ${apiKey}`, ...(body === undefined ? {} : { 'Content-Type': 'application/json' }) },
+                body: body === undefined ? undefined : JSON.stringify(body),
+            });
+        }
+        catch (err) {
+            const cause = err.cause;
+            throw new Error(`could not reach VoidTrack (${cause?.code ?? cause?.message ?? err.message})`);
+        }
+        const text = await res.text();
+        if (!res.ok)
+            throw Object.assign(new Error(`voidtrack ${method} ${path.split('?')[0]} ${res.status}: ${text.slice(0, 200)}`), { status: res.status });
+        return text ? JSON.parse(text) : {};
+    }
+    const enc = encodeURIComponent;
+    return {
+        async viewer() {
+            const d = await call('GET', '/v1/users');
+            const me = (d.users ?? []).find((u) => u.isMe);
+            if (!me)
+                throw new Error('voidtrack did not say which user this key belongs to');
+            return { id: me.id, name: me.name };
+        },
+        // My open cards in the team carrying the label. The API cannot filter on
+        // labels, so that part happens here.
+        async myCardsWithLabel(label, team) {
+            const d = await call('GET', `/v1/issues?team=${enc(team)}&assignee=me&stateType=backlog,unstarted,started&sort=created&limit=200`);
+            return (d.issues ?? []).map((i) => mapIssue(i, web)).filter((c) => c.labels.includes(label));
+        },
+        async card(identifier) {
+            const d = await call('GET', `/v1/issues/${enc(identifier)}`);
+            if (!d.issue)
+                throw new Error(`voidtrack has no card ${identifier}`);
+            return mapIssue(d.issue, web);
+        },
+        async comments(identifier) {
+            const d = await call('GET', `/v1/issues/${enc(identifier)}/comments`);
+            return (d.comments ?? []).map((c) => ({ body: c.body, createdAt: c.createdAt }));
+        },
+        async comment(card, body) {
+            await call('POST', `/v1/issues/${enc(card.identifier)}/comments`, { body });
+        },
+        // Labels are free text on VoidTrack and the list replaces the whole set.
+        async setLabels(card, next) {
+            await call('PATCH', `/v1/issues/${enc(card.identifier)}`, { labels: next });
+            card.labels = next;
+        },
+        // Move to a named state; false if the team has no such state.
+        async moveTo(card, stateName) {
+            try {
+                await call('PATCH', `/v1/issues/${enc(card.identifier)}`, { state: stateName });
+                return true;
+            }
+            catch (err) {
+                if (err.status === 400 || err.status === 404)
+                    return false;
+                throw err;
+            }
+        },
+    };
+}

package/dist/workflow.d.ts

@@ -47,6 +47,6 @@ export interface PromptInput {
     extra?: string;
 }
 export declare function buildPrompt(p: PromptInput): string;
-export declare function verdictBlock<T extends string>(steps: T[], i: number, isVerdict: (s: T) => boolean): [number, number];
-export declare function fixTarget<T extends string>(steps: T[], blockStart: number, isProducer: (s: T) => boolean): number;
+export declare function verdictBlock<T>(steps: T[], i: number, isVerdict: (s: T) => boolean): [number, number];
+export declare function fixTarget<T>(steps: T[], blockStart: number, isProducer: (s: T) => boolean): number;
 export declare function planBody(output: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voidlabs.gg/voidshift-agents",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "Agents for Claude Code and Codex that plan, build and QA Linear cards, chained and run in the background.",
   "license": "Apache-2.0",
   "repository": {