ds4-context-engine 0.1.2 → 0.2.0-beta.1

package/src/pi-adapter/ranking-adapter.ts

@@ -0,0 +1,72 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import {
+  RANKING_FEEDBACK_CUSTOM_ENTRY_TYPE,
+  parseRankingFeedback,
+  rankingTrainingSample,
+  type RankingFeedbackEntry,
+  type RankingTrainingSample,
+} from "ds4-context-core/ranking/learned-ranker";
+
+const MAX_RANKING_LABEL_WARNINGS = 100;
+
+export interface RankingLabelProjection {
+  entries: RankingFeedbackEntry[];
+  samples: RankingTrainingSample[];
+  malformedEntries: number;
+  duplicateEntries: number;
+  warnings: string[];
+}
+
+export function projectRankingLabels(
+  entries: readonly SessionEntry[],
+  maxSamples: number,
+): RankingLabelProjection {
+  if (!Number.isSafeInteger(maxSamples) || maxSamples < 1) {
+    throw new Error("Ranking label projection limit must be a positive integer");
+  }
+  const accepted: RankingFeedbackEntry[] = [];
+  let acceptedCursor = 0;
+  const seen = new Set<string>();
+  const warnings: string[] = [];
+  let malformedEntries = 0;
+  let duplicateEntries = 0;
+
+  for (const entry of entries) {
+    if (entry.type !== "custom" || entry.customType !== RANKING_FEEDBACK_CUSTOM_ENTRY_TYPE) continue;
+    const parsed = parseRankingFeedback(entry.data);
+    if (!parsed) {
+      malformedEntries++;
+      if (warnings.length < MAX_RANKING_LABEL_WARNINGS) {
+        warnings.push(`Ignored malformed ranking feedback custom entry ${entry.id}`);
+      }
+      continue;
+    }
+    if (seen.has(parsed.feedbackId)) {
+      duplicateEntries++;
+      if (warnings.length < MAX_RANKING_LABEL_WARNINGS) {
+        warnings.push(`Ignored duplicate ranking feedback ${parsed.feedbackId} at ${entry.id}`);
+      }
+      continue;
+    }
+    if (accepted.length < maxSamples) {
+      seen.add(parsed.feedbackId);
+      accepted.push(parsed);
+    } else {
+      const replaced = accepted[acceptedCursor];
+      if (replaced) seen.delete(replaced.feedbackId);
+      seen.add(parsed.feedbackId);
+      accepted[acceptedCursor] = parsed;
+      acceptedCursor = (acceptedCursor + 1) % maxSamples;
+    }
+  }
+
+  const bounded = accepted
+    .sort((left, right) => left.createdAt - right.createdAt || left.feedbackId.localeCompare(right.feedbackId));
+  return {
+    entries: bounded,
+    samples: bounded.map(rankingTrainingSample),
+    malformedEntries,
+    duplicateEntries,
+    warnings,
+  };
+}

package/src/pi-adapter/runtime-contract.ts

@@ -0,0 +1,86 @@
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import {
+  RUNTIME_CAPABILITY_IDS,
+  RUNTIME_HISTORY_SCHEMA_VERSION,
+  buildCanonicalToolAtomicGroups,
+  negotiateRuntimeCapabilities,
+  validateRuntimeHistorySnapshot,
+  type RuntimeCapabilityDeclaration,
+  type RuntimeCapabilityNegotiation,
+  type RuntimeCapabilityRequest,
+  type RuntimeHistorySnapshot,
+} from "ds4-context-core/adapter/runtime-adapter";
+import { sha256 } from "ds4-context-core/shared/hash";
+import { stableStringify } from "ds4-context-core/shared/stable-json";
+import {
+  sessionEntryToContextMessages,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { toCanonicalMessage } from "./message-converter.ts";
+
+export const PI_RUNTIME_ID = "pi";
+
+export const PI_RUNTIME_CAPABILITIES: readonly RuntimeCapabilityDeclaration[] = [
+  { id: "compaction", supported: true, version: "pi-session-compact-v1" },
+  { id: "provider-continuation", supported: true, version: "pi-openai-responses-continuation-v1" },
+  { id: "embeddings", supported: true, version: "embedding-port-v1" },
+  {
+    id: "local-kv-reuse",
+    supported: false,
+    reason: "Pi does not expose reusable local prefix or KV state",
+  },
+];
+
+function canonicalProjectRoot(path: string): string {
+  const absolute = resolve(path);
+  try {
+    return realpathSync.native(absolute);
+  } catch {
+    return absolute;
+  }
+}
+
+export function negotiatePiRuntimeCapabilities(
+  requested: readonly RuntimeCapabilityRequest[] = RUNTIME_CAPABILITY_IDS.map((id) => ({ id })),
+): RuntimeCapabilityNegotiation {
+  return negotiateRuntimeCapabilities(PI_RUNTIME_CAPABILITIES, requested);
+}
+
+/**
+ * Projects Pi's active, compaction-aware branch without modifying canonical JSONL.
+ * The snapshot is suitable for shared adapter-contract validation and diagnostics.
+ */
+export function snapshotPiRuntimeHistory(
+  ctx: Pick<ExtensionContext, "cwd" | "isProjectTrusted" | "sessionManager">,
+): RuntimeHistorySnapshot {
+  if (!ctx.isProjectTrusted()) {
+    throw new Error("Pi project root is not trusted");
+  }
+  const sessionId = ctx.sessionManager.getSessionId();
+  const entries = ctx.sessionManager.buildContextEntries();
+  const messages = entries.flatMap((entry) => sessionEntryToContextMessages(entry).map((message) =>
+    toCanonicalMessage({
+      sessionId,
+      entryId: entry.id,
+      entryTimestamp: entry.timestamp,
+      message,
+    })));
+  const snapshot: RuntimeHistorySnapshot = {
+    schemaVersion: RUNTIME_HISTORY_SCHEMA_VERSION,
+    runtimeId: PI_RUNTIME_ID,
+    sessionId,
+    revision: sha256(stableStringify({
+      leafId: ctx.sessionManager.getLeafId(),
+      entries,
+    })),
+    projectRoot: canonicalProjectRoot(ctx.cwd),
+    messages,
+    toolAtomicGroups: buildCanonicalToolAtomicGroups(messages),
+  };
+  const issues = validateRuntimeHistorySnapshot(snapshot);
+  if (issues.length > 0) {
+    throw new Error(`Pi canonical history snapshot failed validation: ${issues.length} issue(s)`);
+  }
+  return snapshot;
+}

package/src/pi-adapter/version.ts

@@ -1,5 +1,5 @@
-export const EXTENSION_VERSION = "0.1.2";
+export const EXTENSION_VERSION = "0.2.0-beta.1";
 export const SUPPORTED_PI_VERSION = "0.84.3";
 export const OBSERVER_PLANNER_VERSION = "observer-model-aware-v1";
-export const PLANNER_VERSION = "managed-native-continuation-v1";
-export const POLICY_VERSION = "8";
+export const PLANNER_VERSION = "managed-learned-ranking-v1";
+export const POLICY_VERSION = "9";