@zaip-ai/cli 2.2.0 → 3.0.0

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-dimension-facts.test.ts

@@ -258,8 +258,19 @@ describe("cost invocation dimension rebuild", () => {
     expect(factRows(database, "cost_invocation_dimension_facts")).toEqual(
       factRows(database, "legacy_cost_invocation_dimension_facts"),
     );
+    // SQLite versions bundled with supported Node runtimes may serialize REALs
+    // with different precision. The contract is exact legacy JSON parity on
+    // that engine, not a hard-coded decimal spelling from SQLite 3.49.
+    const expectedCosts = database
+      .prepare(`
+        SELECT json_extract(payload, '$.cost_usd') AS cost_usd,
+          json_extract(payload, '$.cost_brl') AS cost_brl
+        FROM (SELECT json_object('cost_usd', ?, 'cost_brl', ?) AS payload)
+      `)
+      .get(0.1 + 0.2, 1234567.8912345679);
+    expect(expectedCosts).toEqual({ cost_usd: expect.any(Number), cost_brl: expect.any(Number) });
     expect(factRows(database, "cost_invocation_dimension_facts")).toContainEqual(
-      expect.objectContaining({ residual: 0, cost_usd: 0.3, cost_brl: 1234567.89123457 }),
+      expect.objectContaining({ residual: 0, ...expectedCosts }),
     );
   });
 

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-file-index.test.ts

@@ -0,0 +1,69 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import { rebuildSqliteReadModel, validateSqliteReadModelSchema } from "./sqlite-read-model.js";
+import { prepareMultiProviderFixture } from "./sqlite-read-model-multi-provider-fixture.js";
+
+it("indexes exact and LIKE file lookups without changing case or prefix membership", async () => {
+  const root = await mkdtemp(join(tmpdir(), "zaip-file-index-"));
+  let database: DatabaseSync | undefined;
+  try {
+    await prepareMultiProviderFixture(root);
+    await rebuildSqliteReadModel(root);
+    const path = join(root, ".local/sqlite/zaip-aios-dashboard.sqlite");
+    database = new DatabaseSync(path);
+    const reader = database;
+    const queries = [
+      {
+        sql: "SELECT path, content FROM zaip_vw_files WHERE path = ?",
+        arg: ".agents/config/project.yaml",
+        index: "zaip_activities_file_path",
+      },
+      {
+        sql: "SELECT path FROM zaip_vw_files WHERE path LIKE ? ORDER BY path",
+        arg: ".agents/%",
+        index: "zaip_activities_file_path",
+      },
+      {
+        sql: "SELECT path FROM zaip_vw_files WHERE path LIKE ? ORDER BY path",
+        arg: ".AGENTS/%",
+        index: "zaip_activities_file_path",
+      },
+      {
+        sql: "SELECT path FROM zaip_vw_files WHERE path LIKE ? ORDER BY path",
+        arg: ".agents/missing/%",
+        index: "zaip_activities_file_path",
+      },
+      {
+        sql: "SELECT path FROM zaip_vw_files WHERE path = ?",
+        arg: ".AGENTS/config/project.yaml",
+        index: "zaip_activities_file_path",
+      },
+    ];
+    const indexed = queries.map(({ sql, arg, index }) => {
+      const plan = reader.prepare(`EXPLAIN QUERY PLAN ${sql}`).all(arg);
+      expect(JSON.stringify(plan)).toContain(`USING INDEX ${index}`);
+      return reader.prepare(sql).all(arg);
+    });
+    expect(indexed[0]).toHaveLength(1);
+    expect(indexed[1]?.length).toBeGreaterThan(1);
+    expect(indexed[2]).toEqual(indexed[1]);
+    expect(indexed[3]).toEqual([]);
+    expect(indexed[4]).toEqual([]);
+    const view = database
+      .prepare("SELECT sql FROM sqlite_master WHERE name='zaip_vw_files'")
+      .get() as { sql: string };
+    database.exec("DROP VIEW zaip_vw_files;");
+    database.exec(view.sql.replace(" INDEXED BY zaip_activities_file_path", ""));
+    database.exec("DROP INDEX zaip_activities_file_path;");
+    expect(() => validateSqliteReadModelSchema(path)).toThrow(/missing required indexes/);
+    for (const [position, { sql, arg }] of queries.entries()) {
+      expect(database.prepare(sql).all(arg)).toEqual(indexed[position]);
+    }
+  } finally {
+    database?.close();
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-first-fold-cache.ts

@@ -231,7 +231,9 @@ export function readFirstFoldViewport(
       SELECT COALESCE(status, 'draft') AS status, COUNT(*) AS task_count FROM items WHERE entity_kind='task' GROUP BY COALESCE(status, 'draft'))
   ), task_risk AS (
     SELECT json_group_object(risk, task_count) AS task_risk_json FROM (
-      SELECT COALESCE(risk, 'standard') AS risk, COUNT(*) AS task_count FROM items WHERE entity_kind='task' GROUP BY COALESCE(risk, 'standard'))
+      SELECT COALESCE(risk, 'standard') AS risk, COUNT(*) AS task_count FROM items
+      WHERE entity_kind='task' AND COALESCE(status, 'draft') <> 'draft'
+      GROUP BY COALESCE(risk, 'standard'))
   )
   SELECT totals.*, run_totals.*, duration_totals.*, bounds.*, item_totals.*, task_status.*, task_risk.*
     FROM totals CROSS JOIN run_totals CROSS JOIN duration_totals CROSS JOIN bounds

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-force-canonical.test.ts

@@ -1,7 +1,7 @@
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { rebuildSqliteReadModel } from "./sqlite-read-model.js";
 
 const roots: string[] = [];
@@ -17,12 +17,14 @@ async function fixture(): Promise<string> {
 }
 
 afterEach(async () => {
+  vi.restoreAllMocks();
   await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
 });
 
 describe("forceCanonical SQLite refresh", () => {
   it("bypasses a healthy generation and verifies canonical sources again", async () => {
     const root = await fixture();
+    vi.spyOn(Date, "now").mockReturnValue(Date.now() + 5_000);
     const initial = await rebuildSqliteReadModel(root);
     await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({
       cache: "generation",

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-incremental-refresh.test.ts

@@ -173,6 +173,8 @@ describe("incremental refresh preserves historical facts", () => {
   it("updates and removes changed sources in place with full-build query parity and untouched historical payloads", async () => {
     const root = await fixture();
     const { started, usage, finished } = await prepareMultiProviderFixture(root);
+    // This scenario exercises settled historical checkpoints, not rapid writes.
+    vi.spyOn(Date, "now").mockReturnValue(Date.now() + 5_000);
     const first = await rebuildSqliteReadModel(root);
     const history = inspect(first.path, historySql);
     expect(history).toHaveLength(2);

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-materialize-first-fold.ts

@@ -0,0 +1,78 @@
+import type { DatabaseSync } from "node:sqlite";
+import { persistFirstFoldPayloadsInDatabase } from "./sqlite-first-fold-persistence.js";
+import { measureFirstFold } from "./sqlite-first-fold-timing.js";
+import { operationsWorkRowsInRange } from "./sqlite-operations-work-list.js";
+import { saoPauloCurrentMonth } from "./sqlite-read-model-canonical.js";
+import { SqliteReadModelFileSystem } from "./sqlite-read-model-filesystem.js";
+import type { SqliteFirstFoldMonthlyQuick } from "./sqlite-read-model-first-fold-types.js";
+import { reportSqliteReadModelLaunchProgress } from "./sqlite-read-model-launch-progress.js";
+export function refreshFirstFoldPayloads(workspaceRoot: string, database: DatabaseSync): void {
+  const reportLaunchProgress = reportSqliteReadModelLaunchProgress;
+  const timed = <T>(phase: string, action: () => T) =>
+    measureFirstFold(
+      process.env.ZAIP_DASHBOARD_LAUNCH_PROGRESS === "1",
+      reportLaunchProgress,
+      phase,
+      action,
+    );
+  // This reader shares the writer connection, therefore it sees the
+  // uncommitted canonical facts and projections. Its payloads join the
+  // same BEGIN IMMEDIATE transaction below.
+  const firstFoldFilesystem = new SqliteReadModelFileSystem(workspaceRoot, database);
+  const firstFoldViewport = timed("first_fold_viewport", () =>
+    firstFoldFilesystem.firstFoldViewportAllTime(),
+  );
+  const firstFoldAllTime = timed("first_fold_all_time", () =>
+    firstFoldFilesystem.firstFoldAllTime(),
+  );
+  const firstFoldAllTimeBoard = timed("first_fold_board", () =>
+    firstFoldFilesystem.firstFoldBoardAllTime(),
+  );
+  const costMonitorSummaryAllTime = timed("first_fold_cost_summary", () =>
+    firstFoldFilesystem.costMonitorSummaryAggregate({ from: null, to: null }),
+  );
+  const quickMonth = saoPauloCurrentMonth();
+  const costMonitorSummaryCurrentMonth = timed("first_fold_cost_summary_month", () =>
+    firstFoldFilesystem.costMonitorSummaryAggregate(quickMonth),
+  );
+  const firstFoldMonthlyQuick: SqliteFirstFoldMonthlyQuick = {
+    from_day: quickMonth.from,
+    to_day: quickMonth.to,
+    source_latest_day: timed("first_fold_latest_day", () =>
+      firstFoldFilesystem.firstFoldRelevantLatestDay(),
+    ),
+    aggregate: timed("first_fold_month_aggregate", () =>
+      firstFoldFilesystem.firstFoldAggregate(quickMonth),
+    ),
+    pages: {
+      task: operationsWorkRowsInRange(
+        firstFoldAllTimeBoard.pages.task,
+        quickMonth.from,
+        quickMonth.to,
+      ),
+      spec: operationsWorkRowsInRange(
+        firstFoldAllTimeBoard.pages.spec,
+        quickMonth.from,
+        quickMonth.to,
+      ),
+      prd: operationsWorkRowsInRange(
+        firstFoldAllTimeBoard.pages.prd,
+        quickMonth.from,
+        quickMonth.to,
+      ),
+    },
+    top_tasks: timed("first_fold_month_top_tasks", () => firstFoldFilesystem.topTasks(quickMonth)),
+  };
+  firstFoldFilesystem.close();
+  persistFirstFoldPayloadsInDatabase(database, {
+    first_fold_viewport_cache: JSON.stringify(firstFoldViewport),
+    first_fold_all_time_cache: JSON.stringify(firstFoldAllTime),
+    first_fold_all_time_board_cache: JSON.stringify(firstFoldAllTimeBoard),
+    cost_monitor_summary_cache: JSON.stringify(costMonitorSummaryAllTime),
+    cost_monitor_summary_month_cache: JSON.stringify({
+      ...quickMonth,
+      aggregate: costMonitorSummaryCurrentMonth,
+    }),
+    first_fold_monthly_quick_cache: JSON.stringify(firstFoldMonthlyQuick),
+  });
+}