@atolis-hq/wake 0.1.0

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

@@ -0,0 +1,166 @@
+import { access } from 'node:fs/promises';
+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 === 'wake.labels.requested') {
+                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 labels = [
+                    ...currentLabels.filter((label) => !label.startsWith('wake:status.') &&
+                        !label.startsWith('wake:stage.')),
+                    ...(statusLabel === undefined
+                        ? currentLabels.filter((label) => label.startsWith('wake:status.'))
+                        : [statusLabel]),
+                    ...(stageLabel === undefined
+                        ? currentLabels.filter((label) => label.startsWith('wake:stage.'))
+                        : [stageLabel]),
+                ];
+                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,
+                            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,
+                        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

@@ -0,0 +1,27 @@
+import { mkdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+export function createFakeWorkspaceManager(root) {
+    return {
+        async prepareWorkspace({ workId, }) {
+            // 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 };
+        },
+        async prepareReadOnlyClone({ repo }) {
+            const workspacePath = join(root, repo.replace(/[\\/]/g, '__'), 'canonical');
+            await mkdir(workspacePath, { recursive: true });
+            return { workspacePath };
+        },
+        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

@@ -0,0 +1,84 @@
+import { createHash } from 'node:crypto';
+import { acquireFileLock } from '../../lib/lock.js';
+import { readJsonFile, writeJsonFile } from '../../lib/json-file.js';
+/**
+ * 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 await readJsonFile(file);
+    }
+    catch {
+        return {};
+    }
+}
+// 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

@@ -0,0 +1,17 @@
+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);
+}

package/dist/src/adapters/fs/state-store.js

@@ -0,0 +1,364 @@
+import { access, appendFile, mkdir, readFile, readdir, rename } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { parseEventEnvelope, parseIssueStateRecord, parseLedger, parseRunRecord, parseSourceStateRecord, parseWakeConfig, } from '../../domain/schema.js';
+import { isTerminalStage } from '../../domain/stages.js';
+import { appendJsonLine, readJsonFile, writeJsonFile } from '../../lib/json-file.js';
+import { createWakePaths } from '../../lib/paths.js';
+async function readIssueStateFile(file) {
+    try {
+        return parseIssueStateRecord(await readJsonFile(file));
+    }
+    catch {
+        return null;
+    }
+}
+async function readRunRecordFile(file) {
+    try {
+        return parseRunRecord(await readJsonFile(file));
+    }
+    catch {
+        return null;
+    }
+}
+async function readEventFile(file) {
+    try {
+        const raw = await readFile(file, 'utf8');
+        const envelopes = [];
+        for (const line of raw.split('\n')) {
+            const trimmed = line.trim();
+            if (trimmed.length === 0) {
+                continue;
+            }
+            const parsed = JSON.parse(trimmed);
+            if (parsed !== null &&
+                typeof parsed === 'object' &&
+                'eventId' in parsed &&
+                'sourceEventType' in parsed) {
+                envelopes.push(parseEventEnvelope(parsed));
+            }
+        }
+        return envelopes;
+    }
+    catch {
+        return [];
+    }
+}
+function issueArchiveAgeDate(item) {
+    const stageChangedAt = item.wake.stageHistory.at(-1)?.changedAt;
+    return [stageChangedAt, item.wake.syncedAt, item.issue.updatedAt]
+        .filter((value) => value !== undefined)
+        .sort()
+        .at(-1) ?? item.wake.syncedAt;
+}
+function shouldArchiveIssueState(item, options) {
+    if (!isTerminalStage(item.wake.stage) && item.issue.state !== 'closed') {
+        return false;
+    }
+    const ageMs = options.now.getTime() - Date.parse(issueArchiveAgeDate(item));
+    return Number.isFinite(ageMs) && ageMs > options.archiveFreshnessDays * 24 * 60 * 60 * 1000;
+}
+export async function listRunRecords(wakeRoot) {
+    const runsRoot = join(wakeRoot, 'runs');
+    const recordsById = new Map();
+    try {
+        const files = (await readdir(runsRoot))
+            .filter((file) => file.endsWith('.json'))
+            .sort();
+        for (const file of files) {
+            const record = await readRunRecordFile(join(runsRoot, file));
+            if (record !== null) {
+                recordsById.set(record.runId, record);
+            }
+        }
+    }
+    catch {
+        // The date-bucketed layout below may still exist.
+    }
+    try {
+        const byDateRoot = join(runsRoot, 'by-date');
+        const dateDirs = (await readdir(byDateRoot)).sort();
+        for (const dateDir of dateDirs) {
+            const files = (await readdir(join(byDateRoot, dateDir)).catch(() => []))
+                .filter((file) => file.endsWith('.json'))
+                .sort();
+            for (const file of files) {
+                const record = await readRunRecordFile(join(byDateRoot, dateDir, file));
+                if (record !== null) {
+                    recordsById.set(record.runId, record);
+                }
+            }
+        }
+    }
+    catch {
+        // Old wake homes only have root-level run files.
+    }
+    return [...recordsById.values()].sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+}
+async function listRunRecordsForDate(wakeRoot, date) {
+    const runsRoot = join(wakeRoot, 'runs');
+    const recordsById = new Map();
+    const bucketFiles = (await readdir(join(runsRoot, 'by-date', date)).catch(() => []))
+        .filter((file) => file.endsWith('.json'))
+        .sort();
+    for (const file of bucketFiles) {
+        const record = await readRunRecordFile(join(runsRoot, 'by-date', date, file));
+        if (record !== null) {
+            recordsById.set(record.runId, record);
+        }
+    }
+    if (recordsById.size === 0) {
+        const legacyFiles = (await readdir(runsRoot).catch(() => []))
+            .filter((file) => file.endsWith('.json'))
+            .sort();
+        for (const file of legacyFiles) {
+            const record = await readRunRecordFile(join(runsRoot, file));
+            if (record?.startedAt.slice(0, 10) === date) {
+                recordsById.set(record.runId, record);
+            }
+        }
+    }
+    return [...recordsById.values()].sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+}
+async function listRecentRunRecords(wakeRoot, limit) {
+    const runsRoot = join(wakeRoot, 'runs');
+    const recordsById = new Map();
+    const dateDirs = (await readdir(join(runsRoot, 'by-date')).catch(() => []))
+        .sort()
+        .reverse();
+    for (const dateDir of dateDirs) {
+        const records = await listRunRecordsForDate(wakeRoot, dateDir);
+        for (const record of records.reverse()) {
+            recordsById.set(record.runId, record);
+            if (recordsById.size >= limit) {
+                return [...recordsById.values()].sort((left, right) => right.startedAt.localeCompare(left.startedAt));
+            }
+        }
+    }
+    if (recordsById.size === 0) {
+        return (await listRunRecords(wakeRoot))
+            .sort((left, right) => right.startedAt.localeCompare(left.startedAt))
+            .slice(0, limit);
+    }
+    return [...recordsById.values()].sort((left, right) => right.startedAt.localeCompare(left.startedAt));
+}
+export function createStateStore({ wakeRoot }) {
+    const paths = createWakePaths(wakeRoot);
+    return {
+        paths,
+        async ensureWakeRoot() {
+            await mkdir(wakeRoot, { recursive: true });
+        },
+        async writeConfig(record) {
+            const parsed = parseWakeConfig(record);
+            await writeJsonFile(paths.configFile, parsed);
+            return parsed;
+        },
+        async writeLedger(record) {
+            const parsed = parseLedger(record);
+            await writeJsonFile(paths.ledgerFile, parsed);
+            return parsed;
+        },
+        async readLedger() {
+            try {
+                return parseLedger(await readJsonFile(paths.ledgerFile));
+            }
+            catch {
+                return null;
+            }
+        },
+        async writeIssueState(record) {
+            const parsed = parseIssueStateRecord(record);
+            await writeJsonFile(paths.workItemStateFile(parsed.workItemKey), parsed);
+            return parsed;
+        },
+        async readIssueState(workId) {
+            return ((await readIssueStateFile(paths.workItemStateFile(workId))) ??
+                (await readIssueStateFile(paths.archivedWorkItemStateFile(workId))));
+        },
+        async writeRunRecord(record) {
+            const parsed = parseRunRecord(record);
+            await writeJsonFile(paths.runFile(parsed.runId), parsed);
+            await writeJsonFile(paths.runDateFile(parsed.startedAt.slice(0, 10), parsed.runId), parsed);
+            return parsed;
+        },
+        async writeSourceState(record) {
+            const parsed = parseSourceStateRecord(record);
+            await writeJsonFile(paths.sourceStateFile(parsed.source, parsed.key), parsed);
+            return parsed;
+        },
+        async readRunRecord(runId) {
+            try {
+                return parseRunRecord(await readJsonFile(paths.runFile(runId)));
+            }
+            catch {
+                const recent = await listRecentRunRecords(wakeRoot, 500);
+                return recent.find((record) => record.runId === runId) ?? null;
+            }
+        },
+        async listRunRecords() {
+            return listRunRecords(wakeRoot);
+        },
+        async listRunRecordsForDate(date) {
+            return listRunRecordsForDate(wakeRoot, date);
+        },
+        async listRecentRunRecords(limit = 10) {
+            return listRecentRunRecords(wakeRoot, limit);
+        },
+        async readSourceState(source, key) {
+            try {
+                return parseSourceStateRecord(await readJsonFile(paths.sourceStateFile(source, key)));
+            }
+            catch {
+                return null;
+            }
+        },
+        async appendEventEnvelope(record) {
+            const parsed = parseEventEnvelope(record);
+            const existing = await this.readEventEnvelope(parsed.eventId);
+            if (existing !== null) {
+                return existing;
+            }
+            await appendJsonLine(paths.eventFile(parsed.ingestedAt.slice(0, 10)), parsed);
+            await writeJsonFile(paths.eventEnvelopeFile(parsed.eventId), parsed);
+            return parsed;
+        },
+        async readEventEnvelope(eventId) {
+            try {
+                return parseEventEnvelope(await readJsonFile(paths.eventEnvelopeFile(eventId)));
+            }
+            catch {
+                return null;
+            }
+        },
+        async listIssueStates(options = {}) {
+            const stateRoot = join(wakeRoot, 'state');
+            try {
+                const items = [];
+                const includeArchived = options.includeArchived ?? false;
+                const archiveOptions = options.archiveFreshnessDays === undefined
+                    ? null
+                    : {
+                        archiveFreshnessDays: options.archiveFreshnessDays,
+                        now: options.now ?? new Date(),
+                    };
+                // state/ is flat: state/<workId>.json, plus state/archive/ and the
+                // reverse index's own state/index/ shards. Only those two subdirectories
+                // exist, and index/ holds `{ resourceUri: workItemKey }` maps that are
+                // not projections at all — skip it rather than parse-and-discard.
+                const visit = async (dir, isArchive) => {
+                    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+                    for (const entry of entries) {
+                        if (entry.isDirectory()) {
+                            if (entry.name === 'index') {
+                                continue;
+                            }
+                            if (entry.name === 'archive' && includeArchived) {
+                                await visit(join(dir, entry.name), true);
+                            }
+                            continue;
+                        }
+                        if (!entry.isFile() || !entry.name.endsWith('.json')) {
+                            continue;
+                        }
+                        const file = join(dir, entry.name);
+                        const record = await readIssueStateFile(file);
+                        if (record === null) {
+                            continue;
+                        }
+                        if (archiveOptions !== null && !isArchive && shouldArchiveIssueState(record, archiveOptions)) {
+                            const archivePath = paths.archivedWorkItemStateFile(record.workItemKey);
+                            await mkdir(dirname(archivePath), { recursive: true });
+                            await rename(file, archivePath).catch(() => undefined);
+                            continue;
+                        }
+                        items.push(record);
+                    }
+                };
+                await visit(stateRoot, false);
+                const byWorkItemKey = new Map();
+                for (const item of items) {
+                    byWorkItemKey.set(item.workItemKey, item);
+                }
+                return [...byWorkItemKey.values()].sort((left, right) => left.workItemKey.localeCompare(right.workItemKey));
+            }
+            catch {
+                return [];
+            }
+        },
+        async listEventEnvelopes() {
+            const eventsRoot = join(wakeRoot, 'events');
+            try {
+                const files = (await readdir(eventsRoot)).sort();
+                const envelopes = [];
+                for (const file of files) {
+                    envelopes.push(...await readEventFile(join(eventsRoot, file)));
+                }
+                return envelopes;
+            }
+            catch {
+                return [];
+            }
+        },
+        async listRecentEventEnvelopes(filter = {}) {
+            const limit = filter.limit ?? 200;
+            const eventsRoot = join(wakeRoot, 'events');
+            const files = (await readdir(eventsRoot).catch(() => []))
+                .filter((file) => file.endsWith('.jsonl'))
+                .sort()
+                .reverse();
+            const results = [];
+            for (const file of files) {
+                const events = await readEventFile(join(eventsRoot, file));
+                for (const event of events.reverse()) {
+                    if (filter.workItemKey !== undefined && event.workItemKey !== filter.workItemKey) {
+                        continue;
+                    }
+                    if (filter.direction !== undefined && event.direction !== filter.direction) {
+                        continue;
+                    }
+                    if (filter.type !== undefined && event.sourceEventType !== filter.type) {
+                        continue;
+                    }
+                    results.push(event);
+                    if (results.length >= limit) {
+                        return results;
+                    }
+                }
+            }
+            return results;
+        },
+        async listEventEnvelopesForWorkItem(workItemKey, limit = 10) {
+            const projection = await this.readIssueState(workItemKey);
+            const recentEventIds = projection?.wake.recentEventIds.slice(-limit) ?? [];
+            const envelopes = [];
+            for (const eventId of recentEventIds) {
+                const envelope = await this.readEventEnvelope(eventId);
+                if (envelope?.workItemKey === workItemKey) {
+                    envelopes.push(envelope);
+                }
+            }
+            return envelopes;
+        },
+        async appendLog(date, line) {
+            await mkdir(wakeRoot, { recursive: true });
+            await appendFile(paths.logFile(date), `${line}\n`, 'utf8');
+        },
+        // Only the manual pause file is a hard stop on the whole loop. Quota
+        // pauses are now per-runner (ledger.runners, #67): a paused runner skips
+        // itself via routing fallback inside a tick, but the tick loop itself must
+        // keep running so polling, delivery retries, and other tiers still make
+        // progress while one runner is paused.
+        async isPaused(_now = new Date()) {
+            try {
+                await access(paths.pauseFile);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        async readEventLog(date) {
+            return readFile(paths.eventFile(date), 'utf8');
+        },
+    };
+}