@atolis-hq/wake 0.2.96 → 0.3.0

package/dist/src/adapters/fake/fake-runner.js

@@ -1,77 +0,0 @@
-import { emitRuntimeEvent, runnerRuntimeEvent } from '../runner/runtime-events.js';
-import { createAgentExecution } from '../../core/live-execution.js';
-export function createFakeRunner(result, options) {
-    const runner = {
-        async start(input) {
-            return createAgentExecution(input, (liveInput) => runner.run(liveInput));
-        },
-        async run(_) {
-            const cli = options?.cli ?? 'Fake';
-            const isCanceled = () => _.cancellationSignal?.aborted === true;
-            if (isCanceled()) {
-                return {
-                    result: 'Fake runner canceled\nFAILED',
-                    model: 'fake',
-                    cli,
-                    failureClass: 'infra',
-                    metadata: { source: 'fake-runner', canceled: true },
-                };
-            }
-            await emitRuntimeEvent(_.onRuntimeEvent, runnerRuntimeEvent({
-                type: 'agent.process.started',
-                runId: _.runId,
-                projection: _.projection,
-                routing: _.routing,
-                cli,
-                model: 'fake',
-                payload: { synthetic: true },
-            }));
-            await emitRuntimeEvent(_.onRuntimeEvent, runnerRuntimeEvent({
-                type: 'agent.progress',
-                runId: _.runId,
-                projection: _.projection,
-                routing: _.routing,
-                cli,
-                model: 'fake',
-                sessionId: 'fake-session-1',
-                payload: { message: 'Fake runner completed', synthetic: true },
-            }));
-            await emitRuntimeEvent(_.onRuntimeEvent, runnerRuntimeEvent({
-                type: 'agent.process.exited',
-                runId: _.runId,
-                projection: _.projection,
-                routing: _.routing,
-                cli,
-                model: 'fake',
-                sessionId: 'fake-session-1',
-                payload: { exitCode: 0, synthetic: true },
-            }));
-            if (isCanceled()) {
-                return {
-                    result: 'Fake runner canceled\nFAILED',
-                    model: 'fake',
-                    cli,
-                    failureClass: 'infra',
-                    metadata: { source: 'fake-runner', canceled: true },
-                };
-            }
-            return (result ?? {
-                result: [
-                    'Fake runner completed',
-                    '',
-                    '```wake-result',
-                    '{ "status": "DONE" }',
-                    '```',
-                    'DONE',
-                ].join('\n'),
-                model: 'fake',
-                cli,
-                session_id: 'fake-session-1',
-                metadata: {
-                    source: 'fake-runner',
-                },
-            });
-        },
-    };
-    return runner;
-}

package/dist/src/adapters/fake/fake-ticketing-system.js

@@ -1,185 +0,0 @@
-import { access } from 'node:fs/promises';
-import { LABELS_REQUESTED_EVENT } from '../../domain/event-types.js';
-import { buildResourceUri } from '../../domain/resource-uri.js';
-import { createEventEnvelope, createUnkeyedEventEnvelope } from '../../lib/event-log.js';
-import { readJsonFile } from '../../lib/json-file.js';
-const fakeSource = 'fake-ticketing';
-function normalizeIssueEvents(issue, nowIso) {
-    const sourceUrl = `https://example.test/${issue.repo}/issues/${issue.number}`;
-    // The source names the *resource* it saw, never the work item: the resolver
-    // in tick-runner turns this into the canonical workItemKey (spec D1).
-    const resourceUri = buildResourceUri(fakeSource, 'issue', `${issue.repo}#${issue.number}`);
-    return [
-        createUnkeyedEventEnvelope({
-            eventId: `fake-issue-${issue.repo}-${issue.number}`,
-            streamScope: 'global-intake',
-            direction: 'inbound',
-            sourceSystem: 'fake-ticketing',
-            sourceEventType: 'fake.issue.upsert',
-            sourceRefs: {
-                repo: issue.repo,
-                issueNumber: issue.number,
-                sourceUrl,
-                resourceUri,
-            },
-            occurredAt: nowIso,
-            ingestedAt: nowIso,
-            trigger: 'immediate',
-            payload: {
-                issue: {
-                    repo: issue.repo,
-                    number: issue.number,
-                    title: issue.title,
-                    body: issue.body,
-                    labels: issue.labels,
-                    assignees: [],
-                    state: 'open',
-                    url: sourceUrl,
-                    createdAt: nowIso,
-                    updatedAt: nowIso,
-                },
-            },
-            raw: {
-                title: issue.title,
-                body: issue.body,
-                labels: issue.labels,
-            },
-        }),
-        ...issue.comments.map((comment, index) => createUnkeyedEventEnvelope({
-            eventId: `fake-comment-${issue.repo}-${issue.number}-${comment.id}-${index}`,
-            streamScope: 'work-item',
-            direction: 'inbound',
-            sourceSystem: 'fake-ticketing',
-            sourceEventType: 'fake.issue.comment.created',
-            sourceRefs: {
-                repo: issue.repo,
-                issueNumber: issue.number,
-                commentId: comment.id,
-                sourceUrl,
-                resourceUri,
-            },
-            occurredAt: nowIso,
-            ingestedAt: nowIso,
-            trigger: 'context-only',
-            payload: {
-                comment: {
-                    ...comment,
-                    createdAt: nowIso,
-                    updatedAt: nowIso,
-                },
-            },
-            derivedHints: {
-                botAuthoredComment: false,
-            },
-        })),
-    ];
-}
-export function createFakeTicketingSystem(options) {
-    return {
-        async pollEvents(_input) {
-            const nowIso = (options.now ?? (() => new Date()))().toISOString();
-            return options.tickets.flatMap((issue) => normalizeIssueEvents(issue, nowIso));
-        },
-        async deliverIntent(input) {
-            const publishedAt = (options.now ?? (() => new Date()))().toISOString();
-            if (input.event.sourceEventType === LABELS_REQUESTED_EVENT) {
-                const ticket = options.tickets.find((issue) => issue.repo === input.event.sourceRefs.repo &&
-                    issue.number === input.event.sourceRefs.issueNumber);
-                const currentLabels = ticket?.labels ?? [];
-                const statusLabel = typeof input.event.payload.statusLabel === 'string'
-                    ? input.event.payload.statusLabel
-                    : undefined;
-                const stageLabel = typeof input.event.payload.stageLabel === 'string'
-                    ? input.event.payload.stageLabel
-                    : undefined;
-                const workflowLabel = typeof input.event.payload.workflowLabel === 'string'
-                    ? input.event.payload.workflowLabel
-                    : undefined;
-                const frozenLabel = typeof input.event.payload.frozenLabel === 'string'
-                    ? input.event.payload.frozenLabel
-                    : undefined;
-                const scheduledLabel = typeof input.event.payload.scheduledLabel === 'string'
-                    ? input.event.payload.scheduledLabel
-                    : undefined;
-                const labels = [
-                    ...currentLabels.filter((label) => !label.startsWith('wake:status.') &&
-                        !label.startsWith('wake:stage.') &&
-                        !label.startsWith('wake:workflow.') &&
-                        label !== 'wake:frozen' &&
-                        label !== 'wake:scheduled-workflow'),
-                    ...(statusLabel === undefined
-                        ? currentLabels.filter((label) => label.startsWith('wake:status.'))
-                        : [statusLabel]),
-                    ...(stageLabel === undefined
-                        ? currentLabels.filter((label) => label.startsWith('wake:stage.'))
-                        : [stageLabel]),
-                    ...(workflowLabel === undefined
-                        ? currentLabels.filter((label) => label.startsWith('wake:workflow.'))
-                        : [workflowLabel]),
-                    ...(frozenLabel === undefined ? [] : [frozenLabel]),
-                    ...(scheduledLabel === undefined ? [] : [scheduledLabel]),
-                ];
-                return [
-                    createEventEnvelope({
-                        eventId: `${input.event.eventId}-labels-updated`,
-                        workItemKey: input.event.workItemKey,
-                        streamScope: 'work-item',
-                        direction: 'outbound',
-                        sourceSystem: 'fake-ticketing',
-                        sourceEventType: 'ticket.labels.updated',
-                        sourceRefs: {
-                            ...input.event.sourceRefs,
-                            sink: 'fake-ticketing',
-                        },
-                        occurredAt: publishedAt,
-                        ingestedAt: publishedAt,
-                        trigger: 'context-only',
-                        payload: {
-                            intentEventId: input.event.eventId,
-                            idempotencyKey: input.event.payload.idempotencyKey,
-                            deliveryState: 'CONFIRMED',
-                            labels,
-                        },
-                    }),
-                ];
-            }
-            const commentId = `${input.event.eventId}-comment`;
-            return [
-                createEventEnvelope({
-                    eventId: `${input.event.eventId}-delivery`,
-                    workItemKey: input.event.workItemKey,
-                    streamScope: 'work-item',
-                    direction: 'outbound',
-                    sourceSystem: 'fake-ticketing',
-                    sourceEventType: 'ticket.reply.published',
-                    sourceRefs: {
-                        ...input.event.sourceRefs,
-                        commentId,
-                        sink: 'fake-ticketing',
-                    },
-                    occurredAt: publishedAt,
-                    ingestedAt: publishedAt,
-                    trigger: 'context-only',
-                    payload: {
-                        intentEventId: input.event.eventId,
-                        idempotencyKey: input.event.payload.idempotencyKey,
-                        deliveryState: 'CONFIRMED',
-                        providerId: commentId,
-                        kind: input.event.payload.kind,
-                        body: input.event.payload.body,
-                    },
-                }),
-            ];
-        },
-    };
-}
-export async function createFileBackedFakeTicketingSystem(options) {
-    try {
-        await access(options.fixturePath);
-    }
-    catch {
-        return createFakeTicketingSystem(options.now === undefined ? { tickets: [] } : { tickets: [], now: options.now });
-    }
-    const raw = await readJsonFile(options.fixturePath);
-    return createFakeTicketingSystem(options.now === undefined ? { tickets: raw } : { tickets: raw, now: options.now });
-}

package/dist/src/adapters/fake/fake-workspace-manager.js

@@ -1,81 +0,0 @@
-import { mkdir, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-export class FakeWorkspaceValidationError extends Error {
-    failureSource = 'wake-workspace-validation';
-    constructor(message) {
-        super(message);
-        this.name = 'FakeWorkspaceValidationError';
-    }
-}
-export function createFakeWorkspaceManager(root, options = {}) {
-    function validation(input) {
-        if (options.failValidation === true) {
-            throw new FakeWorkspaceValidationError('fake workspace validation failed');
-        }
-        return {
-            repo: input.repo,
-            expectedBranch: input.branch,
-            actualBranch: input.branch,
-            expectedRemoteUrl: input.remoteUrl,
-            actualRemoteUrl: input.remoteUrl,
-            baseRevision: 'fake-base',
-            headRevision: 'fake-head',
-            clean: true,
-            remoteAvailable: true,
-        };
-    }
-    return {
-        async prepareWorkspace({ workId, repo, issueNumber, }) {
-            // Keyed on the work id, symmetrically with the real git-backed manager.
-            const workspacePath = join(root, workId);
-            await mkdir(workspacePath, { recursive: true });
-            return {
-                workspacePath,
-                mergeConflictDetected: false,
-                validation: validation({
-                    repo,
-                    branch: `wake/issue-${issueNumber}`,
-                    remoteUrl: `https://github.com/${repo}.git`,
-                }),
-            };
-        },
-        async prepareReadOnlyClone({ repo }) {
-            const workspacePath = join(root, repo.replace(/[\\/]/g, '__'), 'canonical');
-            await mkdir(workspacePath, { recursive: true });
-            return {
-                workspacePath,
-                validation: validation({
-                    repo,
-                    branch: 'main',
-                    remoteUrl: `https://github.com/${repo}.git`,
-                }),
-            };
-        },
-        async recordWorkspaceBookkeeping() {
-            if (options.failBookkeeping === true) {
-                throw new Error('fake workspace bookkeeping failed');
-            }
-            return {
-                branch: 'wake/issue-fake',
-                headRevision: 'fake-head-after-run',
-                diffSummary: '',
-                untrackedFiles: [],
-                unpushedCommits: {
-                    hasUpstream: false,
-                    count: 0,
-                    commits: [],
-                },
-            };
-        },
-        async cleanupWorkspace({ workspacePath }) {
-            // Retry on Windows EBUSY/EPERM (AV/indexer holding a brief handle) to
-            // match the real git-backed workspace manager's cleanup behavior.
-            await rm(workspacePath, {
-                recursive: true,
-                force: true,
-                maxRetries: 5,
-                retryDelay: 200,
-            });
-        },
-    };
-}

package/dist/src/adapters/fs/resource-index.js

@@ -1,126 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { z } from 'zod';
-import { acquireFileLock } from '../../lib/lock.js';
-import { readJsonFile, writeJsonFile } from '../../lib/json-file.js';
-import { isMissingPathError, stateHealthIssue, StateHealthError, } from '../../lib/state-health.js';
-const shardContentsSchema = z.record(z.string(), z.string());
-/**
- * Addresses a resource uri to one of 256 shards.
- *
- * The uri is hashed as opaque bytes — this never splits on ':' and never
- * inspects the locator, which is what lets core shard without violating
- * "core compares uris for equality only" (ADR 0001 §1). Hashing also yields
- * a filename-safe shard name for free; the raw uri contains '/', '#' and ':'
- * and could not be a filename without escaping.
- */
-export function shardFor(resourceUri) {
-    return createHash('sha256').update(resourceUri, 'utf8').digest('hex').slice(0, 2);
-}
-async function readShard(file) {
-    try {
-        return shardContentsSchema.parse(await readJsonFile(file));
-    }
-    catch (error) {
-        if (isMissingPathError(error)) {
-            return {};
-        }
-        throw new StateHealthError([
-            stateHealthIssue({
-                surface: 'reverse-index',
-                kind: 'corrupted',
-                path: file,
-                message: error instanceof Error ? error.message : String(error),
-            }),
-        ]);
-    }
-}
-export async function validateResourceIndex(paths) {
-    const issues = [];
-    const entries = await readdir(paths.resourceIndexRoot, { withFileTypes: true }).catch((error) => {
-        if (isMissingPathError(error)) {
-            return [];
-        }
-        throw error;
-    });
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith('.json')) {
-            continue;
-        }
-        const file = join(paths.resourceIndexRoot, entry.name);
-        try {
-            shardContentsSchema.parse(await readJsonFile(file));
-        }
-        catch (error) {
-            issues.push(stateHealthIssue({
-                surface: 'reverse-index',
-                kind: 'corrupted',
-                path: file,
-                message: error instanceof Error ? error.message : String(error),
-            }));
-        }
-    }
-    return issues;
-}
-// acquireFileLock is a non-blocking try-lock: when contended it returns
-// { acquired: false } immediately rather than waiting. register/retract have
-// no sensible "try again later" behavior at their call sites — skipping the
-// write here is exactly the silent-drop corruption this index exists to
-// avoid — so withShardLock must retry until it actually holds the lock.
-// staleAfterMs (60s) already reclaims a lock from a crashed holder, so this
-// bound only needs to outlast normal contention between live processes, not
-// a dead one.
-const SHARD_LOCK_RETRY_INTERVAL_MS = 25;
-const SHARD_LOCK_RETRY_BUDGET_MS = 10_000;
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-export function createResourceIndex({ paths }) {
-    async function withShardLock(shard, fn) {
-        const lockPath = `${paths.resourceIndexShardFile(shard)}.lock`;
-        const deadline = Date.now() + SHARD_LOCK_RETRY_BUDGET_MS;
-        for (;;) {
-            const lock = await acquireFileLock(lockPath, { staleAfterMs: 60_000 });
-            if (lock.acquired) {
-                try {
-                    return await fn();
-                }
-                finally {
-                    await lock.release();
-                }
-            }
-            if (Date.now() >= deadline) {
-                throw new Error(`resource-index: timed out after ${SHARD_LOCK_RETRY_BUDGET_MS}ms waiting for lock on shard '${shard}' (${lockPath})`);
-            }
-            await delay(SHARD_LOCK_RETRY_INTERVAL_MS);
-        }
-    }
-    return {
-        async resolve(resourceUri) {
-            const shard = await readShard(paths.resourceIndexShardFile(shardFor(resourceUri)));
-            return shard[resourceUri];
-        },
-        async register(resourceUri, workItemKey) {
-            const shard = shardFor(resourceUri);
-            const file = paths.resourceIndexShardFile(shard);
-            await withShardLock(shard, async () => {
-                const contents = await readShard(file);
-                contents[resourceUri] = workItemKey;
-                await writeJsonFile(file, contents);
-            });
-        },
-        async retract(resourceUri) {
-            const shard = shardFor(resourceUri);
-            const file = paths.resourceIndexShardFile(shard);
-            await withShardLock(shard, async () => {
-                const contents = await readShard(file);
-                if (!(resourceUri in contents)) {
-                    return;
-                }
-                delete contents[resourceUri];
-                await writeJsonFile(file, contents);
-            });
-        },
-    };
-}

package/dist/src/adapters/fs/self-update-ledger.js

@@ -1,17 +0,0 @@
-import { readJsonFile, writeJsonFile } from '../../lib/json-file.js';
-const EMPTY_LEDGER = {
-    lastAppliedTag: null,
-    lastKnownGoodTag: null,
-    badTags: [],
-};
-export async function readSelfUpdateLedger(path) {
-    try {
-        return await readJsonFile(path);
-    }
-    catch {
-        return EMPTY_LEDGER;
-    }
-}
-export async function writeSelfUpdateLedger(path, ledger) {
-    await writeJsonFile(path, ledger);
-}