@chrysb/alphaclaw 0.6.2-beta.1 → 0.6.2-beta.3

package/lib/public/css/cron.css

@@ -210,6 +210,9 @@
   flex-direction: column;
   gap: 12px;
   min-height: 100%;
+  width: min(100%, 1024px);
+  margin-left: auto;
+  margin-right: auto;
 }
 
 .cron-prompt-editor-shell {
@@ -222,6 +225,11 @@
   background: rgba(255, 255, 255, 0.01);
 }
 
+.cron-prompt-editor-shell .file-viewer-editor-line-num-col {
+  width: 44px;
+  padding: 16px 8px 112px 0;
+}
+
 .cron-calendar-repeating-strip {
   border: 1px solid var(--border);
   border-radius: 10px;
@@ -284,7 +292,7 @@
 .cron-calendar-grid-header,
 .cron-calendar-grid-row {
   display: grid;
-  grid-template-columns: 88px repeat(7, minmax(130px, 1fr));
+  grid-template-columns: 80px repeat(7, minmax(80px, 1fr));
 }
 
 .cron-calendar-day-header {

package/lib/public/js/components/cron-tab/cron-calendar.js

@@ -7,7 +7,6 @@ import { formatCost, formatTokenCount } from "./cron-helpers.js";
 import { formatCronScheduleLabel } from "./cron-helpers.js";
 import { readUiSettings, updateUiSettings } from "../../lib/ui-settings.js";
 import {
-  buildTokenTierByJobId,
   classifyRepeatingJobs,
   expandJobsToRollingSlots,
   getUpcomingSlots,
@@ -68,47 +67,195 @@ const renderLegend = () => html`
 
 const kNowRefreshMs = 60 * 1000;
 const kCalendarExpandedUiSettingKey = "cronCalendarExpanded";
+const kRunWindow7dMs = 7 * 24 * 60 * 60 * 1000;
+const kSlotRunToleranceMs = 45 * 60 * 1000;
+const kUnknownTier = "unknown";
 
 const formatUpcomingTime = (timestampMs) => {
   const dateValue = new Date(timestampMs);
   return dateValue.toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
 };
 
+const getRunTotalTokens = (entry = {}) => {
+  const usage = entry?.usage || {};
+  const candidates = [
+    usage?.total_tokens,
+    usage?.totalTokens,
+    entry?.total_tokens,
+    entry?.totalTokens,
+  ];
+  for (const candidate of candidates) {
+    const numericValue = Number(candidate);
+    if (Number.isFinite(numericValue) && numericValue >= 0) return numericValue;
+  }
+  return 0;
+};
+
+const getRunEstimatedCost = (entry = {}) => {
+  const usage = entry?.usage || {};
+  const candidates = [
+    entry?.estimatedCost,
+    entry?.estimated_cost,
+    usage?.estimatedCost,
+    usage?.estimated_cost,
+    usage?.totalCost,
+    usage?.total_cost,
+    usage?.costUsd,
+    usage?.cost,
+  ];
+  for (const candidate of candidates) {
+    const numericValue = Number(candidate);
+    if (Number.isFinite(numericValue) && numericValue >= 0) return numericValue;
+  }
+  return null;
+};
+
+const buildRunSummaryByJobId = ({ runsByJobId = {}, nowMs = Date.now() } = {}) => {
+  const cutoffMs = Number(nowMs || Date.now()) - kRunWindow7dMs;
+  return Object.entries(runsByJobId || {}).reduce((accumulator, [jobId, runResult]) => {
+    const entries = Array.isArray(runResult?.entries) ? runResult.entries : [];
+    const recentEntries = entries.filter((entry) => {
+      const timestampMs = Number(entry?.ts || 0);
+      return Number.isFinite(timestampMs) && timestampMs >= cutoffMs && timestampMs <= nowMs;
+    });
+    const runCount = recentEntries.length;
+    const totalTokens = recentEntries.reduce(
+      (sum, entry) => sum + Number(getRunTotalTokens(entry) || 0),
+      0,
+    );
+    const totalCost = recentEntries.reduce((sum, entry) => {
+      const cost = getRunEstimatedCost(entry);
+      return sum + Number(cost == null ? 0 : cost);
+    }, 0);
+    accumulator[String(jobId || "")] = {
+      runCount,
+      totalTokens,
+      totalCost,
+      avgTokensPerRun: runCount > 0 ? Math.round(totalTokens / runCount) : 0,
+      avgCostPerRun: runCount > 0 ? totalCost / runCount : 0,
+    };
+    return accumulator;
+  }, {});
+};
+
+const mapRunsToSlots = ({ slots = [], runsByJobId = {}, nowMs = Date.now() } = {}) => {
+  const runsBySlotKey = {};
+  const consumedRunTimestampsByJobId = {};
+  const runEntriesByJobId = Object.entries(runsByJobId || {}).reduce(
+    (accumulator, [jobId, runResult]) => {
+      const entries = Array.isArray(runResult?.entries) ? runResult.entries : [];
+      const normalizedEntries = entries
+        .map((entry) => ({ ...entry, ts: Number(entry?.ts || 0) }))
+        .filter((entry) => Number.isFinite(entry.ts) && entry.ts > 0)
+        .sort((left, right) => left.ts - right.ts);
+      accumulator[String(jobId || "")] = normalizedEntries;
+      return accumulator;
+    },
+    {},
+  );
+  slots.forEach((slot) => {
+    if (Number(slot?.scheduledAtMs || 0) > nowMs) return;
+    const jobId = String(slot?.jobId || "");
+    const runEntries = runEntriesByJobId[jobId] || [];
+    if (runEntries.length === 0) return;
+    const consumedSet = consumedRunTimestampsByJobId[jobId] || new Set();
+    consumedRunTimestampsByJobId[jobId] = consumedSet;
+    let nearestEntry = null;
+    let nearestDeltaMs = Number.MAX_SAFE_INTEGER;
+    runEntries.forEach((entry) => {
+      if (consumedSet.has(entry.ts)) return;
+      const deltaMs = Math.abs(entry.ts - Number(slot?.scheduledAtMs || 0));
+      if (deltaMs > kSlotRunToleranceMs) return;
+      if (deltaMs < nearestDeltaMs) {
+        nearestDeltaMs = deltaMs;
+        nearestEntry = entry;
+      }
+    });
+    if (!nearestEntry) return;
+    consumedSet.add(nearestEntry.ts);
+    runsBySlotKey[String(slot?.key || "")] = nearestEntry;
+  });
+  return runsBySlotKey;
+};
+
+const buildTierThresholds = (values = []) => {
+  const sortedValues = values
+    .map((value) => Number(value || 0))
+    .filter((value) => Number.isFinite(value) && value > 0)
+    .sort((left, right) => left - right);
+  if (sortedValues.length === 0) return null;
+  const percentileAt = (indexRatio = 0) => {
+    const index = Math.min(
+      sortedValues.length - 1,
+      Math.floor((sortedValues.length - 1) * indexRatio),
+    );
+    return sortedValues[Math.max(0, index)];
+  };
+  return {
+    q1: percentileAt(0.25),
+    q2: percentileAt(0.5),
+    p90: percentileAt(0.9),
+  };
+};
+
+const classifyTokenTier = ({
+  enabled = true,
+  tokenValue = 0,
+  thresholds = null,
+} = {}) => {
+  if (!enabled) return "disabled";
+  const safeValue = Number(tokenValue || 0);
+  if (!Number.isFinite(safeValue) || safeValue <= 0 || !thresholds) return kUnknownTier;
+  if (safeValue <= thresholds.q1) return "low";
+  if (safeValue <= thresholds.q2) return "medium";
+  if (safeValue <= thresholds.p90) return "high";
+  return "very-high";
+};
+
 
 const buildJobTooltipText = ({
   jobName = "",
   job = null,
-  usage = {},
+  runSummary7d = {},
+  slotRun = null,
   latestRun = null,
   scheduledAtMs = 0,
   scheduledStatus = "",
+  nowMs = Date.now(),
 } = {}) => {
-  const runCount = Number(usage?.runCount || 0);
-  const totalTokens = Number(usage?.totalTokens || 0);
-  const totalCost = Number(usage?.totalCost || 0);
-  const avgTokensPerRun = runCount > 0
-    ? Number(usage?.avgTokensPerRun || Math.round(totalTokens / runCount))
-    : 0;
-  const avgCostPerRun = runCount > 0 ? totalCost / runCount : 0;
+  const isPastSlot = Number(scheduledAtMs || 0) > 0 && Number(scheduledAtMs || 0) <= nowMs;
+  const runCount7d = Number(runSummary7d?.runCount || 0);
+  const avgTokensPerRun7d = Number(runSummary7d?.avgTokensPerRun || 0);
+  const avgCostPerRun7d = Number(runSummary7d?.avgCostPerRun || 0);
+  const slotRunTokens = getRunTotalTokens(slotRun || {});
+  const slotRunCost = getRunEstimatedCost(slotRun || {});
+  const slotRunStatus = String(slotRun?.status || "").trim().toLowerCase();
 
-  const lines = [
-    String(jobName || "Job"),
-    `Avg tokens/run: ${runCount > 0 ? formatTokenCount(avgTokensPerRun) : "—"}`,
-    `Avg cost/run: ${runCount > 0 ? formatCost(avgCostPerRun) : "—"}`,
-    `Total cost: ${formatCost(totalCost)}`,
-  ];
-
-  if (runCount <= 0) {
-    lines.push("Runs: none yet");
+  const lines = [String(jobName || "Job")];
+  if (isPastSlot) {
+    lines.push(`Run tokens: ${slotRun ? formatTokenCount(slotRunTokens) : "—"}`);
+    lines.push(`Run cost: ${slotRunCost == null ? "—" : formatCost(slotRunCost)}`);
+    lines.push(`Run status: ${slotRunStatus || scheduledStatus || "unknown"}`);
+    if (slotRun?.ts) {
+      lines.push(
+        `Run time: ${new Date(Number(slotRun.ts || 0)).toLocaleString()}`,
+      );
+    }
   } else {
-    lines.push(`Runs: ${formatTokenCount(runCount)}`);
+    lines.push(
+      `Avg tokens/run (last 7d): ${runCount7d > 0 ? formatTokenCount(avgTokensPerRun7d) : "—"}`,
+    );
+    lines.push(
+      `Avg cost/run (last 7d): ${runCount7d > 0 ? formatCost(avgCostPerRun7d) : "—"}`,
+    );
+    lines.push(`Runs (last 7d): ${runCount7d > 0 ? formatTokenCount(runCount7d) : "none"}`);
   }
 
-  if (latestRun?.status) {
+  if (!isPastSlot && latestRun?.status) {
     lines.push(
       `Latest run: ${latestRun.status} (${new Date(Number(latestRun.ts || 0)).toLocaleString()})`,
     );
-  } else {
+  } else if (!isPastSlot) {
     lines.push("Latest run: none");
   }
   if (Number(job?.state?.runningAtMs || 0) > 0) {
@@ -125,7 +272,6 @@ const buildJobTooltipText = ({
 
 export const CronCalendar = ({
   jobs = [],
-  usageByJobId = {},
   runsByJobId = {},
   onSelectJob = () => {},
 }) => {
@@ -163,10 +309,6 @@ export const CronCalendar = ({
     () => mapRunStatusesToSlots({ slots: timeline.slots, bulkRunsByJobId: runsByJobId, nowMs }),
     [timeline.slots, runsByJobId, nowMs],
   );
-  const tokenTierByJobId = useMemo(
-    () => buildTokenTierByJobId({ jobs, usageByJobId }),
-    [jobs, usageByJobId],
-  );
   const jobById = useMemo(
     () =>
       jobs.reduce((accumulator, job) => {
@@ -188,6 +330,63 @@ export const CronCalendar = ({
       }, {}),
     [runsByJobId],
   );
+  const runSummary7dByJobId = useMemo(
+    () => buildRunSummaryByJobId({ runsByJobId, nowMs }),
+    [runsByJobId, nowMs],
+  );
+  const runBySlotKey = useMemo(
+    () => mapRunsToSlots({ slots: timeline.slots, runsByJobId, nowMs }),
+    [timeline.slots, runsByJobId, nowMs],
+  );
+  const slotTierThresholds = useMemo(() => {
+    const values = [];
+    timeline.slots.forEach((slot) => {
+      const job = jobById[slot.jobId] || null;
+      if (!job || job.enabled === false) return;
+      const isPastSlot = Number(slot?.scheduledAtMs || 0) <= nowMs;
+      if (isPastSlot) {
+        const slotRunTokens = getRunTotalTokens(runBySlotKey[slot.key] || {});
+        if (slotRunTokens > 0) values.push(slotRunTokens);
+        return;
+      }
+      const projectedAvgTokens = Number(runSummary7dByJobId[slot.jobId]?.avgTokensPerRun || 0);
+      if (projectedAvgTokens > 0) values.push(projectedAvgTokens);
+    });
+    repeatingJobs.forEach((job) => {
+      const jobId = String(job?.id || "");
+      const projectedAvgTokens = Number(runSummary7dByJobId[jobId]?.avgTokensPerRun || 0);
+      if (projectedAvgTokens > 0) values.push(projectedAvgTokens);
+    });
+    return buildTierThresholds(values);
+  }, [jobById, nowMs, repeatingJobs, runBySlotKey, runSummary7dByJobId, timeline.slots]);
+  const getSlotTokenTier = useCallback((slot = null) => {
+    const jobId = String(slot?.jobId || "");
+    const job = jobById[jobId] || null;
+    const enabled = job?.enabled !== false;
+    const isPastSlot = Number(slot?.scheduledAtMs || 0) <= nowMs;
+    if (isPastSlot) {
+      const slotRunTokens = getRunTotalTokens(runBySlotKey[String(slot?.key || "")] || {});
+      return classifyTokenTier({
+        enabled,
+        tokenValue: slotRunTokens,
+        thresholds: slotTierThresholds,
+      });
+    }
+    const projectedAvgTokens = Number(runSummary7dByJobId[jobId]?.avgTokensPerRun || 0);
+    return classifyTokenTier({
+      enabled,
+      tokenValue: projectedAvgTokens,
+      thresholds: slotTierThresholds,
+    });
+  }, [jobById, nowMs, runBySlotKey, runSummary7dByJobId, slotTierThresholds]);
+  const getJobProjectedTier = useCallback((jobId = "") => {
+    const job = jobById[jobId] || null;
+    return classifyTokenTier({
+      enabled: job?.enabled !== false,
+      tokenValue: Number(runSummary7dByJobId[jobId]?.avgTokensPerRun || 0),
+      thresholds: slotTierThresholds,
+    });
+  }, [jobById, runSummary7dByJobId, slotTierThresholds]);
 
   const upcomingSlots = useMemo(
     () => getUpcomingSlots({ slots: timeline.slots, nowMs }),
@@ -223,13 +422,14 @@ export const CronCalendar = ({
         : html`
             <div class="cron-calendar-compact-strip">
               ${upcomingSlots.map((slot) => {
-                const usage = usageByJobId[slot.jobId] || {};
                 const tooltipText = buildJobTooltipText({
                   jobName: slot.jobName,
                   job: jobById[slot.jobId] || null,
-                  usage,
+                  runSummary7d: runSummary7dByJobId[slot.jobId] || {},
+                  slotRun: runBySlotKey[slot.key] || null,
                   latestRun: latestRunByJobId[slot.jobId],
                   scheduledAtMs: slot.scheduledAtMs,
+                  nowMs,
                 });
                 return html`
                   <${Tooltip}
@@ -309,15 +509,16 @@ export const CronCalendar = ({
                           ${visibleSlots.map((slot) => {
                             const status = statusBySlotKey[slot.key] || "";
                             const isPast = slot.scheduledAtMs <= nowMs;
-                            const tokenTier = tokenTierByJobId[slot.jobId] || "unknown";
-                            const usage = usageByJobId[slot.jobId] || {};
+                            const tokenTier = getSlotTokenTier(slot);
                             const tooltipText = buildJobTooltipText({
                               jobName: slot.jobName,
                               job: jobById[slot.jobId] || null,
-                              usage,
+                              runSummary7d: runSummary7dByJobId[slot.jobId] || {},
+                              slotRun: runBySlotKey[slot.key] || null,
                               latestRun: latestRunByJobId[slot.jobId],
                               scheduledAtMs: slot.scheduledAtMs,
                               scheduledStatus: status,
+                              nowMs,
                             });
                             return html`
                               <${Tooltip}
@@ -366,13 +567,16 @@ export const CronCalendar = ({
               <div class="cron-calendar-repeating-list">
                 ${repeatingJobs.map((job) => {
                   const jobId = String(job?.id || "");
-                  const usage = usageByJobId[jobId] || {};
-                  const avgTokensPerRun = Number(usage?.avgTokensPerRun || 0);
+                  const avgTokensPerRun = Number(
+                    runSummary7dByJobId[jobId]?.avgTokensPerRun || 0,
+                  );
                   const tooltipText = buildJobTooltipText({
                     jobName: job.name || job.id,
                     job,
-                    usage,
+                    runSummary7d: runSummary7dByJobId[jobId] || {},
+                    slotRun: null,
                     latestRun: latestRunByJobId[jobId],
+                    nowMs,
                   });
                   return html`
                     <${Tooltip}
@@ -385,7 +589,7 @@ export const CronCalendar = ({
                         class=${`cron-calendar-repeating-pill ${slotStateClassName({
                           isPast: false,
                           mappedStatus: "",
-                          tokenTier: tokenTierByJobId[jobId] || "unknown",
+                          tokenTier: getJobProjectedTier(jobId),
                         })}`}
                         role="button"
                         tabindex="0"