@jetcrab/pi-desk-usage 0.0.0-stage → 1.0.1-dev.9001

package/dist/usage-timeline.js

@@ -0,0 +1,342 @@
+import { usageBucketRanges, usageBucketIndex } from './l4-usage-calendar.js';
+const MAX_DISPLAY_POINTS = 800;
+const MAX_TRACK_ACTIVITIES = 160;
+const MINUTE_MS = 60_000;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+function emptyTotals() {
+    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+}
+function addTotals(target, value) {
+    target.input += value.input;
+    target.output += value.output;
+    target.cacheRead += value.cacheRead;
+    target.cacheWrite += value.cacheWrite;
+    target.cost += value.cost;
+}
+function promptTokens(event) {
+    return event.totals.input + event.totals.cacheRead + event.totals.cacheWrite;
+}
+function rate(point) {
+    return point.prompt > 0 ? point.cacheRead / point.prompt : 0;
+}
+function pointKey(point) {
+    return `${point.at}:${point.prompt}:${point.cacheRead}`;
+}
+function trimToTarget(points, target, mandatoryAt) {
+    if (points.length <= target)
+        return points;
+    const mandatory = points.filter((point, index) => index === 0 || index === points.length - 1 || mandatoryAt.has(point.at));
+    const mandatoryKeys = new Set(mandatory.map(pointKey));
+    const optional = points.filter((point) => !mandatoryKeys.has(pointKey(point)));
+    const remaining = Math.max(0, target - mandatory.length);
+    if (remaining === 0)
+        return mandatory.sort((left, right) => left.at - right.at);
+    const selected = [...mandatory];
+    const bucketCount = Math.max(1, Math.floor(remaining / 2));
+    const bucketSize = optional.length / bucketCount;
+    for (let bucket = 0; bucket < bucketCount; bucket += 1) {
+        const start = Math.floor(bucket * bucketSize);
+        const end = Math.max(start + 1, Math.floor((bucket + 1) * bucketSize));
+        const values = optional.slice(start, end);
+        if (values.length === 0)
+            continue;
+        const promptMin = values.reduce((best, point) => (point.prompt < best.prompt ? point : best));
+        const promptMax = values.reduce((best, point) => (point.prompt > best.prompt ? point : best));
+        const rateMin = values.reduce((best, point) => (rate(point) < rate(best) ? point : best));
+        const rateMax = values.reduce((best, point) => (rate(point) > rate(best) ? point : best));
+        for (const point of [promptMin, promptMax, rateMin, rateMax].sort((left, right) => left.at - right.at)) {
+            if (selected.length >= target)
+                break;
+            if (!selected.some((item) => pointKey(item) === pointKey(point)))
+                selected.push(point);
+        }
+    }
+    return selected.sort((left, right) => left.at - right.at);
+}
+function chooseBucketMs(duration) {
+    if (duration <= 2 * HOUR_MS)
+        return MINUTE_MS;
+    if (duration <= 10 * HOUR_MS)
+        return 5 * MINUTE_MS;
+    if (duration <= 30 * HOUR_MS)
+        return 15 * MINUTE_MS;
+    if (duration <= 60 * HOUR_MS)
+        return 30 * MINUTE_MS;
+    if (duration <= 5 * DAY_MS)
+        return HOUR_MS;
+    if (duration <= 15 * DAY_MS)
+        return 3 * HOUR_MS;
+    if (duration <= 30 * DAY_MS)
+        return 6 * HOUR_MS;
+    if (duration <= 90 * DAY_MS)
+        return 12 * HOUR_MS;
+    return DAY_MS;
+}
+function runIndex(runs, timestamp) {
+    if (runs.length <= 1)
+        return 0;
+    let result = 0;
+    for (let index = 1; index < runs.length; index += 1) {
+        if (timestamp < runs[index].startAt)
+            break;
+        result = index;
+    }
+    return result;
+}
+function inRange(timestamp, startAt, endAt) {
+    return timestamp >= startAt && timestamp < endAt;
+}
+function intersects(startAt, endAt, rangeStart, rangeEnd) {
+    return startAt < rangeEnd && (endAt === null || endAt >= rangeStart);
+}
+function contextStates(inputs) {
+    return inputs.map((input) => {
+        const calls = input.events
+            .filter((event) => event.kind === 'assistant' && promptTokens(event) > 0)
+            .map((event) => ({
+            timestamp: event.timestamp,
+            order: event.order,
+            prompt: promptTokens(event),
+            cacheRead: event.totals.cacheRead
+        }))
+            .sort((left, right) => left.timestamp - right.timestamp || left.order - right.order);
+        const markers = [...input.markers].sort((left, right) => left.timestamp - right.timestamp || left.order - right.order);
+        const segments = Array.from({ length: Math.max(1, input.kind === 'main' ? 1 : input.runs.length) }, () => []);
+        const mandatoryAt = new Set();
+        for (const call of calls) {
+            segments[input.kind === 'main' ? 0 : runIndex(input.runs, call.timestamp)].push({
+                at: call.timestamp,
+                prompt: call.prompt,
+                cacheRead: call.cacheRead
+            });
+        }
+        for (const marker of markers) {
+            const previous = [...calls].reverse().find((call) => call.timestamp < marker.timestamp);
+            const next = calls.find((call) => call.timestamp > marker.timestamp);
+            mandatoryAt.add(marker.timestamp);
+            if (previous)
+                mandatoryAt.add(previous.timestamp);
+            if (next) {
+                mandatoryAt.add(next.timestamp);
+                const segment = input.kind === 'main' ? 0 : runIndex(input.runs, marker.timestamp);
+                segments[segment].push({
+                    at: marker.timestamp,
+                    prompt: next.prompt,
+                    cacheRead: next.cacheRead
+                });
+            }
+        }
+        for (const segment of segments)
+            segment.sort((left, right) => left.at - right.at);
+        return {
+            input,
+            calls,
+            markers,
+            segments: segments.filter((segment) => segment.length > 0),
+            mandatoryAt
+        };
+    });
+}
+function sampledSources(states) {
+    const totalPoints = states.reduce((total, state) => total + state.segments.reduce((sum, segment) => sum + segment.length, 0), 0);
+    const sampled = totalPoints > MAX_DISPLAY_POINTS;
+    const ratio = sampled ? MAX_DISPLAY_POINTS / totalPoints : 1;
+    return {
+        sampled,
+        sources: states.map((state) => {
+            const pointCount = state.segments.reduce((sum, segment) => sum + segment.length, 0);
+            let remainingTarget = sampled
+                ? Math.max(state.segments.length * 2, Math.floor(pointCount * ratio))
+                : pointCount;
+            let remainingPoints = pointCount;
+            const segments = state.segments.map((segment, index) => {
+                const target = sampled
+                    ? Math.min(segment.length, Math.max(Math.min(segment.length, 2), index === state.segments.length - 1
+                        ? remainingTarget
+                        : Math.floor((segment.length / Math.max(1, remainingPoints)) * remainingTarget)))
+                    : segment.length;
+                remainingTarget = Math.max(0, remainingTarget - target);
+                remainingPoints -= segment.length;
+                return trimToTarget(segment, target, state.mandatoryAt);
+            });
+            return {
+                key: state.input.key,
+                kind: state.input.kind,
+                title: state.input.kind === 'main' ? '主代理' : state.input.title,
+                agentType: state.input.agentType,
+                calls: state.calls.length,
+                segments,
+                runs: state.input.runs
+            };
+        })
+    };
+}
+function timelineMarkers(states) {
+    return states
+        .flatMap((state) => state.markers.map((marker) => {
+        const previous = [...state.calls]
+            .reverse()
+            .find((call) => call.timestamp < marker.timestamp);
+        const next = state.calls.find((call) => call.timestamp > marker.timestamp);
+        return {
+            x: marker.timestamp,
+            sourceKey: state.input.key,
+            kind: marker.kind,
+            timestamp: marker.timestamp,
+            mode: marker.mode,
+            beforePrompt: previous?.prompt ?? null,
+            projectedPrompt: marker.projectedTokens,
+            afterPrompt: next?.prompt ?? null,
+            tokensBefore: marker.tokensBefore
+        };
+    }))
+        .sort((left, right) => left.timestamp - right.timestamp);
+}
+function createBuckets(inputs, startAt, endAt, bucketMs, timeZone) {
+    const buckets = usageBucketRanges(startAt, endAt, bucketMs, timeZone).map((range) => ({
+        ...range,
+        totals: emptyTotals(),
+        calls: 0,
+        sources: inputs.map((source) => ({ sourceKey: source.key, totals: emptyTotals(), calls: 0 }))
+    }));
+    const sourceIndexes = new Map(inputs.map((source, index) => [source.key, index]));
+    for (const source of inputs) {
+        const sourceIndex = sourceIndexes.get(source.key);
+        for (const event of source.events) {
+            if (!inRange(event.timestamp, startAt, endAt))
+                continue;
+            const index = usageBucketIndex(buckets, event.timestamp);
+            const bucket = buckets[index];
+            const sourceBucket = bucket.sources[sourceIndex];
+            addTotals(bucket.totals, event.totals);
+            addTotals(sourceBucket.totals, event.totals);
+            if (event.kind === 'assistant') {
+                bucket.calls += 1;
+                sourceBucket.calls += 1;
+            }
+        }
+    }
+    return buckets;
+}
+export function createUsageActivities(inputs, startAt, endAt) {
+    const activities = [];
+    for (const source of inputs) {
+        for (const event of source.events) {
+            if (!inRange(event.timestamp, startAt, endAt))
+                continue;
+            activities.push({
+                id: event.identity,
+                timestamp: event.timestamp,
+                endAt: null,
+                sourceKey: source.key,
+                kind: 'model',
+                label: event.label,
+                detail: event.kind === 'cache-warm'
+                    ? '缓存保温'
+                    : event.kind === 'usage'
+                        ? '其他模型调用'
+                        : event.kind === 'assistant'
+                            ? '模型调用'
+                            : '工具与摘要用量',
+                status: null,
+                totals: { ...event.totals }
+            });
+        }
+        for (const tool of source.tools) {
+            if (!intersects(tool.timestamp, tool.endAt, startAt, endAt))
+                continue;
+            activities.push({
+                id: tool.identity,
+                timestamp: tool.timestamp,
+                endAt: tool.endAt,
+                sourceKey: source.key,
+                kind: 'tool',
+                label: tool.toolName,
+                detail: tool.reasoning,
+                status: tool.status,
+                totals: null
+            });
+        }
+        if (source.kind === 'subagent') {
+            for (const [index, run] of source.runs.entries()) {
+                if (!intersects(run.startAt, run.endAt, startAt, endAt))
+                    continue;
+                activities.push({
+                    id: `${source.key}:run:${index}`,
+                    timestamp: run.startAt,
+                    endAt: run.endAt,
+                    sourceKey: source.key,
+                    kind: 'subagent-run',
+                    label: '子代理运行',
+                    detail: source.title,
+                    status: run.endAt === null ? 'running' : 'completed',
+                    totals: null
+                });
+            }
+        }
+        for (const marker of source.markers) {
+            if (!inRange(marker.timestamp, startAt, endAt))
+                continue;
+            activities.push({
+                id: marker.identity,
+                timestamp: marker.timestamp,
+                endAt: null,
+                sourceKey: source.key,
+                kind: marker.kind,
+                label: marker.kind === 'compaction' ? '上下文压缩' : '上下文忽略',
+                detail: null,
+                status: null,
+                totals: null
+            });
+        }
+    }
+    return activities.sort((left, right) => left.timestamp - right.timestamp || left.id.localeCompare(right.id));
+}
+export function createUsageTimeline(inputs, requestedStartAt, requestedEndAt, timeZone = 'UTC') {
+    const observedStarts = inputs.flatMap((source) => [
+        ...source.events.map((event) => event.timestamp),
+        ...source.tools.map((tool) => tool.timestamp),
+        ...source.runs.map((run) => run.startAt)
+    ]);
+    const observedEnds = inputs.flatMap((source) => [
+        ...source.events.map((event) => event.timestamp),
+        ...source.tools.flatMap((tool) => (tool.endAt === null ? [] : [tool.endAt])),
+        ...source.runs.flatMap((run) => (run.endAt === null ? [] : [run.endAt])),
+        source.updatedAt
+    ]);
+    const fallback = Date.now();
+    const startAt = requestedStartAt ?? Math.min(...observedStarts, fallback);
+    const defaultEndAt = observedEnds.length > 0 ? Math.max(...observedEnds) : fallback;
+    const endAt = Math.max(startAt + 1, requestedEndAt ?? defaultEndAt);
+    const bucketMs = chooseBucketMs(endAt - startAt);
+    const states = contextStates(inputs);
+    const sampled = sampledSources(states);
+    const markers = timelineMarkers(states).filter((marker) => inRange(marker.timestamp, startAt, endAt));
+    const allActivities = createUsageActivities(inputs, startAt, endAt);
+    const activities = allActivities
+        .filter((activity) => {
+        if (activity.kind === 'subagent-run')
+            return true;
+        if (activity.kind !== 'tool')
+            return false;
+        const end = activity.endAt ?? endAt;
+        return end - activity.timestamp >= bucketMs;
+    })
+        .sort((left, right) => (right.endAt ?? endAt) - right.timestamp - ((left.endAt ?? endAt) - left.timestamp))
+        .slice(0, MAX_TRACK_ACTIVITIES)
+        .sort((left, right) => left.timestamp - right.timestamp);
+    return {
+        generatedAt: Date.now(),
+        startAt,
+        endAt,
+        bucketMs,
+        totalCalls: inputs.reduce((total, source) => total + source.events.filter((event) => event.kind === 'assistant').length, 0),
+        displayedPoints: sampled.sources.reduce((total, source) => total + source.segments.reduce((sum, segment) => sum + segment.length, 0), 0),
+        sampled: sampled.sampled,
+        buckets: createBuckets(inputs, startAt, endAt, bucketMs, timeZone),
+        sources: sampled.sources,
+        markers,
+        activities
+    };
+}

package/dist/usage-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/usage-worker.js

@@ -0,0 +1,13 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { scanUsageFiles } from './usage-scan.js';
+const input = workerData;
+if (!parentPort)
+    throw new Error('用量 Worker 缺少 parentPort');
+try {
+    parentPort.postMessage({ results: await scanUsageFiles(input.files, 2) });
+}
+catch (error) {
+    parentPort.postMessage({
+        error: error instanceof Error ? error.message : String(error)
+    });
+}

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "@jetcrab/pi-desk-usage",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JetCrab/pi-desk.git",
+    "directory": "plugins/pi-desk-usage"
+  },
+  "version": "1.0.1-dev.9001",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "description": "Lazy Pi Desk dashboard for recent model, token, cache, and cost usage",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/pi-desk.d.ts",
+      "import": "./dist/pi-desk.js",
+      "default": "./dist/pi-desk.js"
+    }
+  },
+  "types": "./dist/pi-desk.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "pi-package"
+  ],
+  "pi": {
+    "extensions": []
+  },
+  "piDesk": {
+    "entry": "./dist/pi-desk.js"
+  },
+  "dependencies": {
+    "zod": "^4.4.3",
+    "@jetcrab/pi-desk-sdk": "^1.0.1-dev.9001"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@base-ui/react": "^1.7.0",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "esbuild": "^0.25.0",
+    "react": "19.2.8",
+    "react-dom": "19.2.8",
+    "tsx": "^4.23.12",
+    "typescript": "^5"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node -e \"const fs=require('node:fs');fs.rmSync('dist/browser',{recursive:true,force:true});for(const name of fs.readdirSync('dist'))if(name.startsWith('browser')&&['.js','.d.ts','.js.map'].some(ext=>name.endsWith(ext)))fs.rmSync('dist/'+name,{force:true})\" && esbuild src/browser-entry.ts --bundle --splitting --format=esm --platform=browser --target=es2022 --minify --define:process.env.NODE_ENV='production' --external:react --external:react/jsx-runtime --external:react/jsx-dev-runtime --external:react-dom --external:react-dom/client --external:@jetcrab/pi-desk-sdk/react/base --external:@jetcrab/pi-desk-sdk/react/markdown --outdir=dist/browser --entry-names=entry --chunk-names=chunks/[name]-[hash]",
+    "test": "node --import tsx --test tests/*.test.ts"
+  }
 }