claude-smart 0.2.22 → 0.2.24

package/plugin/dashboard/lib/claude-settings-file.ts

@@ -0,0 +1,114 @@
+/**
+ * Read/write Claude Code project settings used to inject hook-side env vars.
+ *
+ * This is intentionally separate from ~/.reflexio/.env: reflexio reads that
+ * file in the backend process, while claude-smart hooks read env from the
+ * Claude Code process tree.
+ */
+
+import fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { ClaudeCodeHookConfig } from "./types";
+
+const ENV_KEY = "CLAUDE_SMART_ENABLE_OPTIMIZER";
+
+function settingsPath(): string {
+  return path.join(workspaceRoot(), ".claude", "settings.local.json");
+}
+
+function userSettingsPath(): string {
+  return path.join(os.homedir(), ".claude", "settings.json");
+}
+
+function workspaceRoot(): string {
+  const configured = process.env.CLAUDE_SMART_DASHBOARD_WORKSPACE;
+  const start = configured
+    ? path.resolve(configured)
+    : path.resolve(process.cwd(), "../..");
+  return findProjectRoot(start);
+}
+
+function findProjectRoot(start: string): string {
+  let current = start;
+  while (true) {
+    if (
+      existsSync(path.join(current, ".claude")) ||
+      existsSync(path.join(current, ".git"))
+    ) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return start;
+    current = parent;
+  }
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return value as Record<string, unknown>;
+}
+
+function parseEnabled(value: unknown): boolean {
+  if (value === undefined || value === null || value === "") return true;
+  if (value === false || value === 0) return false;
+  if (typeof value === "string" && value.trim() === "0") return false;
+  return true;
+}
+
+function optimizerValue(settings: Record<string, unknown>): boolean | null {
+  const env = asRecord(settings.env);
+  if (!(ENV_KEY in env)) return null;
+  return parseEnabled(env[ENV_KEY]);
+}
+
+async function readSettingsFile(file: string): Promise<Record<string, unknown>> {
+  try {
+    const text = await fs.readFile(file, "utf-8");
+    return asRecord(JSON.parse(text));
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+    throw error;
+  }
+}
+
+export async function readClaudeCodeHookConfig(): Promise<ClaudeCodeHookConfig> {
+  const localPath = settingsPath();
+  const globalPath = userSettingsPath();
+  const [localSettings, userSettings] = await Promise.all([
+    readSettingsFile(localPath),
+    readSettingsFile(globalPath),
+  ]);
+  const localValue = optimizerValue(localSettings);
+  const userValue = optimizerValue(userSettings);
+  const effectiveValue = localValue ?? userValue ?? true;
+  return {
+    CLAUDE_SMART_ENABLE_OPTIMIZER: effectiveValue,
+    effectiveValue,
+    localValue,
+    userValue,
+    settingsPath: localPath,
+    userSettingsPath: globalPath,
+  };
+}
+
+export async function writeClaudeCodeHookConfig(
+  update: Partial<ClaudeCodeHookConfig>,
+): Promise<void> {
+  const file = settingsPath();
+  const settings = await readSettingsFile(file);
+  const env = asRecord(settings.env);
+
+  if (!("CLAUDE_SMART_ENABLE_OPTIMIZER" in update)) return;
+  env[ENV_KEY] = update.CLAUDE_SMART_ENABLE_OPTIMIZER ? "1" : "0";
+
+  settings.env = env;
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, `${JSON.stringify(settings, null, 2)}\n`, {
+    encoding: "utf-8",
+    mode: 0o600,
+  });
+}

package/plugin/dashboard/lib/config-file.ts

@@ -0,0 +1,131 @@
+/**
+ * Read/write ~/.reflexio/.env — preserving unknown keys, comments, and blank
+ * lines. Used by the Configure page.
+ */
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import type { ClaudeSmartConfig } from "./types";
+
+const KNOWN_KEYS = [
+  "REFLEXIO_URL",
+  "CLAUDE_SMART_USE_LOCAL_CLI",
+  "CLAUDE_SMART_USE_LOCAL_EMBEDDING",
+  "CLAUDE_SMART_CLI_PATH",
+  "CLAUDE_SMART_CLI_TIMEOUT",
+  "CLAUDE_SMART_STATE_DIR",
+] as const;
+
+const KNOWN = new Set<string>(KNOWN_KEYS);
+
+const BOOL_KEYS = new Set([
+  "CLAUDE_SMART_USE_LOCAL_CLI",
+  "CLAUDE_SMART_USE_LOCAL_EMBEDDING",
+]);
+
+function envPath(): string {
+  return path.join(os.homedir(), ".reflexio", ".env");
+}
+
+function parseLine(line: string): { key: string; value: string } | null {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#")) return null;
+  const eq = trimmed.indexOf("=");
+  if (eq < 0) return null;
+  const key = trimmed.slice(0, eq).trim();
+  let value = trimmed.slice(eq + 1).trim();
+  if (
+    (value.startsWith('"') && value.endsWith('"')) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    value = value.slice(1, -1);
+  }
+  return { key, value };
+}
+
+export async function readConfig(): Promise<ClaudeSmartConfig> {
+  const defaults: ClaudeSmartConfig = {
+    REFLEXIO_URL: "http://localhost:8071/",
+    CLAUDE_SMART_USE_LOCAL_CLI: false,
+    CLAUDE_SMART_USE_LOCAL_EMBEDDING: false,
+    CLAUDE_SMART_CLI_PATH: "",
+    CLAUDE_SMART_CLI_TIMEOUT: "120",
+    CLAUDE_SMART_STATE_DIR: "",
+  };
+  let text: string;
+  try {
+    text = await fs.readFile(envPath(), "utf-8");
+  } catch {
+    return defaults;
+  }
+  const out: ClaudeSmartConfig = { ...defaults };
+  for (const line of text.split("\n")) {
+    const pair = parseLine(line);
+    if (!pair) continue;
+    if (!KNOWN.has(pair.key)) continue;
+    if (BOOL_KEYS.has(pair.key)) {
+      out[pair.key] = pair.value === "1" || pair.value.toLowerCase() === "true";
+    } else {
+      out[pair.key] = pair.value;
+    }
+  }
+  return out;
+}
+
+export async function writeConfig(update: Partial<ClaudeSmartConfig>): Promise<void> {
+  const file = envPath();
+  await fs.mkdir(path.dirname(file), { recursive: true });
+
+  const safeUpdate = Object.fromEntries(
+    Object.entries(update).filter(([k]) => KNOWN.has(k)),
+  );
+
+  let existing = "";
+  try {
+    existing = await fs.readFile(file, "utf-8");
+  } catch {
+    existing = "";
+  }
+
+  const lines = existing.split("\n");
+  const seen = new Set<string>();
+  const outLines: string[] = [];
+
+  for (const line of lines) {
+    const pair = parseLine(line);
+    if (!pair) {
+      outLines.push(line);
+      continue;
+    }
+    if (pair.key in safeUpdate) {
+      seen.add(pair.key);
+      const raw = safeUpdate[pair.key];
+      outLines.push(`${pair.key}=${formatValue(pair.key, raw)}`);
+    } else {
+      outLines.push(line);
+    }
+  }
+
+  for (const key of Object.keys(safeUpdate)) {
+    if (seen.has(key)) continue;
+    const raw = safeUpdate[key];
+    if (raw === undefined || raw === "") continue;
+    outLines.push(`${key}=${formatValue(key, raw)}`);
+  }
+
+  const content = outLines.join("\n");
+  await fs.writeFile(file, content.endsWith("\n") ? content : content + "\n", {
+    encoding: "utf-8",
+    mode: 0o600,
+  });
+}
+
+function formatValue(key: string, raw: unknown): string {
+  if (BOOL_KEYS.has(key)) {
+    return raw === true || raw === "1" || raw === "true" ? "1" : "0";
+  }
+  return String(raw ?? "");
+}
+
+export { KNOWN_KEYS };

package/plugin/dashboard/lib/format.ts

@@ -0,0 +1,58 @@
+export function formatTimestamp(ts: number | null | undefined): string {
+  if (!ts) return "—";
+  const ms = ts < 1e12 ? ts * 1000 : ts;
+  const d = new Date(ms);
+  if (Number.isNaN(d.getTime())) return "—";
+  return d.toLocaleString(undefined, {
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+}
+
+export function formatRelative(ts: number | null | undefined): string {
+  if (!ts) return "—";
+  const ms = ts < 1e12 ? ts * 1000 : ts;
+  const diff = Date.now() - ms;
+  if (diff < 0) return "just now";
+  const s = Math.floor(diff / 1000);
+  if (s < 60) return `${s}s ago`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  const days = Math.floor(h / 24);
+  if (days < 30) return `${days}d ago`;
+  return formatTimestamp(ts);
+}
+
+export function truncate(text: string, n: number): string {
+  if (text.length <= n) return text;
+  return text.slice(0, n - 1).trimEnd() + "…";
+}
+
+export function truncateId(id: string, prefix = 8, suffix = 4): string {
+  if (id.length <= prefix + suffix + 1) return id;
+  return `${id.slice(0, prefix)}…${id.slice(-suffix)}`;
+}
+
+export function dayBucket(ts: number | null | undefined): string {
+  if (!ts) return "Unknown";
+  const ms = ts < 1e12 ? ts * 1000 : ts;
+  const d = new Date(ms);
+  const now = new Date();
+  const startOfToday = new Date(
+    now.getFullYear(),
+    now.getMonth(),
+    now.getDate(),
+  ).getTime();
+  const oneDay = 86_400_000;
+  if (d.getTime() >= startOfToday) return "Today";
+  if (d.getTime() >= startOfToday - oneDay) return "Yesterday";
+  if (d.getTime() >= startOfToday - 7 * oneDay) return "Earlier this week";
+  if (d.getFullYear() === now.getFullYear()) {
+    return d.toLocaleDateString(undefined, { month: "long" });
+  }
+  return d.toLocaleDateString(undefined, { year: "numeric", month: "long" });
+}

package/plugin/dashboard/lib/reflexio-client.ts

@@ -0,0 +1,238 @@
+/**
+ * Client-side wrapper for talking to reflexio through the Next.js proxy at
+ * /api/reflexio/*. The proxy forwards to the reflexio URL the user picked in
+ * Settings (see hooks/use-settings.tsx). Endpoint paths and request bodies
+ * mirror reflexio/reflexio/server/api.py — every call below corresponds to a
+ * FastAPI route mounted under the /api prefix.
+ */
+
+import type {
+  AgentPlaybook,
+  AgentPlaybookStatus,
+  Interaction,
+  UserPlaybook,
+  UserProfile,
+} from "./types";
+
+type Json = Record<string, unknown>;
+
+interface Opts {
+  reflexioUrl?: string;
+}
+
+async function request<T>(
+  path: string,
+  init: RequestInit,
+  reflexioUrl: string | undefined,
+): Promise<T> {
+  const headers = new Headers(init.headers);
+  headers.set("content-type", "application/json");
+  if (reflexioUrl) headers.set("x-reflexio-url", reflexioUrl);
+
+  const res = await fetch(`/api/reflexio/api/${path.replace(/^\/+/, "")}`, {
+    ...init,
+    headers,
+    cache: "no-store",
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`reflexio ${res.status}: ${body.slice(0, 300)}`);
+  }
+  return res.json() as Promise<T>;
+}
+
+function post<T>(path: string, body: Json, reflexioUrl?: string): Promise<T> {
+  return request<T>(path, { method: "POST", body: JSON.stringify(body) }, reflexioUrl);
+}
+
+function get<T>(path: string, reflexioUrl?: string): Promise<T> {
+  return request<T>(path, { method: "GET" }, reflexioUrl);
+}
+
+export const reflexio = {
+  /** POST /api/get_user_playbooks — all filters are optional. */
+  async getUserPlaybooks(
+    opts: Opts & {
+      userId?: string;
+      agentVersion?: string;
+      playbookName?: string;
+      statusFilter?: (string | null)[];
+      limit?: number;
+    },
+  ): Promise<{ user_playbooks: UserPlaybook[] }> {
+    const body: Json = { limit: opts.limit ?? 100 };
+    if (opts.userId) body.user_id = opts.userId;
+    if (opts.agentVersion) body.agent_version = opts.agentVersion;
+    if (opts.playbookName) body.playbook_name = opts.playbookName;
+    if (opts.statusFilter) body.status_filter = opts.statusFilter;
+    return post("get_user_playbooks", body, opts.reflexioUrl);
+  },
+
+  /** POST /api/get_agent_playbooks — all filters are optional. */
+  async getAgentPlaybooks(
+    opts: Opts & {
+      agentVersion?: string;
+      playbookName?: string;
+      statusFilter?: (string | null)[];
+      playbookStatusFilter?: AgentPlaybookStatus;
+      limit?: number;
+    },
+  ): Promise<{ agent_playbooks: AgentPlaybook[] }> {
+    const body: Json = { limit: opts.limit ?? 100 };
+    if (opts.agentVersion) body.agent_version = opts.agentVersion;
+    if (opts.playbookName) body.playbook_name = opts.playbookName;
+    if (opts.statusFilter) body.status_filter = opts.statusFilter;
+    if (opts.playbookStatusFilter)
+      body.playbook_status_filter = opts.playbookStatusFilter;
+    return post("get_agent_playbooks", body, opts.reflexioUrl);
+  },
+
+  /**
+   * GET /api/get_all_profiles — no per-user filter required. Returns all
+   * preferences across sessions, which is what the dashboard wants.
+   */
+  async getAllProfiles(
+    opts: Opts & { limit?: number; statusFilter?: string } = {},
+  ): Promise<{ user_profiles: UserProfile[] }> {
+    const qs = new URLSearchParams();
+    qs.set("limit", String(opts.limit ?? 200));
+    if (opts.statusFilter) qs.set("status_filter", opts.statusFilter);
+    return get(`get_all_profiles?${qs.toString()}`, opts.reflexioUrl);
+  },
+
+  /** GET /api/get_all_interactions — global, unfiltered. */
+  async getAllInteractions(
+    opts: Opts & { limit?: number } = {},
+  ): Promise<{ interactions: Interaction[] }> {
+    const qs = new URLSearchParams();
+    qs.set("limit", String(opts.limit ?? 100));
+    return get(`get_all_interactions?${qs.toString()}`, opts.reflexioUrl);
+  },
+
+  /** PUT /api/update_user_playbook — partial update of one project-specific skill. */
+  async updateUserPlaybook(
+    update: {
+      user_playbook_id: number;
+      playbook_name?: string | null;
+      content?: string | null;
+      trigger?: string | null;
+      rationale?: string | null;
+    },
+    reflexioUrl?: string,
+  ): Promise<Json> {
+    return request(
+      "update_user_playbook",
+      { method: "PUT", body: JSON.stringify(update) },
+      reflexioUrl,
+    );
+  },
+
+  /** PUT /api/update_agent_playbook — partial update of one shared skill. */
+  async updateAgentPlaybook(
+    update: {
+      agent_playbook_id: number;
+      playbook_name?: string | null;
+      content?: string | null;
+      trigger?: string | null;
+      rationale?: string | null;
+      playbook_status?: AgentPlaybookStatus | null;
+    },
+    reflexioUrl?: string,
+  ): Promise<Json> {
+    return request(
+      "update_agent_playbook",
+      { method: "PUT", body: JSON.stringify(update) },
+      reflexioUrl,
+    );
+  },
+
+  /** DELETE /api/delete_user_playbook — body carries the id. */
+  async deleteUserPlaybook(
+    userPlaybookId: number,
+    reflexioUrl?: string,
+  ): Promise<Json> {
+    return request(
+      "delete_user_playbook",
+      {
+        method: "DELETE",
+        body: JSON.stringify({ user_playbook_id: userPlaybookId }),
+      },
+      reflexioUrl,
+    );
+  },
+
+  /** DELETE /api/delete_agent_playbook — body carries the id. */
+  async deleteAgentPlaybook(
+    agentPlaybookId: number,
+    reflexioUrl?: string,
+  ): Promise<Json> {
+    return request(
+      "delete_agent_playbook",
+      {
+        method: "DELETE",
+        body: JSON.stringify({ agent_playbook_id: agentPlaybookId }),
+      },
+      reflexioUrl,
+    );
+  },
+
+  /** PUT /api/update_user_profile — partial update; content is the common field. */
+  async updateUserProfile(
+    update: {
+      user_id: string;
+      profile_id: string;
+      content?: string | null;
+    },
+    reflexioUrl?: string,
+  ): Promise<Json> {
+    return request(
+      "update_user_profile",
+      { method: "PUT", body: JSON.stringify(update) },
+      reflexioUrl,
+    );
+  },
+
+  /** DELETE /api/delete_profile — needs both user_id and profile_id. */
+  async deleteUserProfile(
+    params: { user_id: string; profile_id: string },
+    reflexioUrl?: string,
+  ): Promise<Json> {
+    return request(
+      "delete_profile",
+      { method: "DELETE", body: JSON.stringify(params) },
+      reflexioUrl,
+    );
+  },
+
+  /** DELETE /api/delete_all_interactions — org-wide purge. */
+  async deleteAllInteractions(reflexioUrl?: string): Promise<Json> {
+    return request(
+      "delete_all_interactions",
+      { method: "DELETE" },
+      reflexioUrl,
+    );
+  },
+
+  /** DELETE /api/delete_all_profiles — org-wide purge. */
+  async deleteAllProfiles(reflexioUrl?: string): Promise<Json> {
+    return request("delete_all_profiles", { method: "DELETE" }, reflexioUrl);
+  },
+
+  /** DELETE /api/delete_all_user_playbooks — org-wide purge. */
+  async deleteAllUserPlaybooks(reflexioUrl?: string): Promise<Json> {
+    return request(
+      "delete_all_user_playbooks",
+      { method: "DELETE" },
+      reflexioUrl,
+    );
+  },
+
+  /** DELETE /api/delete_all_agent_playbooks — org-wide shared skill purge. */
+  async deleteAllAgentPlaybooks(reflexioUrl?: string): Promise<Json> {
+    return request(
+      "delete_all_agent_playbooks",
+      { method: "DELETE" },
+      reflexioUrl,
+    );
+  },
+};

package/plugin/dashboard/lib/reflexio-url.ts

@@ -0,0 +1,17 @@
+/**
+ * Normalize a user-pasted Reflexio URL down to just the origin (scheme +
+ * host + port). The dashboard proxy appends `/api/...` itself, so if the
+ * user pastes `http://localhost:8071/api` we must strip the path —
+ * otherwise FastAPI receives `/api/api/...` and returns 404.
+ *
+ * Returns null for empty input or anything the URL parser rejects.
+ */
+export function originOnly(raw: string): string | null {
+  const candidate = raw.trim();
+  if (!candidate) return null;
+  try {
+    return new URL(candidate).origin;
+  } catch {
+    return null;
+  }
+}