@atolis-hq/wake 0.1.12 → 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/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.12+g6a4753f";
+export const wakeVersion = "0.1.13+g386bfbe";

package/package.json

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