@hippodid/openclaw-plugin 1.0.0

package/src/tier-manager.ts

@@ -0,0 +1,90 @@
+import type { HippoDidClient } from './hippodid-client.js';
+import type { TierInfo } from './types.js';
+
+export interface TierManager {
+  initialize(): Promise<TierInfo>;
+  getCurrentTier(): TierInfo;
+  shouldMountFileSync(autoCaptureEnabled: boolean): boolean;
+  shouldMountAutoRecall(autoRecallEnabled: boolean): boolean;
+  shouldMountAutoCapture(autoCaptureEnabled: boolean): boolean;
+  shouldHydrateOnStart(autoRecallEnabled: boolean): boolean;
+  getEffectiveSyncInterval(configInterval: number): number;
+}
+
+const FREE_TIER_FALLBACK: TierInfo = {
+  tier: 'free',
+  features: {
+    autoRecallAvailable: false,
+    autoCaptureAvailable: false,
+    minSyncIntervalSeconds: 60,
+  },
+};
+
+export function createTierManager(
+  client: HippoDidClient,
+  characterId: string,
+  logger: { info(msg: string): void; warn(msg: string): void },
+): TierManager {
+  let currentTier: TierInfo = FREE_TIER_FALLBACK;
+
+  return {
+    async initialize(): Promise<TierInfo> {
+      const result = await client.getTier(characterId);
+
+      if (result.ok) {
+        currentTier = result.value;
+      } else {
+        logger.warn(
+          `hippodid: failed to fetch tier, defaulting to free: ${result.error.message}`,
+        );
+        currentTier = FREE_TIER_FALLBACK;
+      }
+
+      logger.info(
+        `hippodid: tier=${currentTier.tier}, autoRecall=${currentTier.features.autoRecallAvailable ? 'available' : 'unavailable'}, autoCapture=${currentTier.features.autoCaptureAvailable ? 'available' : 'unavailable'}`,
+      );
+
+      return currentTier;
+    },
+
+    getCurrentTier(): TierInfo {
+      return currentTier;
+    },
+
+    shouldMountFileSync(autoCaptureEnabled: boolean): boolean {
+      const isFree = !isPaidTier(currentTier);
+      if (isFree) return true;
+      return !autoCaptureEnabled;
+    },
+
+    shouldMountAutoRecall(autoRecallEnabled: boolean): boolean {
+      return (
+        isPaidTier(currentTier) &&
+        autoRecallEnabled &&
+        currentTier.features.autoRecallAvailable
+      );
+    },
+
+    shouldMountAutoCapture(autoCaptureEnabled: boolean): boolean {
+      return (
+        isPaidTier(currentTier) &&
+        autoCaptureEnabled &&
+        currentTier.features.autoCaptureAvailable
+      );
+    },
+
+    shouldHydrateOnStart(autoRecallEnabled: boolean): boolean {
+      const isFree = !isPaidTier(currentTier);
+      if (isFree) return true;
+      return !autoRecallEnabled;
+    },
+
+    getEffectiveSyncInterval(configInterval: number): number {
+      return Math.max(configInterval, currentTier.features.minSyncIntervalSeconds);
+    },
+  };
+}
+
+function isPaidTier(tier: TierInfo): boolean {
+  return tier.tier !== 'free';
+}

package/src/types.ts

@@ -0,0 +1,160 @@
+// --- Result type (discriminated union, zero deps) ---
+
+export type Result<T, E = ApiError> =
+  | { ok: true; value: T }
+  | { ok: false; error: E };
+
+export function ok<T>(value: T): Result<T, never> {
+  return { ok: true, value };
+}
+
+export function err<E>(error: E): Result<never, E> {
+  return { ok: false, error };
+}
+
+// --- API error ---
+
+export interface ApiError {
+  status: number;
+  message: string;
+  retryable: boolean;
+}
+
+// --- Plugin config (matches openclaw.plugin.json configSchema) ---
+
+export interface PluginConfig {
+  apiKey: string;
+  characterId: string;
+  baseUrl: string;
+  syncIntervalSeconds: number;
+  autoRecall: boolean;
+  autoCapture: boolean;
+  additionalPaths: WatchPathConfig[];
+}
+
+export interface WatchPathConfig {
+  path: string;
+  label?: string;
+}
+
+// --- Watch path (resolved) ---
+
+export interface WatchPath {
+  path: string;
+  label: string;
+  source: 'auto-detected' | 'user-specified';
+}
+
+// --- Tier info ---
+
+export interface TierInfo {
+  tier: string;
+  features: {
+    autoRecallAvailable: boolean;
+    autoCaptureAvailable: boolean;
+    minSyncIntervalSeconds: number;
+  };
+}
+
+export interface TierApiResponse {
+  tier: string;
+  features: {
+    auto_recall_available: boolean;
+    auto_capture_available: boolean;
+    min_sync_interval_seconds: number;
+  };
+}
+
+// --- Sync responses ---
+
+export interface SyncResponse {
+  status: string;
+  snapshotId: string;
+  changed: boolean;
+}
+
+export interface SyncApiResponse {
+  status: string;
+  snapshot_id: string;
+  changed: boolean;
+}
+
+export interface SyncLatestResponse {
+  sourcePath: string;
+  fileContent: string;
+  snapshotId: string;
+  syncedAt: string;
+}
+
+export interface SyncLatestApiResponse {
+  source_path: string;
+  file_content: string;
+  snapshot_id: string;
+  synced_at: string;
+}
+
+export interface SyncStatusEntry {
+  sourcePath: string;
+  label: string;
+  lastSyncedAt: string;
+  snapshotId: string;
+}
+
+export interface SyncStatusResponse {
+  entries: SyncStatusEntry[];
+}
+
+// --- Search ---
+
+export interface SearchResult {
+  content: string;
+  category: string;
+  score: number;
+  createdAt: string;
+}
+
+export interface SearchResultApiResponse {
+  content: string;
+  category: string;
+  score: number;
+  created_at: string;
+}
+
+// --- File tracking ---
+
+export interface FileTrackingEntry {
+  hash: string;
+  lastSyncedAt: Date;
+}
+
+// --- OpenClaw Plugin API (local type, based on plan assumptions) ---
+
+export interface OpenClawPluginAPI {
+  config: PluginConfig;
+  logger: {
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+  };
+  hooks: {
+    on(event: string, handler: (...args: any[]) => void | Promise<void>): void;
+  };
+  context: {
+    prepend(content: string): void;
+  };
+  commands: {
+    register(name: string, options: CommandOptions): void;
+  };
+}
+
+export interface CommandOptions {
+  description: string;
+  args?: CommandArg[];
+  handler: (args: Record<string, string>) => void | Promise<void>;
+}
+
+export interface CommandArg {
+  name: string;
+  description: string;
+  required?: boolean;
+}

package/src/workspace-detector.ts

@@ -0,0 +1,104 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { homedir } from 'node:os';
+import type { PluginConfig, WatchPath } from './types.js';
+
+export function detectWorkspaceMemoryDir(): string | null {
+  const candidates: string[] = [];
+
+  const envWorkspace = process.env['OPENCLAW_WORKSPACE'];
+  if (envWorkspace) {
+    candidates.push(resolve(join(envWorkspace, 'memory')));
+  }
+
+  candidates.push(resolve(join(homedir(), '.openclaw', 'workspace', 'memory')));
+  candidates.push(resolve(join(process.cwd(), 'memory')));
+
+  for (const candidate of candidates) {
+    if (isValidMemoryDir(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+export function detectMemoryMdPath(): string | null {
+  const candidates: string[] = [];
+
+  const envWorkspace = process.env['OPENCLAW_WORKSPACE'];
+  if (envWorkspace) {
+    candidates.push(resolve(join(envWorkspace, 'MEMORY.md')));
+  }
+
+  candidates.push(
+    resolve(join(homedir(), '.openclaw', 'workspace', 'MEMORY.md')),
+  );
+  candidates.push(resolve(join(process.cwd(), 'MEMORY.md')));
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+export function resolveWatchPaths(config: PluginConfig): WatchPath[] {
+  const paths: WatchPath[] = [];
+  const seen = new Set<string>();
+
+  const memoryDir = detectWorkspaceMemoryDir();
+  if (memoryDir) {
+    const resolved = resolve(memoryDir);
+    if (!seen.has(resolved)) {
+      seen.add(resolved);
+      paths.push({
+        path: resolved,
+        label: 'workspace-memory',
+        source: 'auto-detected',
+      });
+    }
+  }
+
+  const memoryMd = detectMemoryMdPath();
+  if (memoryMd) {
+    const resolved = resolve(memoryMd);
+    if (!seen.has(resolved)) {
+      seen.add(resolved);
+      paths.push({
+        path: resolved,
+        label: 'MEMORY.md',
+        source: 'auto-detected',
+      });
+    }
+  }
+
+  for (const additional of config.additionalPaths) {
+    const resolved = resolve(additional.path);
+    if (!seen.has(resolved)) {
+      seen.add(resolved);
+      paths.push({
+        path: resolved,
+        label: additional.label ?? resolved,
+        source: 'user-specified',
+      });
+    }
+  }
+
+  return paths;
+}
+
+function isValidMemoryDir(dirPath: string): boolean {
+  try {
+    if (!existsSync(dirPath)) return false;
+    const s = statSync(dirPath);
+    if (!s.isDirectory()) return false;
+
+    const entries = readdirSync(dirPath);
+    return entries.some((e) => e.endsWith('.md'));
+  } catch {
+    return false;
+  }
+}