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

package/server/storage-discovery.ts

@@ -1,239 +1,86 @@
 import type { Dirent } from "node:fs";
-import { lstat, readdir, realpath } from "node:fs/promises";
-import { homedir } from "node:os";
-import { basename, isAbsolute, join, resolve } from "node:path";
+import { lstat, readdir } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
 import type { AnalyticsWarning } from "../shared/analytics";
-import { contextModeStorageRootFor, type ProviderOverrides, resolveProvider } from "./integration";
 
-const MAX_DATABASES_PER_DIRECTORY = 512;
-const MAX_LOCAL_DISCOVERY_WARNINGS = 10;
+const MAX_PROJECTS = 256;
+const MAX_DISCOVERY_WARNINGS = 10;
 
-export interface ProviderStorageRoot {
-  provider: string;
-  root: string;
-  sessionsDir: string;
-  contentDir: string;
+export interface ContextModeProjectDatabase {
+  /** Project key directory name, `sha256(projectPath).slice(0, 16)` upstream. */
+  project: string;
+  path: string;
 }
 
 export interface StorageDiscoveryResult {
-  roots: ProviderStorageRoot[];
+  databases: ContextModeProjectDatabase[];
   warnings: AnalyticsWarning[];
 }
 
-export interface StorageDiscoveryOptions {
-  home?: string;
-  env?: NodeJS.ProcessEnv;
-  platform?: NodeJS.Platform;
-  /** Paseo `agents.providers`; each one contributes the storage its own env resolves to. */
-  providers?: ProviderOverrides;
+/** Context Mode 2.x data dir: absolute `CONTEXT_MODE_DATA_DIR`, else `~/.context-mode`. */
+export function resolveContextModeDataDir(env: NodeJS.ProcessEnv, home: string): string {
+  const configured = env.CONTEXT_MODE_DATA_DIR?.trim();
+  return configured && isAbsolute(configured) ? resolve(configured) : join(home, ".context-mode");
 }
 
-interface ProviderLocation {
-  provider: string;
-  root: string;
-}
-
-function configuredDirectory(
-  value: string | undefined,
-  home: string,
-  envVar: string,
-  warnings: AnalyticsWarning[],
-): string | null {
-  const trimmed = value?.trim();
-  if (!trimmed) return null;
-  if (trimmed === "~" || trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
-    return resolve(home, trimmed.slice(2));
-  }
-  if (isAbsolute(trimmed)) return resolve(trimmed);
-  warnings.push({
-    code: "invalid-storage-root",
-    message: `${envVar} was ignored because it is not an absolute path.`,
-  });
-  return null;
-}
-
-function providerLocations(
-  home: string,
-  env: NodeJS.ProcessEnv,
-  warnings: AnalyticsWarning[],
-  platform: NodeJS.Platform,
-  providers: ProviderOverrides,
-): ProviderLocation[] {
-  const configuredRoot = configuredDirectory(
-    env.CONTEXT_MODE_DIR,
-    home,
-    "CONTEXT_MODE_DIR",
-    warnings,
-  );
-  const configuredDataRoot = configuredDirectory(
-    env.CONTEXT_MODE_DATA_DIR,
-    home,
-    "CONTEXT_MODE_DATA_DIR",
-    warnings,
-  );
-  const claudeRoot =
-    configuredDirectory(env.CLAUDE_CONFIG_DIR, home, "CLAUDE_CONFIG_DIR", warnings) ??
-    join(home, ".claude");
-  const codexRoot =
-    configuredDirectory(env.CODEX_HOME, home, "CODEX_HOME", warnings) ?? join(home, ".codex");
-  const kimiRoot =
-    configuredDirectory(env.KIMI_CODE_HOME, home, "KIMI_CODE_HOME", warnings) ??
-    join(home, ".kimi-code");
-  const xdgRoot =
-    platform === "win32"
-      ? (configuredDirectory(env.APPDATA, home, "APPDATA", warnings) ??
-        join(home, "AppData", "Roaming"))
-      : (configuredDirectory(env.XDG_CONFIG_HOME, home, "XDG_CONFIG_HOME", warnings) ??
-        join(home, ".config"));
-
-  const configured = Object.keys(providers).flatMap((id) => {
-    const { base, policy, env: providerEnv } = resolveProvider(id, providers);
-    const root = policy
-      ? contextModeStorageRootFor(base, { home, env: { ...env, ...providerEnv } })
-      : null;
-    return root ? [{ provider: id, root }] : [];
-  });
-
-  return [
-    ...(configuredRoot ? [{ provider: "custom", root: configuredRoot }] : []),
-    ...(configuredDataRoot
-      ? [{ provider: "custom-data", root: join(configuredDataRoot, "context-mode") }]
-      : []),
-    { provider: "claude-code", root: join(claudeRoot, "context-mode") },
-    { provider: "gemini-cli", root: join(home, ".gemini", "context-mode") },
-    { provider: "openclaw", root: join(home, ".openclaw", "context-mode") },
-    { provider: "codex", root: join(codexRoot, "context-mode") },
-    { provider: "cursor", root: join(home, ".cursor", "context-mode") },
-    { provider: "vscode-copilot", root: join(home, ".vscode", "context-mode") },
-    { provider: "copilot-cli", root: join(home, ".copilot", "context-mode") },
-    { provider: "kiro", root: join(home, ".kiro", "context-mode") },
-    { provider: "pi", root: join(home, ".pi", "context-mode") },
-    { provider: "omp", root: join(home, ".omp", "context-mode") },
-    { provider: "qwen-code", root: join(home, ".qwen", "context-mode") },
-    { provider: "kimi", root: join(kimiRoot, "context-mode") },
-    { provider: "kilo", root: join(xdgRoot, "kilo", "context-mode") },
-    { provider: "opencode", root: join(xdgRoot, "opencode", "context-mode") },
-    { provider: "zed", root: join(home, ".config", "zed", "context-mode") },
-    {
-      provider: "jetbrains-copilot",
-      root: join(home, ".config", "JetBrains", "context-mode"),
-    },
-    ...configured,
-  ];
-}
-
-function storageWarning(provider: string, message: string, database?: string): AnalyticsWarning {
-  return {
-    code: "storage-unavailable",
-    provider,
-    ...(database ? { database } : {}),
-    message,
-  };
-}
-
-export async function discoverContextModeStorageRoots(
-  options: StorageDiscoveryOptions = {},
+/** Lists `<dataDir>/projects/<key>/context.db`, skipping project directories without a database. */
+export async function discoverContextModeDatabases(
+  dataDir: string,
 ): Promise<StorageDiscoveryResult> {
-  const home = resolve(options.home ?? homedir());
-  const env = options.env ?? process.env;
-  const warnings: AnalyticsWarning[] = [];
-  const roots: ProviderStorageRoot[] = [];
-  const seen = new Set<string>();
-
-  for (const location of providerLocations(
-    home,
-    env,
-    warnings,
-    options.platform ?? process.platform,
-    options.providers ?? {},
-  )) {
-    try {
-      const info = await lstat(location.root);
-      if (info.isSymbolicLink() || !info.isDirectory()) {
-        warnings.push(
-          storageWarning(
-            location.provider,
-            "The Context Mode storage root is not a regular directory.",
-          ),
-        );
-        continue;
-      }
-      const canonical = await realpath(location.root);
-      if (seen.has(canonical)) continue;
-      seen.add(canonical);
-      roots.push({
-        provider: location.provider,
-        root: canonical,
-        sessionsDir: join(canonical, "sessions"),
-        contentDir: join(canonical, "content"),
-      });
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") continue;
-      warnings.push(
-        storageWarning(location.provider, "The Context Mode storage root could not be inspected."),
-      );
-    }
-  }
-
-  return { roots, warnings };
-}
-
-export async function listRegularContextModeDatabases(
-  provider: string,
-  directory: string,
-): Promise<{ files: string[]; warnings: AnalyticsWarning[] }> {
+  const projectsDir = join(dataDir, "projects");
   let entries: Dirent[];
   try {
-    entries = await readdir(directory, { withFileTypes: true });
+    entries = await readdir(projectsDir, { withFileTypes: true });
   } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") return { files: [], warnings: [] };
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return { databases: [], warnings: [] };
     return {
-      files: [],
+      databases: [],
       warnings: [
-        storageWarning(
-          provider,
-          `The ${basename(directory)} database directory could not be read.`,
-        ),
+        {
+          code: "storage-unavailable",
+          message: "The Context Mode projects directory could not be read.",
+        },
       ],
     };
   }
 
-  const candidates = entries
-    .filter((entry) => entry.name.endsWith(".db"))
-    .sort((left, right) => left.name.localeCompare(right.name));
-  const files: string[] = [];
+  const projects = entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort();
+  const databases: ContextModeProjectDatabase[] = [];
   const warnings: AnalyticsWarning[] = [];
 
-  for (const entry of candidates.slice(0, MAX_DATABASES_PER_DIRECTORY)) {
-    const path = join(directory, entry.name);
+  for (const project of projects.slice(0, MAX_PROJECTS)) {
+    const path = join(projectsDir, project, "context.db");
     try {
       const info = await lstat(path);
-      if (entry.isFile() && info.isFile()) {
-        files.push(path);
-      } else if (warnings.length < MAX_LOCAL_DISCOVERY_WARNINGS) {
+      if (info.isFile()) databases.push({ project, path });
+      else if (warnings.length < MAX_DISCOVERY_WARNINGS) {
         warnings.push({
           code: "not-regular-database",
-          provider,
-          database: entry.name,
-          message: "Skipped a .db entry that is not a regular file.",
+          project,
+          message: "Skipped a context.db entry that is not a regular file.",
         });
       }
-    } catch {
-      if (warnings.length < MAX_LOCAL_DISCOVERY_WARNINGS) {
-        warnings.push(
-          storageWarning(provider, "A database disappeared during discovery.", entry.name),
-        );
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") continue;
+      if (warnings.length < MAX_DISCOVERY_WARNINGS) {
+        warnings.push({
+          code: "storage-unavailable",
+          project,
+          message: "The project database could not be inspected.",
+        });
       }
     }
   }
 
-  if (candidates.length > MAX_DATABASES_PER_DIRECTORY) {
+  if (projects.length > MAX_PROJECTS) {
     warnings.push({
       code: "result-truncated",
-      provider,
-      message: `Only the first ${MAX_DATABASES_PER_DIRECTORY} database files in ${basename(directory)} were inspected.`,
+      message: `Only the first ${MAX_PROJECTS} of ${projects.length} Context Mode projects were inspected.`,
     });
   }
 
-  return { files, warnings };
+  return { databases, warnings };
 }

package/shared/actions.ts

@@ -1,8 +1,6 @@
 import { defineRpc } from "@getpaseo/plugin";
 import { z } from "zod";
-import { ContextModePlatformSchema, ContextModeProviderSchema } from "./knowledge";
-
-export const CONTEXT_MODE_TARGET_VERSION = "1.0.169" as const;
+import { ContextModePlatformSchema, ContextModeProviderSchema } from "./providers";
 
 const providerInput = z.object({ provider: ContextModeProviderSchema }).strict();
 
@@ -11,6 +9,7 @@ export const DoctorStatusRowSchema = z
     status: z.enum(["ok", "warning", "error"]),
     check: z.string().trim().min(1).max(256),
     detail: z.string().max(4_096),
+    fix: z.string().max(4_096).optional(),
   })
   .strict();
 
@@ -22,36 +21,12 @@ export const DoctorReportSchema = z
   })
   .strict();
 
-export const ContextModeActionSchema = z
-  .object({
-    program: z.string().trim().min(1).max(4_096),
-    args: z.array(z.string().max(4_096)).max(32),
-    currentVersion: z.string().trim().min(1).max(128).nullable(),
-    targetVersion: z.union([z.literal(CONTEXT_MODE_TARGET_VERSION), z.literal("latest")]),
-    platform: ContextModePlatformSchema,
-    requiresRestart: z.boolean(),
-  })
-  .strict();
-
 export const getContextModeDoctorReport = defineRpc({
   name: "context-mode.actions.doctor",
   input: providerInput,
   output: DoctorReportSchema,
 });
 
-export const getContextModeInstallAction = defineRpc({
-  name: "context-mode.actions.install",
-  input: providerInput,
-  output: ContextModeActionSchema,
-});
-
-export const getContextModeUpgradeAction = defineRpc({
-  name: "context-mode.actions.upgrade",
-  input: providerInput,
-  output: ContextModeActionSchema,
-});
-
 export type DoctorStatusRow = z.infer<typeof DoctorStatusRowSchema>;
 export type DoctorReport = z.infer<typeof DoctorReportSchema>;
-export type ContextModeAction = z.infer<typeof ContextModeActionSchema>;
 export type ContextModeActionInput = z.infer<typeof providerInput>;

package/shared/analytics.ts

@@ -1,27 +1,32 @@
 import { defineRpc } from "@getpaseo/plugin";
 import { z } from "zod";
 
-export const CONTEXT_MODE_ANALYTICS_SCHEMA_VERSION = 1 as const;
-export const SUPPORTED_CONTEXT_MODE_DATABASE_VERSION = "1.0.169" as const;
+export const CONTEXT_MODE_ANALYTICS_SCHEMA_VERSION = 2 as const;
+export const SUPPORTED_CONTEXT_MODE_DATABASE_USER_VERSION = 6 as const;
 
 const nonNegativeInteger = z.number().int().nonnegative();
 const nonNegativeNumber = z.number().finite().nonnegative();
+const timestamp = z.string().datetime().nullable();
 
+/** Byte totals of Context Mode tool calls: produced in the sandbox, returned to the agent, kept out. */
 export const AnalyticsByteAccountingSchema = z
   .object({
-    eventDataBytes: nonNegativeInteger,
-    avoidedBytes: nonNegativeInteger,
+    producedBytes: nonNegativeInteger,
     returnedBytes: nonNegativeInteger,
-    snapshotBytes: nonNegativeInteger,
-    indexedBytes: nonNegativeInteger,
     savedBytes: nonNegativeInteger,
+    indexedBytes: nonNegativeInteger,
   })
   .strict();
 
+const savingsFields = {
+  savedTokens: nonNegativeInteger,
+  savingsPercent: nonNegativeNumber.max(100),
+  byteAccounting: AnalyticsByteAccountingSchema,
+};
+
 export const AnalyticsTotalsSchema = z
   .object({
-    providers: nonNegativeInteger,
-    databases: nonNegativeInteger,
+    agents: nonNegativeInteger,
     projects: nonNegativeInteger,
     sessions: nonNegativeInteger,
     events: nonNegativeInteger,
@@ -30,27 +35,47 @@ export const AnalyticsTotalsSchema = z
     indexedChunks: nonNegativeInteger,
     inputTokens: nonNegativeInteger,
     outputTokens: nonNegativeInteger,
-    savedTokens: nonNegativeInteger,
-    savingsPercent: nonNegativeNumber.max(100),
-    byteAccounting: AnalyticsByteAccountingSchema,
+    ...savingsFields,
+    lastActivityAt: timestamp,
   })
   .strict();
 
-export const ProviderAnalyticsSchema = z
+/** One row per Context Mode `--agent` id recorded in the databases (claude-code, codex, ...). */
+export const AgentAnalyticsSchema = z
   .object({
-    provider: z.string().min(1).max(128),
-    databases: nonNegativeInteger,
+    agent: z.string().min(1).max(128),
     projects: nonNegativeInteger,
     sessions: nonNegativeInteger,
-    events: nonNegativeInteger,
     toolCalls: nonNegativeInteger,
     indexedSources: nonNegativeInteger,
-    indexedChunks: nonNegativeInteger,
-    inputTokens: nonNegativeInteger,
-    outputTokens: nonNegativeInteger,
-    savedTokens: nonNegativeInteger,
-    savingsPercent: nonNegativeNumber.max(100),
-    byteAccounting: AnalyticsByteAccountingSchema,
+    ...savingsFields,
+  })
+  .strict();
+
+export const ProjectAnalyticsSchema = z
+  .object({
+    path: z.string().min(1).max(4_096),
+    worktrees: nonNegativeInteger,
+    sessions: nonNegativeInteger,
+    toolCalls: nonNegativeInteger,
+    indexedSources: nonNegativeInteger,
+    ...savingsFields,
+    lastActivityAt: timestamp,
+  })
+  .strict();
+
+/** Paseo provider whose Context Mode store holds the row, for Resume and Forget; null when none reaches it. */
+const storeProvider = z.string().min(1).max(128).nullable();
+
+/** One recorded agent session, newest first; the plugin's own `paseo-context-mode` calls are excluded. */
+export const SessionAnalyticsSchema = z
+  .object({
+    sessionId: z.string().min(1).max(256),
+    agent: z.string().min(1).max(128),
+    projectPath: z.string().min(1).max(4_096),
+    events: nonNegativeInteger,
+    lastActivityAt: timestamp,
+    provider: storeProvider,
   })
   .strict();
 
@@ -72,32 +97,30 @@ export const DailyAnalyticsSchema = z
 
 export const IndexedSourceAnalyticsSchema = z
   .object({
-    provider: z.string().min(1).max(128),
+    agent: z.string().min(1).max(128),
+    projectPath: z.string().min(1).max(4_096),
     source: z.string().min(1).max(4_096),
+    kind: z.enum(["path", "content", "url"]),
     chunks: nonNegativeInteger,
-    codeChunks: nonNegativeInteger,
     indexedBytes: nonNegativeInteger,
-    indexedAt: z.string().nullable(),
-    state: z.enum(["ready", "empty", "unavailable"]),
-    detail: z.string().max(512).optional(),
+    indexedAt: timestamp,
+    provider: storeProvider,
   })
   .strict();
 
 export const AnalyticsWarningSchema = z
   .object({
     code: z.enum([
-      "invalid-storage-root",
       "storage-unavailable",
       "not-regular-database",
       "database-open-failed",
+      "database-locked",
       "unsupported-schema",
       "database-query-failed",
-      "inconsistent-index",
       "result-truncated",
       "warning-limit",
     ]),
-    provider: z.string().min(1).max(128).optional(),
-    database: z.string().min(1).max(512).optional(),
+    project: z.string().min(1).max(128).optional(),
     message: z.string().min(1).max(512),
   })
   .strict();
@@ -105,11 +128,13 @@ export const AnalyticsWarningSchema = z
 export const ContextModeAnalyticsDashboardSchema = z
   .object({
     schemaVersion: z.literal(CONTEXT_MODE_ANALYTICS_SCHEMA_VERSION),
-    contextModeVersion: z.literal(SUPPORTED_CONTEXT_MODE_DATABASE_VERSION),
+    contextModeVersion: z.string().min(1).max(64).nullable(),
     completeness: z.enum(["complete", "partial", "unsupported"]),
     warnings: z.array(AnalyticsWarningSchema).max(20),
     totals: AnalyticsTotalsSchema,
-    byProvider: z.array(ProviderAnalyticsSchema).max(32),
+    byAgent: z.array(AgentAnalyticsSchema).max(32),
+    byProject: z.array(ProjectAnalyticsSchema).max(50),
+    recentSessions: z.array(SessionAnalyticsSchema).max(20),
     byCategory: z.array(CategoryAnalyticsSchema).max(128),
     byDay: z.array(DailyAnalyticsSchema).max(400),
     sources: z.array(IndexedSourceAnalyticsSchema).max(2_000),
@@ -125,7 +150,9 @@ export const getContextModeAnalyticsDashboard = defineRpc({
 
 export type AnalyticsByteAccounting = z.infer<typeof AnalyticsByteAccountingSchema>;
 export type AnalyticsTotals = z.infer<typeof AnalyticsTotalsSchema>;
-export type ProviderAnalytics = z.infer<typeof ProviderAnalyticsSchema>;
+export type AgentAnalytics = z.infer<typeof AgentAnalyticsSchema>;
+export type ProjectAnalytics = z.infer<typeof ProjectAnalyticsSchema>;
+export type SessionAnalytics = z.infer<typeof SessionAnalyticsSchema>;
 export type CategoryAnalytics = z.infer<typeof CategoryAnalyticsSchema>;
 export type DailyAnalytics = z.infer<typeof DailyAnalyticsSchema>;
 export type IndexedSourceAnalytics = z.infer<typeof IndexedSourceAnalyticsSchema>;

package/shared/contracts.ts

@@ -1,8 +1,10 @@
 import { defineRpc } from "@getpaseo/plugin";
 import { z } from "zod";
+import { ContextModePlatformSchema } from "./providers";
 
 const refreshInput = z.object({ fresh: z.boolean().default(false) }).strict();
-const binarySource = z.enum(["settings", "path", "bundled"]);
+/** `settings`: the user's own binary; `bundled`: the runtime shipped with the plugin. */
+const binarySource = z.enum(["settings", "bundled"]);
 const failureCode = z.enum([
   "not-installed",
   "invalid-settings",
@@ -20,8 +22,6 @@ export const BinaryStatusSchema = z.discriminatedUnion("state", [
     binaryPath: z.string(),
     source: binarySource,
     version: z.string().nullable(),
-    supportsDoctor: z.boolean(),
-    supportsStats: z.boolean(),
     checkedAt: z.string().datetime(),
   }),
   z.object({
@@ -32,37 +32,19 @@ export const BinaryStatusSchema = z.discriminatedUnion("state", [
   }),
 ]);
 
-export const CommandReportSchema = z.discriminatedUnion("state", [
-  z.object({
-    state: z.literal("ready"),
-    binaryPath: z.string(),
-    output: z.string().max(196_608),
-    checkedAt: z.string().datetime(),
-  }),
-  z.object({
-    state: z.literal("unavailable"),
-    code: failureCode,
-    message: z.string().max(4_096),
-    checkedAt: z.string().datetime(),
-  }),
-]);
-
-export const ProviderIntegrationSchema = z.object({
-  provider: z.string(),
-  platform: z.string(),
-  activation: z.enum(["native", "mcp", "disabled"]),
-  storageRoot: z.string(),
-  reusesExistingStorage: z.boolean(),
-  detail: z.string().max(4_096),
-});
+export const ProviderIntegrationSchema = z
+  .object({
+    provider: z.string(),
+    /** `--agent` id, or null when Context Mode 2.x cannot serve this provider over MCP. */
+    platform: ContextModePlatformSchema.nullable(),
+    activation: z.enum(["native", "mcp", "disabled"]),
+    detail: z.string().max(4_096),
+  })
+  .strict();
 
-export const IntegrationAuditSchema = z.object({
-  runtimePath: z.string(),
-  runtimeVersion: z.string().nullable(),
-  injectionEnabled: z.boolean(),
-  providers: z.array(ProviderIntegrationSchema),
-  checkedAt: z.string().datetime(),
-});
+export const IntegrationAuditSchema = z
+  .object({ providers: z.array(ProviderIntegrationSchema) })
+  .strict();
 
 export const getContextModeStatus = defineRpc({
   name: "context-mode.status",
@@ -70,26 +52,13 @@ export const getContextModeStatus = defineRpc({
   output: BinaryStatusSchema,
 });
 
-export const getContextModeDoctor = defineRpc({
-  name: "context-mode.doctor",
-  input: refreshInput,
-  output: CommandReportSchema,
-});
-
-export const getContextModeStats = defineRpc({
-  name: "context-mode.stats",
-  input: refreshInput,
-  output: CommandReportSchema,
-});
-
 export const getContextModeIntegrationAudit = defineRpc({
   name: "context-mode.integration-audit",
-  input: refreshInput,
+  input: z.object({}).strict(),
   output: IntegrationAuditSchema,
 });
 
 export type BinaryStatus = z.infer<typeof BinaryStatusSchema>;
-export type CommandReport = z.infer<typeof CommandReportSchema>;
 export type IntegrationAudit = z.infer<typeof IntegrationAuditSchema>;
 export type ProviderIntegration = z.infer<typeof ProviderIntegrationSchema>;
 export type ContextModeRefreshInput = z.infer<typeof refreshInput>;