@omercnet/paseo-context-mode 3.1.3 → 3.1.4-next.434.1

package/shared/knowledge.ts

@@ -6,32 +6,29 @@ const MAX_PATH_LENGTH = 4_096;
 const MAX_LABEL_LENGTH = 512;
 const MAX_QUERY_LENGTH = 1_024;
 
-export const ContextModeProviderSchema = z.enum([
-  "claude",
-  "codex",
-  "copilot",
-  "cursor",
-  "opencode",
-  "pi",
-  "omp",
-  "omp-plugin",
-]);
-
-export const ContextModePlatformSchema = z.enum([
-  "claude-code",
-  "codex",
-  "copilot-cli",
-  "cursor",
-  "opencode",
-  "pi",
-  "omp",
-]);
-
 /** A Paseo provider id: a built-in or one configured in `agents.providers`. */
 export const KnowledgeProviderSchema = z.string().trim().min(1).max(128);
 
+/** The project store a knowledge action writes to, and the agent it is recorded as. */
+export interface KnowledgeDestination {
+  provider: string;
+  projectPath: string;
+}
+
+/** A finished action's result belongs to the destination it ran against, not to a later one. */
+export function sameDestination(
+  ran: KnowledgeDestination | undefined,
+  current: KnowledgeDestination | null,
+): boolean {
+  return (
+    ran !== undefined &&
+    current !== null &&
+    ran.provider === current.provider &&
+    ran.projectPath === current.projectPath
+  );
+}
+
 const boundedLabel = z.string().trim().min(1).max(MAX_LABEL_LENGTH);
-const boundedPattern = z.string().trim().min(1).max(256);
 const absoluteLocalPath = z
   .string()
   .trim()
@@ -64,65 +61,64 @@ export const KnowledgeToolResultSchema = z
   })
   .strict();
 
+const pageCursor = z.number().int().nonnegative();
+
+/** Where the next page starts: `offset` for relevance order, `after` (epoch ms) for timeline. */
+export const SearchPageSchema = z.union([
+  z.object({ offset: pageCursor }).strict(),
+  z.object({ after: pageCursor }).strict(),
+]);
+
+export const SearchKnowledgeResultSchema = KnowledgeToolResultSchema.extend({
+  next: SearchPageSchema.nullable(),
+}).strict();
+
 export const SearchKnowledgeInputSchema = providerScope
   .extend({
     queries: z.array(z.string().trim().min(1).max(MAX_QUERY_LENGTH)).min(1).max(8),
-    limit: z.number().int().min(1).max(10).default(3),
+    scope: z.enum(["worktree", "project"]).default("worktree"),
     source: boundedLabel.optional(),
-    contentType: z.enum(["code", "prose"]).optional(),
     sort: z.enum(["relevance", "timeline"]).default("relevance"),
+    page: SearchPageSchema.optional(),
   })
   .strict();
 
-export const IndexPathInputSchema = providerScope
-  .extend({
-    path: absoluteLocalPath,
-    source: boundedLabel.optional(),
-    include: z.array(boundedPattern).max(32).optional(),
-    exclude: z.array(boundedPattern).max(32).optional(),
-    maxDepth: z.number().int().min(0).max(20).optional(),
-    maxFiles: z.number().int().min(1).max(1_000).optional(),
-    extensions: z.array(boundedPattern).max(32).optional(),
-    respectGitignore: z.boolean().optional(),
-    followSymlinks: z.boolean().optional(),
-  })
-  .strict();
+export const IndexPathInputSchema = providerScope.extend({ path: absoluteLocalPath }).strict();
 
-export const FetchAndIndexInputSchema = providerScope
-  .extend({
-    url: httpUrl,
-    source: boundedLabel.optional(),
-    force: z.boolean().default(false),
-    ttl: z.number().int().min(0).max(1_209_600_000).optional(),
-  })
-  .strict();
+export const FetchAndIndexInputSchema = providerScope.extend({ url: httpUrl }).strict();
 
-const projectPurge = z
-  .object({
-    provider: KnowledgeProviderSchema,
-    projectPath: absoluteLocalPath,
-    confirm: z.literal(true),
-    scope: z.literal("project"),
-  })
-  .strict();
-const sessionPurge = z
-  .object({
-    provider: KnowledgeProviderSchema,
-    projectPath: absoluteLocalPath,
-    confirm: z.literal(true),
-    scope: z.literal("session"),
-    sessionId: z.string().trim().min(1).max(256),
-  })
+export const ResumeSessionInputSchema = providerScope
+  .extend({ sessionId: z.string().trim().min(1).max(256) })
   .strict();
 
+const purgeBase = {
+  provider: KnowledgeProviderSchema,
+  projectPath: absoluteLocalPath,
+  confirm: z.literal(true),
+};
+
 export const PurgeKnowledgeInputSchema = z.discriminatedUnion("scope", [
-  projectPurge,
-  sessionPurge,
+  z.object({ ...purgeBase, scope: z.literal("project") }).strict(),
+  z
+    .object({
+      ...purgeBase,
+      scope: z.literal("session"),
+      sessionId: z.string().trim().min(1).max(256),
+    })
+    .strict(),
+  z.object({ ...purgeBase, scope: z.literal("source"), source: boundedLabel }).strict(),
 ]);
 
 export const searchContextModeKnowledge = defineRpc({
   name: "context-mode.knowledge.search",
   input: SearchKnowledgeInputSchema,
+  output: SearchKnowledgeResultSchema,
+});
+
+/** `ctx_resume` for one recorded session: the state block an agent gets after a compact or restart. */
+export const resumeContextModeSession = defineRpc({
+  name: "context-mode.knowledge.resume",
+  input: ResumeSessionInputSchema,
   output: KnowledgeToolResultSchema,
 });
 
@@ -144,10 +140,11 @@ export const purgeContextModeKnowledge = defineRpc({
   output: KnowledgeToolResultSchema,
 });
 
-export type ContextModeProvider = z.infer<typeof ContextModeProviderSchema>;
-export type ContextModePlatform = z.infer<typeof ContextModePlatformSchema>;
 export type KnowledgeToolResult = z.infer<typeof KnowledgeToolResultSchema>;
+export type SearchPage = z.infer<typeof SearchPageSchema>;
+export type SearchKnowledgeResult = z.infer<typeof SearchKnowledgeResultSchema>;
 export type SearchKnowledgeInput = z.infer<typeof SearchKnowledgeInputSchema>;
 export type IndexPathInput = z.infer<typeof IndexPathInputSchema>;
 export type FetchAndIndexInput = z.infer<typeof FetchAndIndexInputSchema>;
+export type ResumeSessionInput = z.infer<typeof ResumeSessionInputSchema>;
 export type PurgeKnowledgeInput = z.infer<typeof PurgeKnowledgeInputSchema>;

package/shared/providers.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+
+/** Paseo providers Context Mode 2 serves over MCP. */
+export const ContextModeProviderSchema = z.enum(["claude", "codex", "copilot", "opencode"]);
+
+/** Context Mode 2 `--agent` ids for those providers. */
+export const ContextModePlatformSchema = z.enum([
+  "claude-code",
+  "codex",
+  "copilot-cli",
+  "opencode",
+]);
+
+export type ContextModeProvider = z.infer<typeof ContextModeProviderSchema>;
+export type ContextModePlatform = z.infer<typeof ContextModePlatformSchema>;
+
+interface ProviderEntry {
+  provider: ContextModeProvider;
+  platform: ContextModePlatform;
+  label: string;
+}
+
+/** The one mapping between Paseo providers, Context Mode agent ids, and display labels. */
+export const CONTEXT_MODE_PROVIDERS: readonly ProviderEntry[] = [
+  { provider: "claude", platform: "claude-code", label: "Claude" },
+  { provider: "codex", platform: "codex", label: "Codex" },
+  { provider: "copilot", platform: "copilot-cli", label: "Copilot" },
+  { provider: "opencode", platform: "opencode", label: "OpenCode" },
+];
+
+export function contextModePlatformFor(provider: ContextModeProvider): ContextModePlatform {
+  const entry = CONTEXT_MODE_PROVIDERS.find((candidate) => candidate.provider === provider);
+  if (!entry) throw new Error(`No Context Mode agent id for provider ${provider}.`);
+  return entry.platform;
+}
+
+interface InProcessEntry {
+  provider: string;
+  agent: string;
+  label: string;
+}
+
+/**
+ * Context Mode runs inside these hosts as an extension, so Paseo cannot inject it, but they record
+ * sessions in the same store under their own agent id.
+ */
+export const IN_PROCESS_PROVIDERS: readonly InProcessEntry[] = [
+  { provider: "pi", agent: "pi", label: "Pi" },
+];
+
+/**
+ * Agent id of the panel's own Context Mode process when no injectable agent applies: `--agent pi`
+ * cannot resolve a project over MCP, and the panel's calls are its own session anyway.
+ */
+export const PANEL_PLATFORM: ContextModePlatform = "claude-code";
+
+/** The Paseo provider that owns a Context Mode agent id recorded in a database, if any. */
+export function providerForPlatform(platform: string): { provider: string; label: string } | null {
+  const injected = CONTEXT_MODE_PROVIDERS.find((candidate) => candidate.platform === platform);
+  if (injected) return injected;
+  return IN_PROCESS_PROVIDERS.find((candidate) => candidate.agent === platform) ?? null;
+}

package/shared/settings.ts

@@ -4,10 +4,8 @@ import { z } from "zod";
 export const REFRESH_INTERVALS = [5_000, 15_000, 30_000, 60_000] as const;
 
 export const DEFAULT_CONTEXT_MODE_SETTINGS = {
-  binaryMode: "path",
-  binaryPath: "",
+  binaryPath: null,
   refreshIntervalMs: 15_000,
-  showDoctorByDefault: false,
   autoInject: true,
   preferNativeIntegrations: true,
 } as const;
@@ -18,34 +16,51 @@ function isAbsolutePath(value: string): boolean {
 
 export const ContextModeSettingsSchema = z
   .object({
-    binaryMode: z.enum(["path", "automatic"]).default(DEFAULT_CONTEXT_MODE_SETTINGS.binaryMode),
-    binaryPath: z.string().trim().max(4_096).default(DEFAULT_CONTEXT_MODE_SETTINGS.binaryPath),
+    /** Your own Context Mode executable; null runs the runtime bundled with the plugin. */
+    binaryPath: z
+      .string()
+      .trim()
+      .min(1)
+      .max(4_096)
+      .refine(isAbsolutePath, "The Context Mode binary path must be absolute.")
+      .nullable()
+      .default(DEFAULT_CONTEXT_MODE_SETTINGS.binaryPath),
     refreshIntervalMs: z
       .union([z.literal(5_000), z.literal(15_000), z.literal(30_000), z.literal(60_000)])
       .default(DEFAULT_CONTEXT_MODE_SETTINGS.refreshIntervalMs),
-    showDoctorByDefault: z.boolean().default(DEFAULT_CONTEXT_MODE_SETTINGS.showDoctorByDefault),
     autoInject: z.boolean().default(DEFAULT_CONTEXT_MODE_SETTINGS.autoInject),
     preferNativeIntegrations: z
       .boolean()
       .default(DEFAULT_CONTEXT_MODE_SETTINGS.preferNativeIntegrations),
   })
-  .strict()
-  .superRefine((settings, context) => {
-    if (settings.binaryMode !== "path" || settings.binaryPath.length === 0) return;
-    if (!isAbsolutePath(settings.binaryPath)) {
-      context.addIssue({
-        code: "custom",
-        path: ["binaryPath"],
-        message: "The Context Mode binary path must be absolute.",
-      });
-    }
-  });
+  .strict();
 
 export type ContextModeSettings = z.infer<typeof ContextModeSettingsSchema>;
 
+const VersionOneSettingsSchema = z.looseObject({
+  binaryMode: z.string().optional(),
+  binaryPath: z.string().optional(),
+});
+
+/**
+ * Version 1 searched PATH when no path was set and kept a `showDoctorByDefault` flag nothing read.
+ * Only an explicitly configured absolute path survives as the user's own binary.
+ */
+function migrate(values: unknown): unknown {
+  const {
+    binaryMode,
+    binaryPath,
+    showDoctorByDefault: _unused,
+    ...rest
+  } = VersionOneSettingsSchema.parse(values ?? {});
+  const configured = binaryMode !== "automatic" ? binaryPath?.trim() : undefined;
+  return { ...rest, binaryPath: configured || null };
+}
+
 export const contextModeSettings = defineSettings({
   id: "context-mode",
   scope: "host",
-  version: 1,
+  version: 2,
   schema: ContextModeSettingsSchema,
+  migrate,
 });