@hassangameryt/freeflow 0.4.0 → 0.6.0

package/pi-extension/src/freeflow-context/resolver.ts

@@ -0,0 +1,139 @@
+import { entryIdFromContextRef } from "./types.js";
+import type { ContextSourceKind, ResolvedContextEntry, ResolvedContextSource } from "./types.js";
+
+export function isToolResultEntry(entry: any): boolean {
+  return entry?.type === "message" && entry?.message?.role === "toolResult";
+}
+
+export class ContextSourceResolver {
+  private ctx: any;
+
+  constructor(ctx: any) {
+    this.ctx = ctx;
+  }
+
+  setContext(ctx: any): void {
+    this.ctx = ctx;
+  }
+
+  sessionId(): string {
+    const value = this.ctx?.sessionManager?.getSessionId?.() ?? this.ctx?.sessionId ?? this.ctx?.cwd ?? "current";
+    return String(value);
+  }
+
+  branchLeafId(): string | null | undefined {
+    try {
+      return this.ctx?.sessionManager?.getLeafId?.();
+    } catch {
+      return undefined;
+    }
+  }
+
+  branchEntries(): any[] {
+    const entries = this.ctx?.sessionManager?.getBranch?.() ?? this.ctx?.sessionManager?.getEntries?.() ?? [];
+    return Array.isArray(entries) ? entries : [];
+  }
+
+  activeContextEntries(): any[] {
+    try {
+      const entries = this.ctx?.sessionManager?.buildContextEntries?.() ?? this.branchEntries();
+      return Array.isArray(entries) ? entries : [];
+    } catch {
+      return this.branchEntries();
+    }
+  }
+
+  activeContextEntriesStrict(): any[] {
+    const manager = this.ctx?.sessionManager;
+    if (typeof manager?.buildContextEntries !== "function") return this.branchEntries();
+    const entries = manager.buildContextEntries();
+    if (!Array.isArray(entries)) throw new Error("active_context_entries_unavailable");
+    return entries;
+  }
+
+  resolvedEntriesById(entries = this.branchEntries(), sessionId = this.sessionId()): Map<string, ResolvedContextEntry> {
+    const result = new Map<string, ResolvedContextEntry>();
+    for (const entry of entries) {
+      const resolved = this.entryFromSessionEntry(entry, sessionId);
+      if (resolved) result.set(resolved.source.entryId, resolved);
+    }
+    return result;
+  }
+
+  toolResultSources(entries = this.branchEntries(), sessionId = this.sessionId()): Map<string, ResolvedContextSource> {
+    const grouped = new Map<string, ResolvedContextSource[]>();
+    for (const entry of entries) {
+      const source = this.sourceFromEntry(entry, sessionId);
+      if (!source) continue;
+      const group = grouped.get(source.source.toolCallId!) ?? [];
+      group.push(source);
+      grouped.set(source.source.toolCallId!, group);
+    }
+
+    const unique = new Map<string, ResolvedContextSource>();
+    for (const [toolCallId, sources] of grouped) {
+      if (sources.length === 1) unique.set(toolCallId, sources[0]);
+    }
+    return unique;
+  }
+
+  sourcesByEntryId(entries = this.branchEntries(), sessionId = this.sessionId()): Map<string, ResolvedContextSource> {
+    const result = new Map<string, ResolvedContextSource>();
+    for (const source of this.toolResultSources(entries, sessionId).values()) {
+      result.set(source.source.entryId, source);
+    }
+    return result;
+  }
+
+  activeToolResultIds(): Set<string> {
+    const ids = new Set<string>();
+    for (const entry of this.activeContextEntries()) {
+      if (isToolResultEntry(entry) && typeof entry.id === "string") ids.add(entry.id);
+    }
+    return ids;
+  }
+
+  resolveCurrent(ref: unknown): ResolvedContextEntry | undefined {
+    const entryId = entryIdFromContextRef(ref);
+    if (!entryId) return undefined;
+    const entry = this.branchEntries().find((candidate) => candidate?.id === entryId);
+    return entry ? this.entryFromSessionEntry(entry, this.sessionId()) : undefined;
+  }
+
+  private sourceFromEntry(entry: any, sessionId: string): ResolvedContextSource | undefined {
+    const resolved = this.entryFromSessionEntry(entry, sessionId);
+    return resolved?.kind === "toolResult" ? (resolved as ResolvedContextSource) : undefined;
+  }
+
+  private entryFromSessionEntry(entry: any, sessionId: string): ResolvedContextEntry | undefined {
+    if (!entry || typeof entry.id !== "string") return undefined;
+    const kind = this.kindForEntry(entry);
+    if (!kind) return undefined;
+    const message = entry.message;
+    const toolCallId =
+      kind === "toolResult" && typeof message?.toolCallId === "string" ? message.toolCallId : undefined;
+    return {
+      kind,
+      entry,
+      ...(message ? { message } : {}),
+      source: {
+        sessionId,
+        entryId: entry.id,
+        ...(toolCallId ? { toolCallId } : {}),
+        ...(typeof message?.toolName === "string" ? { toolName: message.toolName } : {}),
+      },
+    };
+  }
+
+  private kindForEntry(entry: any): ContextSourceKind | undefined {
+    if (entry.type === "custom") return "custom";
+    if (entry.type === "compaction" || entry.type === "branch_summary") return "summary";
+    if (entry.type !== "message") return undefined;
+    if (entry.message?.role === "user") return "user";
+    if (entry.message?.role === "assistant") return "assistant";
+    if (entry.message?.role === "toolResult") return "toolResult";
+    if (entry.message?.role === "custom") return "custom";
+    if (entry.message?.role === "branchSummary" || entry.message?.role === "compactionSummary") return "summary";
+    return undefined;
+  }
+}

package/pi-extension/src/freeflow-context/runtime.ts

@@ -0,0 +1,100 @@
+import { buildContextVisibility } from "./visibility.js";
+import { ContextSourceResolver } from "./resolver.js";
+import { projectContextSource } from "./source-projector.js";
+import type {
+  ContextRequestSnapshot,
+  FreeflowContextSnapshot,
+  ProjectedContextSource,
+  ResolvedContextSource,
+} from "./types.js";
+
+export class FreeflowContextRuntime {
+  readonly resolver: ContextSourceResolver;
+  private ctx: any;
+  private generation = 0;
+  private latestRequestSnapshot: ContextRequestSnapshot | undefined;
+
+  constructor(ctx: any) {
+    this.ctx = ctx;
+    this.resolver = new ContextSourceResolver(ctx);
+  }
+
+  setContext(ctx: any): void {
+    this.ctx = ctx;
+    this.resolver.setContext(ctx);
+  }
+
+  sessionId(): string {
+    return this.resolver.sessionId();
+  }
+
+  branchLeafId(): string | null | undefined {
+    return this.resolver.branchLeafId();
+  }
+
+  branchEntries(): any[] {
+    return this.resolver.branchEntries();
+  }
+
+  resolveCurrent(ref: unknown) {
+    return this.resolver.resolveCurrent(ref);
+  }
+
+  recordRequest(refs: Map<string, ResolvedContextSource>): ContextRequestSnapshot {
+    this.generation += 1;
+    this.latestRequestSnapshot = {
+      generation: this.generation,
+      sessionId: this.sessionId(),
+      branchLeafId: this.branchLeafId(),
+      refs,
+    };
+    return this.latestRequestSnapshot;
+  }
+
+  clearRequest(): void {
+    this.latestRequestSnapshot = undefined;
+  }
+
+  latestRequest(): ContextRequestSnapshot | undefined {
+    return this.latestRequestSnapshot;
+  }
+
+  captureSnapshot(options: {
+    contextVirtualizationEnabled: boolean;
+    isSourceFullyProjected?: (entryId: string) => boolean;
+  }): FreeflowContextSnapshot {
+    const branchEntries = this.resolver.branchEntries();
+    const activeEntries = this.resolver.activeContextEntriesStrict();
+    const sessionId = this.sessionId();
+    const resolvedByEntryId = this.resolver.resolvedEntriesById(branchEntries, sessionId);
+    const visibility = buildContextVisibility(activeEntries, resolvedByEntryId, options);
+    const entries = new Map<string, ProjectedContextSource>();
+    let skippedEntries = 0;
+    for (let position = 0; position < branchEntries.length; position += 1) {
+      const entry = branchEntries[position];
+      if (typeof entry?.id !== "string") continue;
+      const resolved = resolvedByEntryId.get(entry.id);
+      if (!resolved) continue;
+      const outcome = projectContextSource({ ...resolved, entry: { ...resolved.entry, position } });
+      if (outcome.status === "eligible") entries.set(outcome.source.ref, outcome.source);
+      else if (
+        outcome.status === "invalid" &&
+        !visibility.visibleSourceIds.has(entry.id) &&
+        !visibility.materializedSourceIds.has(entry.id)
+      ) {
+        skippedEntries += 1;
+      }
+    }
+    const generation = this.latestRequestSnapshot?.generation ?? ++this.generation;
+    return {
+      generation,
+      sessionId,
+      branchLeafId: this.branchLeafId(),
+      visibleEntryIds: visibility.visibleEntryIds,
+      visibleSourceIds: visibility.visibleSourceIds,
+      materializedSourceIds: visibility.materializedSourceIds,
+      skippedEntries,
+      entries,
+    };
+  }
+}

package/pi-extension/src/freeflow-context/source-projector.ts

@@ -0,0 +1,106 @@
+import { isFreeflowContextToolName } from "./types.js";
+import type { ProjectedContextSource, ResolvedContextEntry, SourceProjectionOutcome } from "./types.js";
+
+function textFromContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts: string[] = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const value = block as Record<string, unknown>;
+    if (value.type === "text" && typeof value.text === "string") {
+      parts.push(value.text);
+    } else if (value.type === "image" && typeof value.mimeType === "string") {
+      parts.push(`[image:${value.mimeType}]`);
+    }
+  }
+  return parts.join("\n");
+}
+
+function timestampFor(source: ResolvedContextEntry): string {
+  const value = source.entry?.timestamp ?? source.message?.timestamp;
+  const timestamp = typeof value === "string" || typeof value === "number" ? new Date(value) : new Date(0);
+  return Number.isNaN(timestamp.getTime()) ? new Date(0).toISOString() : timestamp.toISOString();
+}
+
+function invalid(reason: string): SourceProjectionOutcome {
+  return { status: "invalid", reason };
+}
+
+function toolCallParts(
+  content: unknown,
+): { status: "ok"; text: string; names: string[] } | { status: "invalid"; reason: string } {
+  if (!Array.isArray(content)) return { status: "ok", text: "", names: [] };
+  const parts: string[] = [];
+  const names: string[] = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const value = block as Record<string, unknown>;
+    if (value.type !== "toolCall" && value.type !== "tool_use") continue;
+    const name = typeof value.name === "string" ? value.name.trim() : "";
+    if (!name) return { status: "invalid", reason: "tool_name_missing" };
+    if (name === "freeflow_context") continue;
+    if (name.length > 128) return { status: "invalid", reason: "tool_name_too_long" };
+    const args = value.arguments ?? value.input;
+    let renderedArgs = "";
+    if (args !== undefined) {
+      try {
+        const serialized = JSON.stringify(args);
+        if (serialized === undefined) return { status: "invalid", reason: "tool_arguments_unserializable" };
+        renderedArgs = `\n${serialized}`;
+      } catch {
+        return { status: "invalid", reason: "tool_arguments_unserializable" };
+      }
+    }
+    names.push(name);
+    parts.push(`Tool call: ${name}${renderedArgs}`);
+  }
+  return { status: "ok", text: parts.join("\n"), names };
+}
+
+export function projectContextSource(source: ResolvedContextEntry): SourceProjectionOutcome {
+  if (!source.entry || !source.source.entryId) return invalid("source_id_missing");
+  if (source.source.entryId.length > 256) return invalid("source_id_too_long");
+  if (source.kind === "custom") return { status: "excluded", reason: "custom_source" };
+
+  const message = source.message;
+  let text = "";
+  let toolNames: string[] = [];
+  let isError: boolean | undefined;
+
+  if (source.kind === "summary") {
+    text = typeof source.entry.summary === "string" ? source.entry.summary : textFromContent(message?.content);
+  } else if (source.kind === "toolResult") {
+    if (isFreeflowContextToolName(message?.toolName)) {
+      return { status: "excluded", reason: "freeflow_context_source" };
+    }
+    if (typeof message?.toolName !== "string" || message.toolName.trim().length === 0) {
+      return invalid("tool_name_missing");
+    }
+    const toolName = message.toolName.trim();
+    if (toolName.length > 128) return invalid("tool_name_too_long");
+    text = textFromContent(message.content);
+    toolNames = [toolName];
+    if (typeof message.isError === "boolean") isError = message.isError;
+  } else if (source.kind === "assistant") {
+    const calls = toolCallParts(message?.content);
+    if (calls.status === "invalid") return invalid(calls.reason);
+    text = [textFromContent(message?.content), calls.text].filter(Boolean).join("\n");
+    toolNames = calls.names;
+  } else if (source.kind === "user") {
+    text = textFromContent(message?.content);
+  }
+
+  if (!text.trim()) return { status: "excluded", reason: "empty_source" };
+  const projected: ProjectedContextSource = {
+    ref: `ctx:${source.source.entryId}`,
+    kind: source.kind,
+    text,
+    timestamp: timestampFor(source).slice(0, 64),
+    position: typeof source.entry.position === "number" ? source.entry.position : 0,
+    ...(toolNames.length > 0 ? { toolNames: [...new Set(toolNames)] } : {}),
+    ...(isError === undefined ? {} : { isError }),
+    source,
+  };
+  return { status: "eligible", source: projected };
+}