@atolis-hq/wake 0.1.11 → 0.1.13

package/dist/src/core/workspace-cleanup.js

@@ -0,0 +1,77 @@
+import { rm } from 'node:fs/promises';
+import { isAbsolute, join, relative } from 'node:path';
+import { createEventEnvelope } from '../lib/event-log.js';
+// Cleans up per-issue workspaces (and, unless retained, transcripts) once the
+// originating issue is closed. A cleanup failure is recorded as an event and
+// skipped rather than aborting the sweep.
+export function createWorkspaceCleanup(deps) {
+    function eventStampNow() {
+        return deps.clock.now().toISOString();
+    }
+    function isPerIssueWorkspacePath(workspacePath) {
+        const workspacesRoot = join(deps.config.paths.wakeRoot, 'workspaces');
+        const rel = relative(workspacesRoot, workspacePath);
+        return !rel.startsWith('..') && !isAbsolute(rel) && rel.length > 0;
+    }
+    async function cleanupClosedIssueWorkspaces(projections) {
+        for (const projection of projections) {
+            const { workspacePath } = projection.wake;
+            if (projection.issue.state === 'closed' &&
+                workspacePath !== undefined &&
+                isPerIssueWorkspacePath(workspacePath)) {
+                try {
+                    await deps.workspaceManager.cleanupWorkspace({ workspacePath });
+                    if (!deps.config.transcripts.retainAfterWorkspaceCleanup) {
+                        await rm(deps.stateStore.paths.transcriptWorkDir(projection.workItemKey), {
+                            recursive: true,
+                            force: true,
+                        });
+                    }
+                }
+                catch (error) {
+                    const failedAt = eventStampNow();
+                    await deps.stateStore.appendEventEnvelope(createEventEnvelope({
+                        eventId: `workspace-cleanup-failed-${projection.issue.repo.replace(/[^a-z0-9]+/gi, '-')}-${projection.issue.number}`,
+                        workItemKey: projection.workItemKey,
+                        streamScope: 'work-item',
+                        direction: 'internal',
+                        sourceSystem: 'wake',
+                        sourceEventType: 'wake.workspace.cleanup-failed',
+                        sourceRefs: {
+                            repo: projection.issue.repo,
+                            issueNumber: projection.issue.number,
+                        },
+                        occurredAt: failedAt,
+                        ingestedAt: failedAt,
+                        trigger: 'context-only',
+                        payload: {
+                            workspacePath,
+                            error: error instanceof Error ? error.message : String(error),
+                        },
+                    }));
+                    continue;
+                }
+                const cleanedAt = eventStampNow();
+                const cleanupEvent = createEventEnvelope({
+                    eventId: `workspace-cleaned-${projection.issue.repo.replace(/[^a-z0-9]+/gi, '-')}-${projection.issue.number}-${deps.clock.now().getTime()}`,
+                    workItemKey: projection.workItemKey,
+                    streamScope: 'work-item',
+                    direction: 'internal',
+                    sourceSystem: 'wake',
+                    sourceEventType: 'wake.workspace.cleaned',
+                    sourceRefs: {
+                        repo: projection.issue.repo,
+                        issueNumber: projection.issue.number,
+                    },
+                    occurredAt: cleanedAt,
+                    ingestedAt: cleanedAt,
+                    trigger: 'immediate',
+                    payload: { workspacePath },
+                });
+                await deps.stateStore.appendEventEnvelope(cleanupEvent);
+                await deps.projectionUpdater.rebuildFromEvents([cleanupEvent]);
+            }
+        }
+    }
+    return { cleanupClosedIssueWorkspaces };
+}

package/dist/src/domain/schema.js

@@ -316,6 +316,26 @@ const workflowDefinitionSchema = z.object({
     entryStage: identifierSchema.optional(),
     stages: z.record(identifierSchema, workflowStageSchema),
 });
+const workflowSelectorMatchSchema = z
+    .object({
+    kind: z.string().min(1).optional(),
+    sourceEventType: z.string().min(1).optional(),
+    repo: z.string().min(1).optional(),
+    requiredLabels: z.array(z.string()).default([]),
+    ignoredLabels: z.array(z.string()).default([]),
+    requiredAssignees: z.array(z.string()).default([]),
+    requiredAuthors: z.array(z.string()).default([]),
+})
+    .default({
+    requiredLabels: [],
+    ignoredLabels: [],
+    requiredAssignees: [],
+    requiredAuthors: [],
+});
+const workflowSelectorSchema = z.object({
+    workflow: identifierSchema,
+    match: workflowSelectorMatchSchema,
+});
 function defaultPromptsRoot() {
     const sourceDir = dirname(fileURLToPath(import.meta.url));
     for (const candidate of [
@@ -515,6 +535,7 @@ export const wakeConfigSchema = z
             },
         },
     }),
+    workflowSelectors: z.array(workflowSelectorSchema).default([]),
     commands: z.record(identifierSchema, customCommandSchema).default({
         ask: {
             action: 'ask',
@@ -707,6 +728,15 @@ export const wakeConfigSchema = z
             });
         }
     }
+    for (const [index, selector] of config.workflowSelectors.entries()) {
+        if (config.workflows[selector.workflow] === undefined) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['workflowSelectors', index, 'workflow'],
+                message: `Workflow selector targets unknown workflow "${selector.workflow}".`,
+            });
+        }
+    }
     for (const [commandName, command] of commandEntries) {
         if (reservedCommandNames.includes(commandName.toLowerCase())) {
             ctx.addIssue({

package/dist/src/domain/workflows.js

@@ -37,6 +37,75 @@ export function workflowNameForProjection(projection, config) {
     const context = projection.context;
     return typeof context.workflow === 'string' ? context.workflow : defaultWorkflowName(config);
 }
+function stringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === 'string')
+        : [];
+}
+function repoFromResourceUri(resourceUri) {
+    if (resourceUri === undefined) {
+        return undefined;
+    }
+    const [, , rest] = resourceUri.split(':', 3);
+    return rest?.split('#')[0];
+}
+export function workflowSelectorInputFromEvent(event) {
+    const resourceUri = event.sourceRefs.resourceUri ?? event.sourceRefs.parentResourceUri;
+    const kind = resourceUri?.split(':')[1];
+    const ticket = (event.payload.ticket ?? event.payload.issue);
+    const pr = event.payload.pr;
+    const repo = (typeof ticket?.repo === 'string' ? ticket.repo : undefined) ??
+        event.sourceRefs.repo ??
+        repoFromResourceUri(resourceUri);
+    return {
+        ...(kind === undefined ? {} : { kind }),
+        sourceEventType: event.sourceEventType,
+        ...(repo === undefined ? {} : { repo }),
+        labels: stringArray(ticket?.labels),
+        assignees: stringArray(ticket?.assignees),
+        ...(typeof pr?.author === 'string' ? { author: pr.author } : {}),
+    };
+}
+function labelsAndAssigneesMatch(input) {
+    const labels = new Set(input.labels);
+    const assignees = new Set(input.assignees);
+    if (input.requiredLabels.some((label) => !labels.has(label))) {
+        return false;
+    }
+    if (input.ignoredLabels.some((label) => labels.has(label))) {
+        return false;
+    }
+    if (input.requiredAssignees.length > 0 &&
+        !input.requiredAssignees.some((login) => assignees.has(login))) {
+        return false;
+    }
+    return true;
+}
+function selectorMatches(selector, input) {
+    const match = selector.match;
+    if (match.kind !== undefined && match.kind !== input.kind) {
+        return false;
+    }
+    if (match.sourceEventType !== undefined && match.sourceEventType !== input.sourceEventType) {
+        return false;
+    }
+    if (match.repo !== undefined && match.repo !== input.repo) {
+        return false;
+    }
+    if (!labelsAndAssigneesMatch({ ...match, labels: input.labels, assignees: input.assignees })) {
+        return false;
+    }
+    if (match.requiredAuthors.length > 0 &&
+        (input.author === undefined || !match.requiredAuthors.includes(input.author))) {
+        return false;
+    }
+    return true;
+}
+export function selectWorkflowForEvent(event, config) {
+    const input = workflowSelectorInputFromEvent(event);
+    const selector = config.workflowSelectors.find((candidate) => selectorMatches(candidate, input));
+    return selector?.workflow ?? null;
+}
 export function configuredStageNames(workflow) {
     return Object.keys(workflow.stages);
 }

package/dist/src/lib/format.js

@@ -0,0 +1,41 @@
+// Presentation-only formatting for run summaries (cost, duration, tokens).
+// Pure functions with no dependency on tick state — kept in lib/ so they are
+// directly unit-testable rather than only reachable through a full run.
+export function extractTokenCount(tokenUsage) {
+    if (tokenUsage === undefined) {
+        return undefined;
+    }
+    // Cache tokens dominate real usage and were previously dropped from this
+    // total entirely, understating the reported figure by roughly an order of
+    // magnitude (#135).
+    return (tokenUsage.inputTokens +
+        tokenUsage.outputTokens +
+        (tokenUsage.cacheCreationInputTokens ?? 0) +
+        (tokenUsage.cacheReadInputTokens ?? 0));
+}
+export function formatCostUsd(costUsd) {
+    return `$${costUsd.toFixed(costUsd < 1 ? 4 : 2)}`;
+}
+export function formatDuration(startedAtStr, finishedAtStr) {
+    const startedAt = new Date(startedAtStr);
+    const finishedAt = new Date(finishedAtStr);
+    const durationMs = finishedAt.getTime() - startedAt.getTime();
+    if (durationMs < 0 || !isFinite(durationMs))
+        return undefined;
+    const totalSeconds = Math.floor(durationMs / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (minutes > 0) {
+        return `${minutes}m${seconds}s`;
+    }
+    return `${seconds}s`;
+}
+export function formatTokenCount(count) {
+    if (count >= 1000000) {
+        return `${(count / 1000000).toFixed(1)}M`;
+    }
+    if (count >= 1000) {
+        return `${(count / 1000).toFixed(0)}k`;
+    }
+    return String(count);
+}

package/dist/src/version.js

@@ -1 +1 @@
-export const wakeVersion = "0.1.11+gbbbf616";
+export const wakeVersion = "0.1.13+g386bfbe";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {