assistme 0.0.1 → 0.1.0

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "semi": true,
+  "singleQuote": false,
+  "trailingComma": "es5",
+  "printWidth": 100,
+  "tabWidth": 2
+}

package/PLAN.md

@@ -0,0 +1,135 @@
+# AssistMe CLI Agent - Implementation Plan
+
+## Vision
+Build a CLI tool under `packages/assistme` based on Claude Agent SDK that:
+- Runs as a local daemon, listening for tasks from the web UI
+- Processes messages using Claude Agent SDK with full agentic capabilities (tool use, multi-turn)
+- Streams real-time events (thinking, tool calls, text output) back to the web UI
+- Surpasses OpenClaw by offering: streaming UI, visible tool execution, workspace awareness, and tight web integration
+
+## Architecture
+
+```
+┌─────────────┐     ┌──────────────┐     ┌──────────────────┐
+│   Web UI    │────▶│  Supabase DB │◀────│  CLI Agent       │
+│  (web/)     │◀────│              │────▶│  (packages/      │
+│             │     │ agent_tasks  │     │   assistme/)     │
+│ Send message│     │ task_events  │     │                  │
+│ See results │     │ sessions     │     │ Claude Agent SDK │
+└─────────────┘     └──────────────┘     └──────────────────┘
+
+Flow:
+1. User sends message on web → inserts into agent_tasks (status: pending)
+2. CLI agent polls/subscribes → picks up task (status: running)
+3. Claude Agent SDK processes → streams events to agent_task_events
+4. Web UI polls task_events → renders streaming output in real-time
+5. Task completes → status: completed, final response stored
+```
+
+## Database Design
+
+### New Tables Needed
+
+#### 1. `agent_sessions` - Track running CLI agent instances
+```sql
+- id: UUID PK
+- user_id: UUID FK → user_profiles
+- session_name: VARCHAR(100) -- e.g., "My Workspace"
+- status: VARCHAR(20) -- 'online', 'offline', 'busy'
+- workspace_path: TEXT -- local filesystem path the agent operates in
+- agent_version: VARCHAR(50)
+- started_at: TIMESTAMPTZ
+- last_heartbeat_at: TIMESTAMPTZ -- CLI sends heartbeat every 30s
+- ended_at: TIMESTAMPTZ
+- metadata: JSONB -- capabilities, config, etc.
+- created_at: TIMESTAMPTZ
+```
+
+#### 2. `agent_tasks` - Commands/tasks from web to CLI
+```sql
+- id: UUID PK
+- session_id: UUID FK → agent_sessions
+- user_id: UUID FK → user_profiles
+- conversation_id: UUID FK → conversations (nullable, for context threading)
+- prompt: TEXT -- the user's message/command
+- status: VARCHAR(20) -- 'pending', 'running', 'completed', 'failed', 'cancelled'
+- result_summary: TEXT -- final text response
+- error_message: TEXT
+- token_usage: JSONB -- {prompt_tokens, completion_tokens, total_tokens}
+- started_at: TIMESTAMPTZ
+- completed_at: TIMESTAMPTZ
+- created_at: TIMESTAMPTZ
+- updated_at: TIMESTAMPTZ
+```
+
+#### 3. `agent_task_events` - Streaming events from CLI
+```sql
+- id: UUID PK
+- task_id: UUID FK → agent_tasks
+- event_type: VARCHAR(30) -- 'text_delta', 'tool_use_start', 'tool_use_input', 'tool_result', 'thinking', 'error', 'status_change'
+- event_data: JSONB -- flexible payload per event type
+- sequence_number: INTEGER -- ordering within a task
+- created_at: TIMESTAMPTZ
+```
+
+### Existing Tables - No Changes Needed
+- `conversations` - Can be reused for threading agent task history
+- `chat_messages` - Not used directly (agent_tasks + agent_task_events replace this)
+- `user_profiles` - No changes needed
+- `user_credits` / `llm_token_usage` - Reused for billing
+
+## Package Structure
+
+```
+packages/assistme/
+├── package.json          # CLI package with bin entry
+├── tsconfig.json
+├── src/
+│   ├── index.ts          # CLI entry point (commander.js)
+│   ├── agent/
+│   │   ├── session.ts    # Session management (heartbeat, lifecycle)
+│   │   └── processor.ts  # Task processor using Claude Agent SDK
+│   ├── db/
+│   │   └── supabase.ts   # Supabase client for task polling & event writing
+│   ├── tools/
+│   │   ├── index.ts      # MCP tool registry
+│   │   ├── filesystem.ts # File read/write/search tools
+│   │   ├── shell.ts      # Shell command execution
+│   │   └── web.ts        # Web search/fetch tools
+│   └── utils/
+│       ├── config.ts     # Config management (.assistme.json)
+│       └── logger.ts     # Structured logging with levels
+├── .assistme.json.example
+└── README.md
+```
+
+## Web UI Addition (web/src/)
+
+New page: `/agent` - Agent chat interface
+- Message input with send button
+- Streaming output display (text, tool calls, results)
+- Session status indicator (online/offline)
+- Task history sidebar
+
+## Implementation Steps
+
+### Phase 1: Database (Migration)
+1. Create migration for agent_sessions, agent_tasks, agent_task_events
+2. Add RLS policies and indexes
+
+### Phase 2: CLI Package
+1. Set up package.json with dependencies
+2. Implement Supabase client for DB communication
+3. Implement session management (start/stop/heartbeat)
+4. Implement task processor with Claude Agent SDK
+5. Implement MCP tools (filesystem, shell, web)
+6. Wire up CLI commands (assistme start, assistme login, assistme status)
+
+### Phase 3: Web UI
+1. Create /agent page with chat interface
+2. Implement task submission (insert into agent_tasks)
+3. Implement event polling (poll agent_task_events)
+4. Render streaming events (text, tool use, thinking)
+
+### Phase 4: Edge Function
+1. Create agent-submit-task edge function for mobile clients

package/README.md

@@ -1 +1,57 @@
-assist me ai
+# @assistme/cli
+
+AI-powered CLI agent that connects to the AssistMe web UI. Send messages from the web, and the CLI agent processes them locally using Claude with full tool access (file operations, shell commands, web search).
+
+## Quick Start
+
+```bash
+# Install dependencies
+cd packages/assistme && npm install
+
+# Build
+npm run build
+
+# Configure
+assistme config set supabaseUrl https://your-project.supabase.co
+assistme config set supabaseAnonKey your-anon-key
+assistme config set anthropicApiKey sk-ant-...
+
+# Login
+assistme login -e your@email.com -p your-password
+
+# Start the agent (in your project directory)
+assistme start
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `assistme start` | Start the agent daemon and listen for tasks |
+| `assistme login` | Authenticate with your AssistMe account |
+| `assistme status` | Check active sessions |
+| `assistme config set <key> <value>` | Set configuration |
+| `assistme config show` | Show current configuration |
+
+## Architecture
+
+```
+Web UI → Supabase DB (agent_tasks) → CLI Agent → Claude API → Tool Execution → Events back to DB → Web UI
+```
+
+The CLI agent:
+1. Registers a session in `agent_sessions`
+2. Polls `agent_tasks` for new pending tasks
+3. Processes each task using Claude with tool access
+4. Streams events to `agent_task_events` (text, tool calls, results)
+5. Web UI polls events for real-time display
+
+## Tools Available
+
+- **read_file** - Read file contents with line numbers
+- **write_file** - Create or overwrite files
+- **search_files** - Glob pattern file search
+- **search_content** - Regex content search across files
+- **list_directory** - List directory contents
+- **execute_command** - Run shell commands
+- **web_fetch** - Fetch web page content

package/dist/chunk-3TP3YO56.js

@@ -0,0 +1,410 @@
+// src/db/supabase.ts
+import { createClient } from "@supabase/supabase-js";
+
+// src/utils/config.ts
+import Conf from "conf";
+import { resolve } from "path";
+var CONFIG_DEFAULTS = {
+  sessionName: "Default",
+  model: "claude-sonnet-4-20250514",
+  maxTurns: 50
+};
+var config = new Conf({
+  projectName: "assistme",
+  defaults: CONFIG_DEFAULTS
+});
+function getConfig() {
+  const supabaseUrl = process.env.SUPABASE_URL || config.get("supabaseUrl") || "";
+  const supabaseAnonKey = process.env.SUPABASE_ANON_KEY || config.get("supabaseAnonKey") || "";
+  const anthropicApiKey = process.env.ANTHROPIC_API_KEY || config.get("anthropicApiKey") || "";
+  const workspacePath = config.get("workspacePath") || process.cwd();
+  return {
+    supabaseUrl,
+    supabaseAnonKey,
+    anthropicApiKey,
+    workspacePath: resolve(workspacePath),
+    sessionName: config.get("sessionName") || "Default",
+    model: config.get("model") || "claude-sonnet-4-20250514",
+    maxTurns: config.get("maxTurns") || 50
+  };
+}
+function setConfig(key, value) {
+  config.set(key, value);
+}
+function clearConfig() {
+  config.clear();
+}
+function getConfigPath() {
+  return config.path;
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+import { randomUUID } from "crypto";
+var currentLevel = "info";
+var currentCorrelationId = null;
+var LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function setCorrelationId(id) {
+  currentCorrelationId = id;
+}
+function newCorrelationId() {
+  const id = randomUUID().slice(0, 8);
+  currentCorrelationId = id;
+  return id;
+}
+function shouldLog(level) {
+  return LEVEL_ORDER[level] >= LEVEL_ORDER[currentLevel];
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+}
+function prefix() {
+  const ts = timestamp();
+  return currentCorrelationId ? `${ts} ${currentCorrelationId}` : ts;
+}
+var log = {
+  debug(msg, ...args) {
+    if (shouldLog("debug")) {
+      console.log(chalk.gray(`[${prefix()}] DEBUG`), msg, ...args);
+    }
+  },
+  info(msg, ...args) {
+    if (shouldLog("info")) {
+      console.log(chalk.blue(`[${prefix()}]`), msg, ...args);
+    }
+  },
+  success(msg, ...args) {
+    if (shouldLog("info")) {
+      console.log(chalk.green(`[${prefix()}] \u2713`), msg, ...args);
+    }
+  },
+  warn(msg, ...args) {
+    if (shouldLog("warn")) {
+      console.log(chalk.yellow(`[${prefix()}] WARN`), msg, ...args);
+    }
+  },
+  error(msg, ...args) {
+    if (shouldLog("error")) {
+      console.error(chalk.red(`[${prefix()}] ERROR`), msg, ...args);
+    }
+  },
+  agent(msg) {
+    console.log(chalk.cyan("  \u25B8"), msg);
+  },
+  tool(name, msg) {
+    console.log(chalk.magenta(`  \u26A1 ${name}:`), msg);
+  },
+  result(msg) {
+    console.log(chalk.green("  \u2190"), msg);
+  }
+};
+
+// src/db/supabase.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CLI_AGENT_ID = "00000000-0000-0000-0000-000000000001";
+var DAYBOX_AGENT_ID = "00000000-0000-0000-0000-000000000002";
+var AUTH_DIR = join(homedir(), ".config", "assistme");
+var AUTH_FILE = join(AUTH_DIR, "auth.json");
+function ensureAuthDir() {
+  if (!existsSync(AUTH_DIR)) {
+    mkdirSync(AUTH_DIR, { recursive: true, mode: 448 });
+  }
+}
+function readAuthStore() {
+  try {
+    if (existsSync(AUTH_FILE)) {
+      return JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+function writeAuthStore(data) {
+  ensureAuthDir();
+  writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), { mode: 384 });
+}
+var fileStorage = {
+  getItem(key) {
+    const store = readAuthStore();
+    return store[key] ?? null;
+  },
+  setItem(key, value) {
+    const store = readAuthStore();
+    store[key] = value;
+    writeAuthStore(store);
+  },
+  removeItem(key) {
+    const store = readAuthStore();
+    delete store[key];
+    writeAuthStore(store);
+  }
+};
+var supabase = null;
+function getSupabase() {
+  if (!supabase) {
+    const config2 = getConfig();
+    if (!config2.supabaseUrl || !config2.supabaseAnonKey) {
+      throw new Error(
+        "Supabase not configured. Run `assistme config set supabaseUrl <url>` first."
+      );
+    }
+    supabase = createClient(config2.supabaseUrl, config2.supabaseAnonKey, {
+      auth: {
+        storage: fileStorage,
+        autoRefreshToken: true,
+        persistSession: true
+      }
+    });
+  }
+  return supabase;
+}
+async function loginWithToken(cliToken) {
+  let parsed;
+  try {
+    const json = Buffer.from(cliToken, "base64").toString("utf-8");
+    parsed = JSON.parse(json);
+    if (!parsed.access_token || !parsed.refresh_token) {
+      throw new Error("Missing token fields");
+    }
+  } catch {
+    throw new Error(
+      "Invalid token format. Please copy the full token from the web page."
+    );
+  }
+  const sb = getSupabase();
+  const { data, error } = await sb.auth.setSession({
+    access_token: parsed.access_token,
+    refresh_token: parsed.refresh_token
+  });
+  if (error) throw new Error(`Login failed: ${error.message}`);
+  if (!data.user) throw new Error("Login failed: no user returned");
+  return data.user.id;
+}
+async function getSession() {
+  const sb = getSupabase();
+  const { data } = await sb.auth.getSession();
+  return data.session;
+}
+async function getCurrentUserId() {
+  const sb = getSupabase();
+  const { data, error } = await sb.auth.getUser();
+  if (error || !data.user) {
+    throw new Error("Not authenticated. Run `assistme login`.");
+  }
+  return data.user.id;
+}
+async function logout() {
+  const sb = getSupabase();
+  await sb.auth.signOut();
+  try {
+    writeAuthStore({});
+  } catch {
+  }
+}
+async function createSession(userId, sessionName, workspacePath, version) {
+  const sb = getSupabase();
+  const { data, error } = await sb.from("agent_sessions").insert({
+    user_id: userId,
+    session_name: sessionName,
+    status: "online",
+    workspace_path: workspacePath,
+    agent_version: version,
+    metadata: { model: getConfig().model }
+  }).select().single();
+  if (error) throw new Error(`Failed to create session: ${error.message}`);
+  return data;
+}
+async function updateHeartbeat(sessionId) {
+  const sb = getSupabase();
+  const { error } = await sb.from("agent_sessions").update({ last_heartbeat_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", sessionId);
+  if (error) log.warn(`Heartbeat update failed: ${error.message}`);
+}
+async function endSession(sessionId) {
+  const sb = getSupabase();
+  const { error } = await sb.from("agent_sessions").update({
+    status: "offline",
+    ended_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).eq("id", sessionId);
+  if (error) log.error(`Failed to end session: ${error.message}`);
+}
+async function setSessionBusy(sessionId, busy) {
+  const sb = getSupabase();
+  await sb.from("agent_sessions").update({ status: busy ? "busy" : "online" }).eq("id", sessionId);
+}
+async function getOrCreateCliConversation(userId, sessionId) {
+  const sb = getSupabase();
+  const { data: existing } = await sb.from("conversations").select("id").eq("agent", "cli").eq("created_by", userId).order("created_at", { ascending: false }).limit(1);
+  if (existing && existing.length > 0) {
+    return existing[0].id;
+  }
+  const { data: conv, error: convErr } = await sb.from("conversations").insert({
+    conversation_type: "direct",
+    agent: "cli",
+    created_by: userId
+  }).select("id").single();
+  if (convErr || !conv) {
+    throw new Error(`Failed to create conversation: ${convErr?.message}`);
+  }
+  await sb.from("conversation_participants").insert([
+    { conversation_id: conv.id, user_id: userId, role: "member" },
+    { conversation_id: conv.id, user_id: CLI_AGENT_ID, role: "member" }
+  ]);
+  return conv.id;
+}
+async function createTask(conversationId, userId, sessionId, prompt) {
+  const sb = getSupabase();
+  const { data: rpcResult, error: rpcError } = await sb.rpc(
+    "create_task_pair",
+    {
+      p_conversation_id: conversationId,
+      p_user_id: userId,
+      p_agent_id: CLI_AGENT_ID,
+      p_session_id: sessionId,
+      p_prompt: prompt
+    }
+  );
+  if (!rpcError && rpcResult) {
+    return { ...rpcResult, prompt };
+  }
+  if (rpcError) {
+    log.debug(`create_task_pair RPC unavailable, using fallback: ${rpcError.message}`);
+  }
+  const { error: userErr } = await sb.from("conversation_messages").insert({
+    conversation_id: conversationId,
+    sender_id: userId,
+    role: "user",
+    content: prompt
+  });
+  if (userErr) throw new Error(`Failed to create user message: ${userErr.message}`);
+  const { data, error } = await sb.from("conversation_messages").insert({
+    conversation_id: conversationId,
+    sender_id: CLI_AGENT_ID,
+    role: "assistant",
+    content: "",
+    status: "pending",
+    session_id: sessionId,
+    metadata: { prompt }
+  }).select().single();
+  if (error) throw new Error(`Failed to create task: ${error.message}`);
+  return { ...data, prompt };
+}
+async function pollPendingTasks(sessionId) {
+  const sb = getSupabase();
+  const { data, error } = await sb.from("conversation_messages").select("*").eq("session_id", sessionId).eq("status", "pending").order("created_at", { ascending: true }).limit(1);
+  if (error) {
+    log.warn(`Task poll failed: ${error.message}`);
+    return [];
+  }
+  return (data || []).map((row) => ({
+    ...row,
+    prompt: row.metadata?.prompt || row.content || ""
+  }));
+}
+async function claimTask(messageId) {
+  const sb = getSupabase();
+  const { error } = await sb.from("conversation_messages").update({
+    status: "running",
+    metadata: { started_at: (/* @__PURE__ */ new Date()).toISOString() }
+  }).eq("id", messageId).eq("status", "pending");
+  if (error) throw new Error(`Failed to claim task: ${error.message}`);
+}
+async function completeTask(messageId, resultSummary, tokenUsage) {
+  const sb = getSupabase();
+  const { data: current } = await sb.from("conversation_messages").select("metadata").eq("id", messageId).single();
+  const existingMeta = current?.metadata || {};
+  const { error } = await sb.from("conversation_messages").update({
+    content: resultSummary,
+    status: "completed",
+    metadata: {
+      ...existingMeta,
+      completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+      token_usage: tokenUsage || null
+    }
+  }).eq("id", messageId);
+  if (error) throw new Error(`Failed to complete task: ${error.message}`);
+}
+async function failTask(messageId, errorMessage) {
+  const sb = getSupabase();
+  const { data: current } = await sb.from("conversation_messages").select("metadata").eq("id", messageId).single();
+  const existingMeta = current?.metadata || {};
+  const { error } = await sb.from("conversation_messages").update({
+    status: "failed",
+    content: errorMessage,
+    metadata: {
+      ...existingMeta,
+      completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+      error_message: errorMessage
+    }
+  }).eq("id", messageId);
+  if (error) log.error(`Failed to update task status: ${error.message}`);
+}
+var eventSequence = 0;
+function resetEventSequence() {
+  eventSequence = 0;
+}
+async function emitEvent(messageId, eventType, eventData) {
+  const sb = getSupabase();
+  eventSequence++;
+  const { error } = await sb.from("message_events").insert({
+    message_id: messageId,
+    event_type: eventType,
+    event_data: eventData,
+    sequence_number: eventSequence
+  });
+  if (error) log.warn(`Failed to emit event: ${error.message}`);
+}
+async function emitEvents(messageId, events) {
+  const sb = getSupabase();
+  const rows = events.map((e) => {
+    eventSequence++;
+    return {
+      message_id: messageId,
+      event_type: e.type,
+      event_data: e.data,
+      sequence_number: eventSequence
+    };
+  });
+  const { error } = await sb.from("message_events").insert(rows);
+  if (error) log.warn(`Failed to emit events batch: ${error.message}`);
+}
+
+export {
+  getConfig,
+  setConfig,
+  clearConfig,
+  getConfigPath,
+  setLogLevel,
+  setCorrelationId,
+  newCorrelationId,
+  log,
+  CLI_AGENT_ID,
+  DAYBOX_AGENT_ID,
+  getSupabase,
+  loginWithToken,
+  getSession,
+  getCurrentUserId,
+  logout,
+  createSession,
+  updateHeartbeat,
+  endSession,
+  setSessionBusy,
+  getOrCreateCliConversation,
+  createTask,
+  pollPendingTasks,
+  claimTask,
+  completeTask,
+  failTask,
+  resetEventSequence,
+  emitEvent,
+  emitEvents
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node