claude-smart 0.2.23 → 0.2.24

package/plugin/dashboard/lib/session-reader.ts

@@ -0,0 +1,245 @@
+/**
+ * Server-side reader for claude-smart JSONL session buffers.
+ * Mirrors the format documented in src/claude_smart/state.py:
+ *   - {role: "User" | "Assistant" | "Assistant_tool", ...}
+ *   - {published_up_to: N}  watermark
+ */
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import type {
+  CitedItem,
+  SessionDetail,
+  SessionSummary,
+  SessionTurn,
+  ToolUsed,
+  UserActionType,
+} from "./types";
+
+// Mirrors _TOOL_DATA_FIELD_MAX_LEN in plugin/src/claude_smart/state.py — we
+// truncate to the same length the publisher ships to reflexio so the
+// dashboard renders the exact bytes the extractor sees.
+const TOOL_DATA_FIELD_MAX_LEN = 256;
+
+function truncateToolField<T>(value: T): T {
+  if (typeof value === "string" && value.length > TOOL_DATA_FIELD_MAX_LEN) {
+    return value.slice(0, TOOL_DATA_FIELD_MAX_LEN) as T;
+  }
+  return value;
+}
+
+export function stateDir(): string {
+  const override = process.env.CLAUDE_SMART_STATE_DIR;
+  if (override) return override;
+  return path.join(os.homedir(), ".claude-smart", "sessions");
+}
+
+type RawRecord = {
+  role?: "User" | "Assistant" | "Assistant_tool";
+  content?: string;
+  ts?: number;
+  user_id?: string;
+  tool_name?: string;
+  tool_input?: Record<string, unknown>;
+  tool_output?: string;
+  status?: string;
+  user_action?: UserActionType;
+  user_action_description?: string;
+  cited_items?: CitedItem[];
+  published_up_to?: number;
+};
+
+async function readJsonl(filePath: string): Promise<RawRecord[]> {
+  const text = await fs.readFile(filePath, "utf-8");
+  const out: RawRecord[] = [];
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      // skip malformed line, matches state.py behaviour
+    }
+  }
+  return out;
+}
+
+function foldTurns(records: RawRecord[]): {
+  turns: SessionTurn[];
+  publishedUpTo: number;
+  learningInteractionCount: number;
+  lastTs: number | null;
+  firstTs: number | null;
+  preview: string | null;
+} {
+  let published = 0;
+  let pendingTools: ToolUsed[] = [];
+  const turns: SessionTurn[] = [];
+  let learningInteractionCount = 0;
+  let lastTs: number | null = null;
+  let firstTs: number | null = null;
+  let preview: string | null = null;
+
+  for (let idx = 0; idx < records.length; idx++) {
+    const rec = records[idx];
+    if (typeof rec.published_up_to === "number") {
+      published = rec.published_up_to;
+      pendingTools = [];
+      continue;
+    }
+    const role = rec.role;
+    if (role === "Assistant_tool") {
+      const entry: ToolUsed = {
+        tool_name: rec.tool_name ?? "",
+        status: rec.status ?? "success",
+      };
+      const toolData: { input?: Record<string, unknown>; output?: string } = {};
+      if (rec.tool_input && Object.keys(rec.tool_input).length > 0) {
+        const input: Record<string, unknown> = {};
+        for (const [k, v] of Object.entries(rec.tool_input)) {
+          input[k] = truncateToolField(v);
+        }
+        toolData.input = input;
+      }
+      if (typeof rec.tool_output === "string" && rec.tool_output.length > 0) {
+        toolData.output = truncateToolField(rec.tool_output);
+      }
+      if (toolData.input || toolData.output) {
+        entry.tool_data = toolData;
+      }
+      pendingTools.push(entry);
+      continue;
+    }
+    if (role !== "User" && role !== "Assistant") continue;
+
+    if (
+      role === "Assistant" &&
+      rec.cited_items &&
+      rec.cited_items.length > 0
+    ) {
+      learningInteractionCount += 1;
+    }
+    if (typeof rec.ts === "number") {
+      lastTs = rec.ts;
+      if (firstTs === null) firstTs = rec.ts;
+    }
+
+    const turn: SessionTurn = {
+      role,
+      content: rec.content ?? "",
+      ts: rec.ts,
+      user_id: rec.user_id,
+      user_action: rec.user_action,
+      user_action_description: rec.user_action_description,
+    };
+    if (role === "Assistant" && pendingTools.length) {
+      turn.tools_used = pendingTools;
+      pendingTools = [];
+    }
+    if (role === "Assistant" && rec.cited_items && rec.cited_items.length) {
+      turn.cited_items = rec.cited_items;
+    }
+    if (
+      preview === null &&
+      role === "User" &&
+      typeof turn.content === "string" &&
+      turn.content.trim()
+    ) {
+      preview = turn.content.trim().slice(0, 240);
+    }
+    turns.push(turn);
+  }
+
+  return {
+    turns,
+    publishedUpTo: published,
+    learningInteractionCount,
+    lastTs,
+    firstTs,
+    preview,
+  };
+}
+
+export async function listSessions(): Promise<SessionSummary[]> {
+  const dir = stateDir();
+  let entries: string[];
+  try {
+    entries = await fs.readdir(dir);
+  } catch {
+    return [];
+  }
+
+  const summaries: SessionSummary[] = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".jsonl")) continue;
+    if (entry.endsWith(".injected.jsonl")) continue;
+    const fullPath = path.join(dir, entry);
+    const records = await readJsonl(fullPath).catch(() => []);
+    const {
+      turns,
+      publishedUpTo,
+      learningInteractionCount,
+      lastTs,
+      firstTs,
+      preview,
+    } = foldTurns(records);
+    summaries.push({
+      session_id: entry.replace(/\.jsonl$/, ""),
+      turn_count: turns.length,
+      learning_interaction_count: learningInteractionCount,
+      last_activity: lastTs,
+      first_activity: firstTs,
+      published_up_to: publishedUpTo,
+      preview,
+      source: "local",
+    });
+  }
+  summaries.sort((a, b) => (b.last_activity ?? 0) - (a.last_activity ?? 0));
+  return summaries;
+}
+
+export async function deleteSession(sessionId: string): Promise<boolean> {
+  const file = path.join(stateDir(), `${sessionId}.jsonl`);
+  try {
+    await fs.unlink(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function deleteAllSessions(): Promise<number> {
+  const dir = stateDir();
+  let entries: string[];
+  try {
+    entries = await fs.readdir(dir);
+  } catch {
+    return 0;
+  }
+  let count = 0;
+  for (const entry of entries) {
+    if (!entry.endsWith(".jsonl")) continue;
+    try {
+      await fs.unlink(path.join(dir, entry));
+      count += 1;
+    } catch {
+      // ignore
+    }
+  }
+  return count;
+}
+
+export async function readSession(
+  sessionId: string,
+): Promise<SessionDetail | null> {
+  const file = path.join(stateDir(), `${sessionId}.jsonl`);
+  let records: RawRecord[];
+  try {
+    records = await readJsonl(file);
+  } catch {
+    return null;
+  }
+  const { turns, publishedUpTo } = foldTurns(records);
+  return { session_id: sessionId, turns, published_up_to: publishedUpTo };
+}

package/plugin/dashboard/lib/status.ts

@@ -0,0 +1,24 @@
+// Wire status comes from Python's Status StrEnum: lowercase strings
+// ("archived", "pending"). CURRENT rows are omitted from JSON entirely
+// (response_model_exclude_none) and arrive as `null`/undefined.
+// Normalize to the uppercase label the dashboard renders.
+
+export type StatusLabel = "CURRENT" | "ARCHIVED" | "PENDING";
+export type AgentPlaybookStatusLabel = "PENDING" | "APPROVED" | "REJECTED";
+
+export function statusLabel(p: { status?: string | null }): StatusLabel {
+  if (!p.status) return "CURRENT";
+  const s = String(p.status).toLowerCase();
+  if (s === "archived") return "ARCHIVED";
+  if (s === "pending") return "PENDING";
+  return "CURRENT";
+}
+
+export function agentPlaybookStatusLabel(p: {
+  playbook_status?: string | null;
+}): AgentPlaybookStatusLabel {
+  const s = String(p.playbook_status ?? "pending").toLowerCase();
+  if (s === "approved") return "APPROVED";
+  if (s === "rejected") return "REJECTED";
+  return "PENDING";
+}

package/plugin/dashboard/lib/types.ts

@@ -0,0 +1,145 @@
+export type UserActionType =
+  | "NONE"
+  | "CORRECTIVE_PHRASE"
+  | "CORRECTION"
+  | "PRAISE"
+  | "STOP";
+
+// Wire format from the reflexio API. CURRENT rows arrive as `status: null`
+// (response_model_exclude_none strips it from the JSON entirely), so the type
+// only enumerates the non-null values. The values are lowercase because they
+// come from Python's Status StrEnum.
+export type LifecycleStatus = "pending" | "archived";
+
+export type AgentPlaybookStatus = "pending" | "approved" | "rejected";
+
+export type ProfileStatus = "pending" | "archived";
+
+export interface ToolUsed {
+  tool_name: string;
+  status: string;
+  tool_data?: { input?: Record<string, unknown>; output?: string };
+}
+
+export interface CitedItem {
+  id: string;
+  kind: "playbook" | "profile";
+  title: string;
+  real_id?: string;
+  source_kind?: "user_playbook" | "agent_playbook" | "profile";
+}
+
+export interface Interaction {
+  interaction_id: number;
+  user_id: string;
+  request_id: string;
+  created_at: number;
+  role: string;
+  content: string;
+  user_action: UserActionType;
+  user_action_description?: string;
+  tools_used: ToolUsed[];
+}
+
+export interface UserPlaybook {
+  user_playbook_id: number;
+  user_id: string | null;
+  agent_version: string;
+  request_id: string;
+  playbook_name: string;
+  created_at: number;
+  content: string;
+  trigger: string | null;
+  rationale: string | null;
+  status: LifecycleStatus | null;
+  source: string | null;
+  source_interaction_ids: number[];
+}
+
+export interface AgentPlaybook {
+  agent_playbook_id: number;
+  playbook_name: string;
+  agent_version: string;
+  created_at: number;
+  content: string;
+  trigger: string | null;
+  rationale: string | null;
+  playbook_status: AgentPlaybookStatus;
+  playbook_metadata: string;
+  status: LifecycleStatus | null;
+}
+
+export interface UserProfile {
+  profile_id: string;
+  user_id: string;
+  content: string;
+  last_modified_timestamp: number;
+  generated_from_request_id: string;
+  profile_time_to_live?: string;
+  expiration_timestamp?: number;
+  custom_features?: Record<string, unknown> | null;
+  extractor_names?: string[] | null;
+  status: ProfileStatus | null;
+  source: string | null;
+}
+
+export interface SessionTurn {
+  role: "User" | "Assistant";
+  content: string;
+  ts?: number;
+  user_id?: string;
+  tools_used?: ToolUsed[];
+  cited_items?: CitedItem[];
+  user_action?: UserActionType;
+  user_action_description?: string;
+}
+
+export interface SessionSummary {
+  session_id: string;
+  turn_count: number;
+  learning_interaction_count: number;
+  last_activity: number | null;
+  first_activity: number | null;
+  published_up_to: number;
+  preview: string | null;
+  source: "local";
+}
+
+export interface SessionDetail {
+  session_id: string;
+  turns: SessionTurn[];
+  published_up_to: number;
+}
+
+export interface ClaudeSmartConfig {
+  REFLEXIO_URL: string;
+  CLAUDE_SMART_USE_LOCAL_CLI: boolean;
+  CLAUDE_SMART_USE_LOCAL_EMBEDDING: boolean;
+  CLAUDE_SMART_CLI_PATH: string;
+  CLAUDE_SMART_CLI_TIMEOUT: string;
+  CLAUDE_SMART_STATE_DIR: string;
+  [extra: string]: string | boolean;
+}
+
+export interface ClaudeCodeHookConfig {
+  CLAUDE_SMART_ENABLE_OPTIMIZER: boolean;
+  effectiveValue: boolean;
+  localValue: boolean | null;
+  userValue: boolean | null;
+  settingsPath: string;
+  userSettingsPath: string;
+}
+
+export interface ReflexioExtractorConfig {
+  extraction_definition_prompt?: string;
+  [k: string]: unknown;
+}
+
+export interface ReflexioConfig {
+  agent_context_prompt?: string | null;
+  window_size?: number;
+  stride_size?: number;
+  profile_extractor_configs?: ReflexioExtractorConfig[] | null;
+  user_playbook_extractor_configs?: ReflexioExtractorConfig[] | null;
+  [k: string]: unknown;
+}

package/plugin/dashboard/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

package/plugin/dashboard/next.config.ts

@@ -0,0 +1,7 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  /* config options here */
+};
+
+export default nextConfig;