@pstdio/sdk 0.25.0 → 0.36.0

package/dist/data/index.js

@@ -3,10 +3,10 @@ var assertSafePathSegment = (value) => {
   if (!value || value === "." || value === ".." || /[/\\\0]/.test(value))
     throw new Error(`Unsafe path segment: ${value}`);
 };
-var requireRepoFiles = (repoFiles) => {
-  if (!repoFiles)
-    throw new Error("This command must be run inside a project repository.");
-  return repoFiles;
+var requireRepoFiles = (projectFiles) => {
+  if (!projectFiles)
+    throw new Error("This command must be run inside a project folder.");
+  return projectFiles;
 };
 var createDraftLayout = (root, document) => {
   const directory = (name) => {

package/dist/data.d.ts

@@ -1,49 +1,27 @@
-export declare const applyFrontmatter: (frontmatter: string, content: string) => string;
-
-declare interface ArtifactFile {
-    path: string;
-    size?: number;
-    updatedAt?: string;
-}
-
-declare interface ArtifactMount {
-    exists(path: string): Promise<boolean>;
-    readText(path: string): Promise<string>;
-    writeText(path: string, value: string): Promise<void>;
-    /** Replace existing text. Fails if missing and never recreates a concurrently deleted file. */
-    updateText(path: string, value: string): Promise<void>;
-    readBytes(path: string): Promise<Uint8Array>;
-    writeBytes(path: string, value: Uint8Array): Promise<void>;
-    list(pattern?: string): Promise<ArtifactFile[]>;
-    listDirs(path?: string): Promise<string[]>;
-    delete(path: string): Promise<void>;
-}
-
-export declare const assertSafePathSegment: (value: string) => void;
-
-export declare const createDraftLayout: (root: string, document: string) => {
-    directory: (name: string) => string;
-    markdown: (name: string, suffix?: string) => string;
-    files: (name: string, suffix?: string) => string;
-};
-
-export declare const findClosingFrontmatterDelimiter: (content: string) => {
-    end: number;
-    start: number;
-} | null;
-
-export declare const quoteYamlScalar: (value: string) => string;
-
-export declare const requireRepoFiles: (repoFiles: ArtifactMount | undefined) => ArtifactMount;
-
-export declare const resolveByIdOrName: <TItem extends {
-    id: string;
-}>(items: TItem[], value: string, nameOf: (item: TItem) => string, label: string) => string;
-
-export declare const sameName: (a: string, b: string) => boolean;
-
-export declare const stripFrontmatter: (content: string) => string;
-
-export declare const unquoteYamlScalar: (value: string) => string;
-
-export { }
+import { Ir as ArtifactMount } from "./index-CR17_9lz.js";
+//#region src/data/draft-layout.d.ts
+export declare const assertSafePathSegment: (value: string) => void;
+export declare const requireRepoFiles: (projectFiles: ArtifactMount | undefined) => ArtifactMount;
+export declare const createDraftLayout: (root: string, document: string) => {
+  directory: (name: string) => string;
+  markdown: (name: string, suffix?: string) => string;
+  files: (name: string, suffix?: string) => string;
+};
+//#endregion
+//#region src/data/frontmatter.d.ts
+export declare const quoteYamlScalar: (value: string) => string;
+export declare const findClosingFrontmatterDelimiter: (content: string) => {
+  end: number;
+  start: number;
+} | null;
+export declare const stripFrontmatter: (content: string) => string;
+export declare const applyFrontmatter: (frontmatter: string, content: string) => string;
+export declare const unquoteYamlScalar: (value: string) => string;
+//#endregion
+//#region src/data/resolve.d.ts
+export declare const sameName: (a: string, b: string) => boolean;
+export declare const resolveByIdOrName: <TItem extends {
+  id: string;
+}>(items: TItem[], value: string, nameOf: (item: TItem) => string, label: string) => string;
+//#endregion
+export {};

package/dist/extensions/index.js

@@ -1,3 +1,7 @@
+// ../pstdio-api-contracts/src/extension-kernel/api-versions.ts
+var numericIdentifier = "(?:0|[1-9]\\d*)";
+var prereleaseIdentifier = `(?:${numericIdentifier}|\\d*[A-Za-z-][0-9A-Za-z-]*)`;
+var exactVersion = new RegExp(`^${numericIdentifier}\\.${numericIdentifier}\\.${numericIdentifier}(?:-${prereleaseIdentifier}(?:\\.${prereleaseIdentifier})*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$`);
 // ../pstdio-api-contracts/src/extension-kernel/types/composition.ts
 var dockedWorkbenchRegions = ["sidenav", "main", "secondary", "side"];
 var extensionPanelRegions = ["main", "secondary", "side"];
@@ -133,6 +137,11 @@ var workspaceSlots = {
 var projectEvents = {
   opened: hostEventRef("project.opened")
 };
+var viewDataEvents = {
+  sessionsChanged: hostEventRef("view.sessions.changed"),
+  workspacesChanged: hostEventRef("view.workspaces.changed"),
+  repositoriesChanged: hostEventRef("view.repositories.changed")
+};
 var sessionEvents = {
   started: hostEventRef("session.started"),
   resumed: hostEventRef("session.resumed"),
@@ -262,7 +271,7 @@ var packageAsset = (path, baseUrl) => ({
   baseUrl
 });
 // ../pstdio-api-contracts/src/extension-kernel/types/extension.ts
-var EXTENSION_API_VERSION = "1.0.0-alpha.10";
+var EXTENSION_API_VERSION = "1.0.0-alpha.13";
 // ../pstdio-api-contracts/src/extension-kernel/types/webview-capabilities.ts
 var WEBVIEW_HOST_CAPABILITY_VERSION = 1;
 var WEBVIEW_DECLARABLE_CAPABILITIES = [
@@ -291,8 +300,186 @@ var WEBVIEW_HOST_CAPABILITIES = [
   ...WEBVIEW_SCOPED_DECLARABLE_CAPABILITIES,
   ...ALWAYS_AVAILABLE_WEBVIEW_CAPABILITIES
 ];
+// ../pstdio-api-contracts/src/history-turn-evidence.ts
+var historyTurnEvidence = (known, native, prompt, body) => {
+  const signatures = (turn) => JSON.stringify([prompt(turn), body(turn)]);
+  if (known.length === native.length && known.every((turn, index) => signatures(turn) === signatures(native[index]))) {
+    return signatures;
+  }
+  const tokens = (turns) => {
+    const positions = new Map;
+    turns.forEach((turn, index) => {
+      for (const value of new Set(body(turn))) {
+        const token = JSON.stringify([prompt(turn), value]);
+        positions.set(token, positions.has(token) ? -1 : index);
+      }
+    });
+    return positions;
+  };
+  const left = tokens(known);
+  const right = tokens(native);
+  const matches = new Map;
+  const reverse = new Map;
+  for (const [token, index] of left) {
+    const other = right.get(token);
+    if (index < 0 || other === undefined || other < 0)
+      continue;
+    const targets = matches.get(index) ?? new Set;
+    targets.add(other);
+    matches.set(index, targets);
+    const sources = reverse.get(other) ?? new Set;
+    sources.add(index);
+    reverse.set(other, sources);
+  }
+  const keys = new Map;
+  known.forEach((turn, index) => {
+    keys.set(turn, `known:${index}`);
+  });
+  native.forEach((turn, index) => {
+    keys.set(turn, `native:${index}`);
+  });
+  for (const [index, targets] of matches) {
+    if (targets.size !== 1)
+      continue;
+    const other = [...targets][0];
+    if (reverse.get(other)?.size !== 1)
+      continue;
+    const key = `pair:${index}:${other}`;
+    keys.set(known[index], key);
+    keys.set(native[other], key);
+  }
+  return (turn) => keys.get(turn);
+};
+
+// ../pstdio-api-contracts/src/history-reconciliation.ts
+class HistoryConflict extends Error {
+}
+var submittedPrompt = (message) => message.parts.filter((part) => part.type === "text").map((part) => part.text).join(`
+`).replace(/\n\n<session-attachments>[\s\S]*<\/session-attachments>\s*$/, "").trim();
+var historyValueKey = (value) => JSON.stringify(value, (_key, item) => {
+  if (!item || typeof item !== "object" || Array.isArray(item))
+    return item;
+  return Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b)));
+});
+var historyMessageKey = (message) => historyValueKey([message.role, message.parts]);
+var positions = (items, key) => {
+  const result = new Map;
+  items.forEach((item, index) => {
+    const value = key(item);
+    const indices = result.get(value) ?? [];
+    indices.push(index);
+    result.set(value, indices);
+  });
+  return result;
+};
+var mergeOrderedHistory = (known, native, key, merge, refineKey) => {
+  if (!known.length)
+    return native;
+  if (!native.length)
+    return known;
+  const knownPositions = positions(known, key);
+  const nativePositions = positions(native, key);
+  const anchors = [];
+  for (const [value, indices] of knownPositions) {
+    const other = nativePositions.get(value);
+    if (indices.length === 1 && other?.length === 1)
+      anchors.push([indices[0], other[0]]);
+  }
+  if (!anchors.length) {
+    if (refineKey) {
+      const refined = mergeOrderedHistory(known, native, refineKey(known, native), merge);
+      return refined;
+    }
+    const paired = Math.min(known.length, native.length);
+    if (known.slice(0, paired).every((item, index) => key(item) === key(native[index]))) {
+      return [
+        ...known.slice(0, paired).map((item, index) => merge(item, native[index])),
+        ...known.slice(paired),
+        ...native.slice(paired)
+      ];
+    }
+    throw new HistoryConflict("ambiguous_interval");
+  }
+  let left = 0;
+  let right = 0;
+  const result = [];
+  for (const [a, b] of anchors) {
+    if (b < right)
+      throw new HistoryConflict("conflicting_order");
+    result.push(...mergeOrderedHistory(known.slice(left, a), native.slice(right, b), key, merge, refineKey));
+    result.push(merge(known[a], native[b]));
+    left = a + 1;
+    right = b + 1;
+  }
+  result.push(...mergeOrderedHistory(known.slice(left), native.slice(right), key, merge, refineKey));
+  return result;
+};
+var splitHistoryTurns = (messages) => {
+  const turns = [];
+  for (const message of messages) {
+    if (message.role === "user" || !turns.length)
+      turns.push([]);
+    turns[turns.length - 1].push(message);
+  }
+  return turns;
+};
+var mergeHistoryMetadata = (known, native) => {
+  const files = native.parts.filter((part) => part.type === "file");
+  const fileKeys = new Set(files.map((part) => part.fileId ?? part.url));
+  const missing = known.parts.filter((part) => part.type === "file" && !fileKeys.has(part.fileId ?? part.url));
+  const parts = native.role === "user" ? [...known.parts.filter((part) => part.type === "text"), ...native.parts.filter((part) => part.type !== "text")] : native.parts;
+  return { ...known, ...native, parts: [...parts, ...missing] };
+};
+var isUsage = (message) => message.role === "system" && message.parts.length > 0 && message.parts.every((part) => part.type === "token_usage");
+var combineTextRuns = (messages) => {
+  const runs = [];
+  for (const message of messages) {
+    const previous = runs.at(-1);
+    const part = message.parts[0];
+    const previousPart = previous?.parts[0];
+    if (previous && message.role === previous.role && message.parts.length === 1 && previous.parts.length === 1 && (part.type === "text" || part.type === "reasoning") && previousPart?.type === part.type) {
+      runs[runs.length - 1] = { ...previous, parts: [{ ...part, text: previousPart.text + part.text }] };
+    } else
+      runs.push(message);
+  }
+  return runs;
+};
+var reconcileMessageHistory = (input, projection = {}) => {
+  const key = projection.key ?? historyMessageKey;
+  const merge = projection.merge ?? mergeHistoryMetadata;
+  const generated = projection.isGenerated ?? isUsage;
+  const mergeTurn = (known, native) => {
+    const startsWithUser = known[0]?.role === "user" && native[0]?.role === "user";
+    const body = (turn) => combineTextRuns(turn.slice(startsWithUser ? 1 : 0).filter((message) => !generated(message)));
+    const messages = mergeOrderedHistory(body(known), body(native), key, merge);
+    const metadata = [...native.filter(generated)];
+    const counts = new Map;
+    metadata.forEach((message) => {
+      counts.set(historyMessageKey(message), (counts.get(historyMessageKey(message)) ?? 0) + 1);
+    });
+    for (const message of known.filter(generated)) {
+      const value = historyMessageKey(message);
+      const remaining = counts.get(value) ?? 0;
+      if (remaining)
+        counts.set(value, remaining - 1);
+      else
+        metadata.push(message);
+    }
+    return [...startsWithUser ? [mergeHistoryMetadata(known[0], native[0])] : [], ...messages, ...metadata];
+  };
+  try {
+    const prompt = (turn) => turn[0]?.role === "user" ? `user:${submittedPrompt(turn[0])}` : "prefix";
+    const turns = mergeOrderedHistory(splitHistoryTurns(input.knownMessages), splitHistoryTurns(input.nativeMessages), prompt, mergeTurn, (known, native) => historyTurnEvidence(known, native, prompt, (turn) => combineTextRuns(turn.slice(1).filter((message) => !generated(message))).map(key)));
+    const messages = turns.flat().map((message, index) => message.index === undefined ? message : { ...message, index });
+    return { kind: "recovered", messages };
+  } catch (error) {
+    if (error instanceof HistoryConflict)
+      return { kind: "conflict", category: error.message };
+    throw error;
+  }
+};
 // package.json
-var version = "0.25.0";
+var version = "0.36.0";
 
 // src/version.ts
 var SDK_VERSION = version;
@@ -609,7 +796,6 @@ var params = {
     type: "multi-select",
     ...options
   }),
-  repo: (options) => ({ type: "repo", ...options }),
   harness: (options) => ({ type: "harness", ...options }),
   template: (options) => {
     const { type: templateType, ...rest } = options;
@@ -732,7 +918,8 @@ var createWebviewClient = (host, options) => {
   const runCommand = async (commandKey, params) => {
     const response = await host.call("commands.execute", {
       commandId: `${extensionId}.command.${commandKey}`,
-      params
+      params,
+      ...options?.workspaceId ? { workspaceId: options.workspaceId } : {}
     });
     return unwrapCommandOutcome(response);
   };
@@ -776,6 +963,7 @@ export {
   ALWAYS_AVAILABLE_WEBVIEW_CAPABILITIES,
   EXTENSION_API_VERSION,
   EXTENSION_EVENTS_SCOPE,
+  HistoryConflict,
   SDK_VERSION,
   WEBVIEW_DECLARABLE_CAPABILITIES,
   WEBVIEW_HOST_CAPABILITIES,
@@ -824,6 +1012,8 @@ export {
   eventRef,
   extensionPanelRegions,
   gitEvents,
+  historyMessageKey,
+  historyValueKey,
   isLocalizedString,
   isNavigationTarget,
   isValidLocalContributionId,
@@ -832,6 +1022,8 @@ export {
   localContributionIdGrammar,
   localContributionIdPattern,
   matchesResourceWhen,
+  mergeHistoryMetadata,
+  mergeOrderedHistory,
   packageAsset,
   params,
   parsePageUrl,
@@ -841,6 +1033,7 @@ export {
   projectSlots,
   qualifyNavigationTarget,
   qualifyRef,
+  reconcileMessageHistory,
   resolveEventReferenceId,
   resourceKey,
   resourceMenuSlotRef2 as resourceMenuSlotRef,
@@ -848,7 +1041,10 @@ export {
   serializeWorkbenchPageUrl,
   sessionEvents,
   sessionSlots,
+  splitHistoryTurns,
+  submittedPrompt,
   unwrapCommandOutcome,
+  viewDataEvents,
   workbenchModeDefinitions,
   workbenchModes,
   workbenchPageDefinitions,

package/dist/extensions-react.d.ts

@@ -1,23 +1,18 @@
-import { QueryKey } from '@tanstack/react-query';
-import { UseMutationResult } from '@tanstack/react-query';
-import { UseQueryResult } from '@tanstack/react-query';
-
-declare interface CommandMutationInput<TParams, TResult> {
-    command: (params: TParams) => Promise<TResult>;
-    invalidate?: QueryKey[];
-}
-
-declare interface CommandQueryInput<TResult> {
-    queryKey: QueryKey;
-    command: () => Promise<TResult>;
-    enabled?: boolean;
-    staleTime?: number;
-}
-
-/** Writes server state via a typed client command and refreshes affected queries on success. */
-export declare const useCommandMutation: <TParams, TResult>(input: CommandMutationInput<TParams, TResult>) => UseMutationResult<TResult, Error, TParams, unknown>;
-
-/** Reads server state via a typed client command, cached and deduped by react-query. */
-export declare const useCommandQuery: <TResult>(input: CommandQueryInput<TResult>) => UseQueryResult<TResult>;
-
-export { }
+import { QueryKey, UseQueryResult } from "@tanstack/react-query";
+//#region src/extensions/react/index.d.ts
+interface CommandQueryInput<TResult> {
+  queryKey: QueryKey;
+  command: () => Promise<TResult>;
+  enabled?: boolean;
+  staleTime?: number;
+}
+/** Reads server state via a typed client command, cached and deduped by react-query. */
+export declare const useCommandQuery: <TResult>(input: CommandQueryInput<TResult>) => UseQueryResult<TResult>;
+interface CommandMutationInput<TParams, TResult> {
+  command: (params: TParams) => Promise<TResult>;
+  invalidate?: QueryKey[];
+}
+/** Writes server state via a typed client command and refreshes affected queries on success. */
+export declare const useCommandMutation: <TParams, TResult>(input: CommandMutationInput<TParams, TResult>) => import("@tanstack/react-query").UseMutationResult<TResult, Error, TParams, unknown>;
+//#endregion
+export {};