@omercnet/paseo-context-mode 0.0.0

package/shared/analytics.ts

@@ -0,0 +1,134 @@
+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;
+
+const nonNegativeInteger = z.number().int().nonnegative();
+const nonNegativeNumber = z.number().finite().nonnegative();
+
+export const AnalyticsByteAccountingSchema = z
+  .object({
+    eventDataBytes: nonNegativeInteger,
+    avoidedBytes: nonNegativeInteger,
+    returnedBytes: nonNegativeInteger,
+    snapshotBytes: nonNegativeInteger,
+    indexedBytes: nonNegativeInteger,
+    savedBytes: nonNegativeInteger,
+  })
+  .strict();
+
+export const AnalyticsTotalsSchema = z
+  .object({
+    providers: nonNegativeInteger,
+    databases: nonNegativeInteger,
+    projects: nonNegativeInteger,
+    sessions: nonNegativeInteger,
+    events: nonNegativeInteger,
+    toolCalls: nonNegativeInteger,
+    indexedSources: nonNegativeInteger,
+    indexedChunks: nonNegativeInteger,
+    inputTokens: nonNegativeInteger,
+    outputTokens: nonNegativeInteger,
+    savedTokens: nonNegativeInteger,
+    savingsPercent: nonNegativeNumber.max(100),
+    byteAccounting: AnalyticsByteAccountingSchema,
+  })
+  .strict();
+
+export const ProviderAnalyticsSchema = z
+  .object({
+    provider: z.string().min(1).max(128),
+    databases: nonNegativeInteger,
+    projects: nonNegativeInteger,
+    sessions: nonNegativeInteger,
+    events: nonNegativeInteger,
+    toolCalls: nonNegativeInteger,
+    indexedSources: nonNegativeInteger,
+    indexedChunks: nonNegativeInteger,
+    inputTokens: nonNegativeInteger,
+    outputTokens: nonNegativeInteger,
+    savedTokens: nonNegativeInteger,
+    savingsPercent: nonNegativeNumber.max(100),
+    byteAccounting: AnalyticsByteAccountingSchema,
+  })
+  .strict();
+
+export const CategoryAnalyticsSchema = z
+  .object({
+    category: z.string().min(1).max(256),
+    count: nonNegativeInteger,
+    savedTokens: nonNegativeInteger,
+  })
+  .strict();
+
+export const DailyAnalyticsSchema = z
+  .object({
+    date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+    calls: nonNegativeInteger,
+    savedTokens: nonNegativeInteger,
+  })
+  .strict();
+
+export const IndexedSourceAnalyticsSchema = z
+  .object({
+    provider: z.string().min(1).max(128),
+    source: z.string().min(1).max(4_096),
+    chunks: nonNegativeInteger,
+    codeChunks: nonNegativeInteger,
+    indexedBytes: nonNegativeInteger,
+    indexedAt: z.string().nullable(),
+    state: z.enum(["ready", "empty", "unavailable"]),
+    detail: z.string().max(512).optional(),
+  })
+  .strict();
+
+export const AnalyticsWarningSchema = z
+  .object({
+    code: z.enum([
+      "invalid-storage-root",
+      "storage-unavailable",
+      "not-regular-database",
+      "database-open-failed",
+      "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(),
+    message: z.string().min(1).max(512),
+  })
+  .strict();
+
+export const ContextModeAnalyticsDashboardSchema = z
+  .object({
+    schemaVersion: z.literal(CONTEXT_MODE_ANALYTICS_SCHEMA_VERSION),
+    contextModeVersion: z.literal(SUPPORTED_CONTEXT_MODE_DATABASE_VERSION),
+    completeness: z.enum(["complete", "partial", "unsupported"]),
+    warnings: z.array(AnalyticsWarningSchema).max(20),
+    totals: AnalyticsTotalsSchema,
+    byProvider: z.array(ProviderAnalyticsSchema).max(32),
+    byCategory: z.array(CategoryAnalyticsSchema).max(128),
+    byDay: z.array(DailyAnalyticsSchema).max(400),
+    sources: z.array(IndexedSourceAnalyticsSchema).max(2_000),
+    generatedAt: z.string().datetime(),
+  })
+  .strict();
+
+export const getContextModeAnalyticsDashboard = defineRpc({
+  name: "context-mode.analytics-dashboard",
+  input: z.object({}).strict(),
+  output: ContextModeAnalyticsDashboardSchema,
+});
+
+export type AnalyticsByteAccounting = z.infer<typeof AnalyticsByteAccountingSchema>;
+export type AnalyticsTotals = z.infer<typeof AnalyticsTotalsSchema>;
+export type ProviderAnalytics = z.infer<typeof ProviderAnalyticsSchema>;
+export type CategoryAnalytics = z.infer<typeof CategoryAnalyticsSchema>;
+export type DailyAnalytics = z.infer<typeof DailyAnalyticsSchema>;
+export type IndexedSourceAnalytics = z.infer<typeof IndexedSourceAnalyticsSchema>;
+export type AnalyticsWarning = z.infer<typeof AnalyticsWarningSchema>;
+export type ContextModeAnalyticsDashboard = z.infer<typeof ContextModeAnalyticsDashboardSchema>;
+export type AnalyticsDashboard = ContextModeAnalyticsDashboard;

package/shared/contracts.ts

@@ -0,0 +1,95 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+const refreshInput = z.object({ fresh: z.boolean().default(false) }).strict();
+const binarySource = z.enum(["settings", "path", "bundled"]);
+const failureCode = z.enum([
+  "not-installed",
+  "invalid-settings",
+  "timeout",
+  "output-limit",
+  "launch-failed",
+  "protocol-error",
+  "unsupported",
+  "command-failed",
+]);
+
+export const BinaryStatusSchema = z.discriminatedUnion("state", [
+  z.object({
+    state: z.literal("ready"),
+    binaryPath: z.string(),
+    source: binarySource,
+    version: z.string().nullable(),
+    supportsDoctor: z.boolean(),
+    supportsStats: z.boolean(),
+    checkedAt: z.string().datetime(),
+  }),
+  z.object({
+    state: z.literal("unavailable"),
+    code: failureCode,
+    message: z.string().max(4_096),
+    checkedAt: z.string().datetime(),
+  }),
+]);
+
+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 IntegrationAuditSchema = z.object({
+  runtimePath: z.string(),
+  runtimeVersion: z.string().nullable(),
+  injectionEnabled: z.boolean(),
+  providers: z.array(ProviderIntegrationSchema),
+  checkedAt: z.string().datetime(),
+});
+
+export const getContextModeStatus = defineRpc({
+  name: "context-mode.status",
+  input: refreshInput,
+  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,
+  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>;

package/shared/index.ts

@@ -0,0 +1,5 @@
+export * from "./actions";
+export * from "./analytics";
+export * from "./contracts";
+export * from "./knowledge";
+export * from "./settings";

package/shared/knowledge.ts

@@ -0,0 +1,150 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+const MAX_OUTPUT_LENGTH = 192 * 1_024;
+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",
+]);
+
+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()
+  .min(1)
+  .max(MAX_PATH_LENGTH)
+  .refine(
+    (value) =>
+      !value.includes("\0") &&
+      (value.startsWith("/") ||
+        /^[A-Za-z]:[\\/]/.test(value) ||
+        /^\\\\[^\\/]+[\\/][^\\/]+/.test(value)),
+    { message: "path must be an absolute local path" },
+  );
+const providerScope = z
+  .object({ provider: ContextModeProviderSchema, projectPath: absoluteLocalPath })
+  .strict();
+const httpUrl = z
+  .string()
+  .trim()
+  .min(1)
+  .max(MAX_PATH_LENGTH)
+  .url()
+  .refine((value) => /^https?:\/\//i.test(value), "url must use HTTP or HTTPS");
+
+export const KnowledgeToolResultSchema = z
+  .object({
+    provider: ContextModeProviderSchema,
+    output: z.string().max(MAX_OUTPUT_LENGTH),
+    completedAt: z.string().datetime(),
+  })
+  .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),
+    source: boundedLabel.optional(),
+    contentType: z.enum(["code", "prose"]).optional(),
+    sort: z.enum(["relevance", "timeline"]).default("relevance"),
+  })
+  .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 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();
+
+const projectPurge = z
+  .object({
+    provider: ContextModeProviderSchema,
+    projectPath: absoluteLocalPath,
+    confirm: z.literal(true),
+    scope: z.literal("project"),
+  })
+  .strict();
+const sessionPurge = z
+  .object({
+    provider: ContextModeProviderSchema,
+    projectPath: absoluteLocalPath,
+    confirm: z.literal(true),
+    scope: z.literal("session"),
+    sessionId: z.string().trim().min(1).max(256),
+  })
+  .strict();
+
+export const PurgeKnowledgeInputSchema = z.discriminatedUnion("scope", [
+  projectPurge,
+  sessionPurge,
+]);
+
+export const searchContextModeKnowledge = defineRpc({
+  name: "context-mode.knowledge.search",
+  input: SearchKnowledgeInputSchema,
+  output: KnowledgeToolResultSchema,
+});
+
+export const indexContextModePath = defineRpc({
+  name: "context-mode.knowledge.index-path",
+  input: IndexPathInputSchema,
+  output: KnowledgeToolResultSchema,
+});
+
+export const fetchAndIndexContextMode = defineRpc({
+  name: "context-mode.knowledge.fetch-index",
+  input: FetchAndIndexInputSchema,
+  output: KnowledgeToolResultSchema,
+});
+
+export const purgeContextModeKnowledge = defineRpc({
+  name: "context-mode.knowledge.purge",
+  input: PurgeKnowledgeInputSchema,
+  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 SearchKnowledgeInput = z.infer<typeof SearchKnowledgeInputSchema>;
+export type IndexPathInput = z.infer<typeof IndexPathInputSchema>;
+export type FetchAndIndexInput = z.infer<typeof FetchAndIndexInputSchema>;
+export type PurgeKnowledgeInput = z.infer<typeof PurgeKnowledgeInputSchema>;

package/shared/settings.ts

@@ -0,0 +1,51 @@
+import { defineSettings } from "@getpaseo/plugin";
+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: "",
+  refreshIntervalMs: 15_000,
+  showDoctorByDefault: false,
+  autoInject: true,
+  preferNativeIntegrations: true,
+} as const;
+
+function isAbsolutePath(value: string): boolean {
+  return value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value);
+}
+
+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),
+    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.",
+      });
+    }
+  });
+
+export type ContextModeSettings = z.infer<typeof ContextModeSettingsSchema>;
+
+export const contextModeSettings = defineSettings({
+  id: "context-mode",
+  scope: "host",
+  version: 1,
+  schema: ContextModeSettingsSchema,
+});