forgeos 0.1.0-alpha.11 → 0.1.0-alpha.13

package/src/forge/delta/timeline.ts

@@ -0,0 +1,104 @@
+import { DeltaStore, type DeltaSemanticTimelineResult } from "./store.ts";
+
+export interface DeltaTimelineResult {
+  ok: true;
+  session?: string;
+  target?: string;
+  rebuilt?: boolean;
+  timeline: DeltaSemanticTimelineResult;
+  exitCode: 0;
+}
+
+export async function runDeltaTimeline(input: {
+  workspaceRoot: string;
+  target?: string;
+  kind?: string;
+  session?: string;
+  limit?: number;
+  rebuild?: boolean;
+}): Promise<DeltaTimelineResult> {
+  const store = await DeltaStore.open(input.workspaceRoot);
+  try {
+    if (input.rebuild) {
+      await store.rebuildSemanticTimeline();
+    }
+    return {
+      ok: true,
+      session: input.session,
+      target: input.target,
+      rebuilt: input.rebuild || undefined,
+      timeline: await store.semanticTimeline({ target: input.target, kind: input.kind, workSessionId: input.session, limit: input.limit }),
+      exitCode: 0,
+    };
+  } finally {
+    await store.close();
+  }
+}
+
+export function formatDeltaTimelineHuman(result: DeltaTimelineResult): string {
+  const timeline = result.timeline;
+  if (timeline.events.length === 0) {
+    return "Timeline\n\nno semantic timeline events recorded\n";
+  }
+  const title = timeline.entity
+    ? `Timeline - ${timeline.entity.kind}:${timeline.entity.name}`
+    : result.session
+      ? `Timeline (${result.session})`
+      : "Timeline";
+  const lines = [title, ""];
+  const grouped = new Map<string, typeof timeline.events>();
+  for (const event of timeline.events) {
+    const key = event.kind;
+    grouped.set(key, [...(grouped.get(key) ?? []), event]);
+  }
+  for (const [kind, events] of grouped) {
+    lines.push(formatTimelineSectionTitle(kind));
+    for (const event of events) {
+      const time = event.timestamp.slice(11, 16);
+      const confidence = event.confidence < 0.8 ? ` likely (${event.confidence.toFixed(2)})` : "";
+      lines.push(`  ${time} ${event.title}${confidence}`);
+      const details = event.entities
+        .filter((entity) => entity.role !== "primary")
+        .slice(0, 4)
+        .map((entity) => `${entity.kind}:${entity.name}`);
+      if (details.length > 0) {
+        lines.push(`       ${details.join(", ")}`);
+      }
+    }
+    lines.push("");
+  }
+  if (Object.keys(timeline.currentState).length > 0) {
+    lines.push("Current state");
+    for (const [key, value] of Object.entries(timeline.currentState)) {
+      if (value !== undefined) {
+        lines.push(`  ${key}: ${Array.isArray(value) ? value.join(", ") : String(value)}`);
+      }
+    }
+    lines.push("");
+  }
+  if (timeline.causalEdges.length > 0) {
+    lines.push("Causality");
+    for (const edge of timeline.causalEdges.slice(0, 8)) {
+      lines.push(`  ${edge.kind}: ${edge.from} -> ${edge.to} (${edge.confidence.toFixed(2)})`);
+    }
+    lines.push("");
+  }
+  if (timeline.openQuestions.length > 0) {
+    lines.push("Open questions");
+    for (const question of timeline.openQuestions) {
+      lines.push(`  ${question}`);
+    }
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+export function formatDeltaTimelineJson(result: DeltaTimelineResult): string {
+  return `${JSON.stringify(result, null, 2)}\n`;
+}
+
+function formatTimelineSectionTitle(kind: string): string {
+  return kind
+    .split(".")
+    .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+    .join(" ");
+}

package/src/forge/dev/server.ts

@@ -582,6 +582,7 @@ async function buildAiSdkTools(input: {
   telemetry: ReturnType<typeof createTelemetryContext> | ReturnType<typeof createNoopTelemetryContext>;
   env: Record<string, string | undefined>;
   auth: Awaited<ReturnType<typeof authenticateHeaders>>;
+  deltaRecorder?: DevServerOptions["deltaRecorder"];
 }): Promise<Record<string, unknown>> {
   const { tool } = await import("ai");
   return Object.fromEntries(
@@ -632,6 +633,13 @@ async function buildAiSdkTools(input: {
                 latencyMs: Date.now() - startedAt,
                 status: "completed",
               });
+              await input.deltaRecorder?.recordAgentTool({
+                toolName: name,
+                risk: definition.risk ?? "external",
+                status: "completed",
+                traceId: input.traceId,
+                durationMs: Date.now() - startedAt,
+              });
               return output;
             } catch (error) {
               await input.telemetry.capture("forge.ai.tool.failed", {
@@ -644,6 +652,13 @@ async function buildAiSdkTools(input: {
                 status: "failed",
                 error: error instanceof Error ? error.message : String(error),
               });
+              await input.deltaRecorder?.recordAgentTool({
+                toolName: name,
+                risk: definition.risk ?? "external",
+                status: "failed",
+                traceId: input.traceId,
+                durationMs: Date.now() - startedAt,
+              });
               throw error;
             }
           },
@@ -671,6 +686,7 @@ export async function startDevServer(
   options: DevServerOptions,
 ): Promise<DevServerHandle> {
   const workspaceRoot = options.workspaceRoot.replace(/\\/g, "/");
+  const deltaRecorder = options.deltaRecorder;
   const authConfig = loadAuthConfigFromEnv(workspaceRoot, {
     defaultMode: "dev-headers",
   });
@@ -1344,6 +1360,7 @@ export async function startDevServer(
               telemetry,
               env: envStore.snapshot(),
               auth,
+              deltaRecorder,
             });
             const { ToolLoopAgent, createAgentUIStreamResponse, hasToolCall, stepCountIs } = await import("ai");
             const stopWhen =
@@ -1714,6 +1731,14 @@ export async function startDevServer(
             const policyDenied = result.diagnostics.some(
               (diagnostic) => diagnostic.code === FORGE_POLICY_DENIED,
             );
+            await deltaRecorder?.recordRuntimeCall({
+              entryName: `${externalInvoke.serviceName}.${externalInvoke.entryName}`,
+              entryKind: externalInvoke.kind,
+              service: externalInvoke.serviceName,
+              result: policyDenied ? "denied" : result.ok ? "success" : "failed",
+              diagnostics: result.diagnostics,
+              traceId: result.traceId,
+            });
             return jsonResponse(
               {
                 ok: result.ok,
@@ -1775,6 +1800,13 @@ export async function startDevServer(
             const policyDenied = result.diagnostics.some(
               (diagnostic) => diagnostic.code === FORGE_POLICY_DENIED,
             );
+            await deltaRecorder?.recordRuntimeCall({
+              entryName: queryName,
+              entryKind: "query",
+              result: policyDenied ? "denied" : result.ok ? "success" : "failed",
+              diagnostics: result.diagnostics,
+              traceId: result.traceId,
+            });
 
             return jsonResponse(
               {
@@ -1845,6 +1877,13 @@ export async function startDevServer(
             const policyDenied = result.diagnostics.some(
               (diagnostic) => diagnostic.code === FORGE_POLICY_DENIED,
             );
+            await deltaRecorder?.recordRuntimeCall({
+              entryName,
+              entryKind: entry.kind,
+              result: policyDenied ? "denied" : result.ok ? "success" : "failed",
+              diagnostics: result.diagnostics,
+              traceId: result.traceId,
+            });
 
             if (policyDenied) {
               const denied = result.diagnostics.find(

package/src/forge/dev/types.ts

@@ -1,5 +1,6 @@
 import type { DevRoute } from "../compiler/types/dev-manifest.ts";
 import type { DbAdapter } from "../runtime/db/adapter.ts";
+import type { AmbientDeltaRecorder } from "../delta/recorder.ts";
 
 export type DevDbMode = "memory" | "pglite" | "postgres" | "none";
 
@@ -18,6 +19,7 @@ export interface DevServerOptions {
   mode?: "dev" | "serve";
   allowDevAuth?: boolean;
   webUrl?: string;
+  deltaRecorder?: AmbientDeltaRecorder;
 }
 
 export interface DevServerDbState {

package/src/forge/dev/watch.ts

@@ -21,28 +21,38 @@ export function shouldSkipWatchPath(absolutePath: string): boolean {
 
 export function createDebouncedCallback(
   debounceMs: number,
-  callback: (changedCount: number) => void | Promise<void>,
-): (increment?: number) => void {
+  callback: (changedCount: number, changedPaths: string[]) => void | Promise<void>,
+): (incrementOrPath?: number | string) => void {
   let pendingChanges = 0;
+  const pendingPaths = new Set<string>();
   let timer: ReturnType<typeof setTimeout> | null = null;
 
-  return (increment = 1) => {
-    pendingChanges += increment;
+  return (incrementOrPath) => {
+    if (typeof incrementOrPath === "number") {
+      pendingChanges += incrementOrPath;
+    } else {
+      pendingChanges += 1;
+    }
+    if (typeof incrementOrPath === "string") {
+      pendingPaths.add(incrementOrPath);
+    }
     if (timer !== null) {
       clearTimeout(timer);
     }
     timer = setTimeout(async () => {
       const count = pendingChanges;
+      const paths = [...pendingPaths].sort();
       pendingChanges = 0;
+      pendingPaths.clear();
       timer = null;
-      await callback(count);
+      await callback(count, paths);
     }, debounceMs);
   };
 }
 
 export function startDevWatch(
   workspaceRoot: string,
-  onRegenerate: (changedCount: number) => void | Promise<void>,
+  onRegenerate: (changedCount: number, changedPaths: string[]) => void | Promise<void>,
 ): DevWatchHandle {
   const roots = getSourceRoots(workspaceRoot);
   const watchers: FSWatcher[] = [];
@@ -71,7 +81,7 @@ export function startDevWatch(
             return;
           }
 
-          debounced();
+          debounced(relativePath);
         },
       );
 

package/src/forge/version.ts

@@ -1,3 +1,3 @@
-export const FORGEOS_VERSION = "0.1.0-alpha.11";
+export const FORGEOS_VERSION = "0.1.0-alpha.13";
 export const GENERATOR_VERSION = FORGEOS_VERSION;
 export const CLI_VERSION = FORGEOS_VERSION;