optimal-cli 1.0.0 → 1.1.0

package/lib/kanban.ts

@@ -0,0 +1,239 @@
+/**
+ * Supabase-backed Kanban operations
+ * Uses existing projects and tasks tables in supabase
+ */
+import { getSupabase } from './supabase.js'
+
+const sb = () => getSupabase('optimal')
+
+// --- Types ---
+
+export interface Task {
+  id: string
+  project_id: string
+  milestone_id: string | null
+  title: string
+  description: string | null
+  status: 'backlog' | 'ready' | 'in_progress' | 'blocked' | 'review' | 'done' | 'cancelled'
+  priority: number
+  assigned_to: string | null
+  claimed_by: string | null
+  claimed_at: string | null
+  skill_required: string | null
+  source_repo: string | null
+  target_module: string | null
+  estimated_effort: string | null
+  blocked_by: string[]
+  sort_order: number
+  created_at: string
+  updated_at: string
+  completed_at: string | null
+}
+
+export interface Project {
+  id: string
+  slug: string
+  name: string
+  description: string | null
+  status: 'active' | 'archived' | 'on_hold'
+  priority: number
+  owner: string | null
+  created_at: string
+  updated_at: string
+}
+
+export interface CreateTaskInput {
+  project_slug: string
+  title: string
+  description?: string
+  priority?: number
+  skill_required?: string
+  source_repo?: string
+}
+
+// --- Projects ---
+
+export async function getProjectBySlug(slug: string): Promise<Project> {
+  const { data, error } = await sb()
+    .from('projects')
+    .select('*')
+    .eq('slug', slug)
+    .single()
+  
+  if (error) throw new Error(`Project not found: ${slug} — ${error.message}`)
+  return data as Project
+}
+
+export async function listProjects(): Promise<Project[]> {
+  const { data, error } = await sb()
+    .from('projects')
+    .select('*')
+    .eq('status', 'active')
+    .order('name')
+  
+  if (error) throw new Error(`Failed to list projects: ${error.message}`)
+  return (data ?? []) as Project[]
+}
+
+// --- Tasks ---
+
+export async function createTask(input: CreateTaskInput): Promise<Task> {
+  const project = await getProjectBySlug(input.project_slug)
+  
+  const { data, error } = await sb()
+    .from('tasks')
+    .insert({
+      project_id: project.id,
+      title: input.title,
+      description: input.description ?? null,
+      priority: input.priority ?? 3,
+      skill_required: input.skill_required ?? null,
+      source_repo: input.source_repo ?? null,
+      status: 'backlog',
+      blocked_by: [],
+      sort_order: 0,
+    })
+    .select()
+    .single()
+  
+  if (error) throw new Error(`Failed to create task: ${error.message}`)
+  return data as Task
+}
+
+export async function updateTask(
+  taskId: string,
+  updates: Partial<Pick<Task, 'status' | 'assigned_to' | 'claimed_by' | 'claimed_at' | 'priority' | 'title' | 'description'>>
+): Promise<Task> {
+  const updateData: Record<string, unknown> = { ...updates, updated_at: new Date().toISOString() }
+  
+  // Handle completed_at
+  if (updates.status === 'done') {
+    updateData.completed_at = new Date().toISOString()
+  }
+  
+  const { data, error } = await sb()
+    .from('tasks')
+    .update(updateData)
+    .eq('id', taskId)
+    .select()
+    .single()
+  
+  if (error) throw new Error(`Failed to update task ${taskId}: ${error.message}`)
+  return data as Task
+}
+
+export async function getTask(taskId: string): Promise<Task> {
+  const { data, error } = await sb()
+    .from('tasks')
+    .select('*')
+    .eq('id', taskId)
+    .single()
+  
+  if (error) throw new Error(`Task not found: ${taskId} — ${error.message}`)
+  return data as Task
+}
+
+export async function claimTask(taskId: string, agentName: string): Promise<Task> {
+  const { data, error } = await sb()
+    .from('tasks')
+    .update({
+      claimed_by: agentName,
+      claimed_at: new Date().toISOString(),
+      status: 'in_progress',
+      updated_at: new Date().toISOString(),
+    })
+    .eq('id', taskId)
+    .select()
+    .single()
+  
+  if (error) throw new Error(`Failed to claim task ${taskId}: ${error.message}`)
+  return data as Task
+}
+
+export async function getNextTask(projectSlug: string, agentName: string): Promise<Task | null> {
+  const project = await getProjectBySlug(projectSlug)
+  
+  const { data, error } = await sb()
+    .from('tasks')
+    .select('*')
+    .eq('project_id', project.id)
+    .in('status', ['backlog', 'ready'])
+    .is('claimed_by', null)
+    .order('priority', { ascending: true })
+    .order('created_at', { ascending: true })
+    .limit(10)
+
+  if (error) throw new Error(`Failed to fetch tasks: ${error.message}`)
+  if (!data || data.length === 0) return null
+
+  for (const task of data as Task[]) {
+    if (!task.blocked_by || task.blocked_by.length === 0) return task
+    const { data: blockers } = await sb()
+      .from('tasks')
+      .select('id, status')
+      .in('id', task.blocked_by)
+    const allDone = blockers?.every(b => b.status === 'done' || b.status === 'cancelled')
+    if (allDone) return task
+  }
+  return null
+}
+
+export async function getBoard(projectSlug: string): Promise<Task[]> {
+  const project = await getProjectBySlug(projectSlug)
+  
+  const { data, error } = await sb()
+    .from('tasks')
+    .select('*')
+    .eq('project_id', project.id)
+    .not('status', 'eq', 'cancelled')
+    .order('sort_order')
+    .order('priority', { ascending: true })
+    .order('created_at', { ascending: true })
+
+  if (error) throw new Error(`Failed to fetch board: ${error.message}`)
+  return (data ?? []) as Task[]
+}
+
+export async function getBoardByStatus(projectSlug: string): Promise<Record<string, Task[]>> {
+  const tasks = await getBoard(projectSlug)
+  
+  const byStatus: Record<string, Task[]> = {
+    backlog: [],
+    ready: [],
+    in_progress: [],
+    blocked: [],
+    review: [],
+    done: [],
+  }
+  
+  for (const task of tasks) {
+    const status = task.status as string
+    if (byStatus[status]) {
+      byStatus[status].push(task)
+    } else {
+      byStatus.backlog.push(task)
+    }
+  }
+  
+  return byStatus
+}
+
+// --- Activity/Logs (if activity_log table exists) ---
+
+export async function logActivity(
+  taskId: string,
+  entry: { agent: string; action: string; details?: string }
+) {
+  const { error } = await sb()
+    .from('activity_log')
+    .insert({
+      task_id: taskId,
+      agent: entry.agent,
+      action: entry.action,
+      details: entry.details ?? null,
+    })
+  
+  if (error) {
+    console.warn(`Failed to log activity: ${error.message}`)
+  }
+}

package/lib/obsidian-tasks.ts

@@ -0,0 +1,231 @@
+/**
+ * Obsidian Tasks Interface
+ * 
+ * Reads/writes markdown task files in /home/oracle/Documents/optimal/tasks/
+ * Each task is a separate .md file with YAML frontmatter.
+ */
+import { readFile, writeFile, readdir, mkdir } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { join, basename } from 'node:path'
+import { parse, stringify } from 'yaml'
+
+const TASKS_DIR = process.env.OPTIMAL_TASKS_DIR || '/home/oracle/Documents/optimal/tasks'
+
+export interface TaskFrontmatter {
+  id: string
+  type: 'task'
+  status: 'pending' | 'in-progress' | 'done' | 'blocked'
+  owner?: string
+  assignee?: string
+  project?: string
+  priority?: '1' | '2' | '3' | '4'
+  source?: string
+  created_at?: string
+  updated_at?: string
+  updated_by?: string
+  tags?: string[]
+  // Custom fields
+  title?: string
+  description?: string
+}
+
+export interface Task {
+  id: string
+  frontmatter: TaskFrontmatter
+  body: string
+  filePath: string
+}
+
+function ensureTasksDir(): void {
+  if (!existsSync(TASKS_DIR)) {
+    throw new Error(`Tasks directory not found: ${TASKS_DIR}`)
+  }
+}
+
+export async function listTasks(filters?: {
+  project?: string
+  status?: string
+  owner?: string
+  assignee?: string
+}): Promise<Task[]> {
+  ensureTasksDir()
+  
+  const files = await readdir(TASKS_DIR)
+  const tasks: Task[] = []
+  
+  for (const file of files) {
+    if (!file.endsWith('.md') || file === 'index__tasks__task_hub.md') continue
+    
+    const filePath = join(TASKS_DIR, file)
+    const content = await readFile(filePath, 'utf-8')
+    
+    const task = parseTaskFile(content, filePath)
+    if (!task) continue
+    
+    // Apply filters
+    if (filters?.project && task.frontmatter.project !== filters.project) continue
+    if (filters?.status && task.frontmatter.status !== filters.status) continue
+    if (filters?.owner && task.frontmatter.owner !== filters.owner) continue
+    if (filters?.assignee && task.frontmatter.assignee !== filters.assignee) continue
+    
+    tasks.push(task)
+  }
+  
+  return tasks.sort((a, b) => {
+    // Sort by priority (1 = highest), then by updated_at
+    const priA = parseInt(a.frontmatter.priority || '3')
+    const priB = parseInt(b.frontmatter.priority || '3')
+    if (priA !== priB) return priA - priB
+    return (b.frontmatter.updated_at || '').localeCompare(a.frontmatter.updated_at || '')
+  })
+}
+
+export function parseTaskFile(content: string, filePath: string): Task | null {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+  if (!match) return null
+  
+  try {
+    const frontmatter = parse(match[1]) as TaskFrontmatter
+    const body = match[2] || ''
+    
+    return {
+      id: frontmatter.id || basename(filePath, '.md'),
+      frontmatter,
+      body,
+      filePath
+    }
+  } catch {
+    return null
+  }
+}
+
+export async function getTaskById(id: string): Promise<Task | null> {
+  ensureTasksDir()
+  
+  // Try to find by ID in filename
+  const files = await readdir(TASKS_DIR)
+  const matchingFile = files.find(f => f.includes(id))
+  
+  if (!matchingFile) return null
+  
+  const filePath = join(TASKS_DIR, matchingFile)
+  const content = await readFile(filePath, 'utf-8')
+  
+  return parseTaskFile(content, filePath)
+}
+
+export async function createTask(opts: {
+  title: string
+  project?: string
+  description?: string
+  priority?: string
+  owner?: string
+  assignee?: string
+  source?: string
+  tags?: string[]
+}): Promise<Task> {
+  ensureTasksDir()
+  
+  const id = `task__${opts.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 40)}_${Date.now().toString(36).slice(-6)}`
+  const now = new Date().toISOString()
+  
+  const frontmatter: TaskFrontmatter = {
+    id,
+    type: 'task',
+    status: 'pending',
+    project: opts.project || 'default',
+    priority: (opts.priority as TaskFrontmatter['priority']) || '3',
+    owner: opts.owner,
+    assignee: opts.assignee,
+    source: opts.source,
+    created_at: now,
+    updated_at: now,
+    tags: opts.tags
+  }
+  
+  const content = `---
+${stringify(frontmatter).trim()}
+---
+
+${opts.description || ''}
+`
+  
+  const filePath = join(TASKS_DIR, `${id}.md`)
+  await writeFile(filePath, content, 'utf-8')
+  
+  return {
+    id,
+    frontmatter,
+    body: opts.description || '',
+    filePath
+  }
+}
+
+export async function updateTask(id: string, updates: Partial<{
+  status: TaskFrontmatter['status']
+  owner: string
+  assignee: string
+  priority: string
+  message: string
+}>): Promise<Task | null> {
+  const task = await getTaskById(id)
+  if (!task) return null
+  
+  const now = new Date().toISOString()
+  
+  // Update frontmatter
+  if (updates.status) task.frontmatter.status = updates.status
+  if (updates.owner) task.frontmatter.owner = updates.owner
+  if (updates.assignee) task.frontmatter.assignee = updates.assignee
+  if (updates.priority) task.frontmatter.priority = updates.priority as TaskFrontmatter['priority']
+  task.frontmatter.updated_at = now
+  
+  // Append message to body if provided
+  if (updates.message) {
+    const timestamp = new Date().toISOString()
+    task.body += `\n\n---\n*${timestamp}:* ${updates.message}`
+  }
+  
+  const content = `---
+${stringify(task.frontmatter).trim()}
+---
+
+${task.body}
+`
+  
+  await writeFile(task.filePath, content, 'utf-8')
+  
+  return task
+}
+
+export async function deleteTask(id: string): Promise<boolean> {
+  const task = await getTaskById(id)
+  if (!task) return false
+  
+  const { rm } = await import('node:fs/promises')
+  await rm(task.filePath)
+  
+  return true
+}
+
+export function getTasksDir(): string {
+  return TASKS_DIR
+}
+
+// Group tasks by status for board view
+export function groupTasksByStatus(tasks: Task[]): Record<string, Task[]> {
+  const groups: Record<string, Task[]> = {
+    pending: [],
+    'in-progress': [],
+    blocked: [],
+    done: []
+  }
+  
+  for (const task of tasks) {
+    const status = task.frontmatter.status || 'pending'
+    if (!groups[status]) groups[status] = []
+    groups[status].push(task)
+  }
+  
+  return groups
+}

package/package.json

@@ -1,24 +1,7 @@
 {
   "name": "optimal-cli",
-  "version": "1.0.0",
-  "description": "Optimal CLI — unified command-line interface for bot orchestration, financial analytics, content management, and infrastructure",
+  "version": "1.1.0",
   "type": "module",
-  "bin": {
-    "optimal": "./bin/optimal.ts"
-  },
-  "files": [
-    "bin/",
-    "lib/",
-    "agents/",
-    "docs/CLI-REFERENCE.md"
-  ],
-  "keywords": ["cli", "supabase", "kanban", "bot-orchestration", "financial-analytics"],
-  "author": "Carlos Lenis <clenis@users.noreply.github.com>",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/clenisa/optimal-cli.git"
-  },
   "scripts": {
     "build": "tsc",
     "dev": "tsx watch bin/optimal.ts",
@@ -32,9 +15,12 @@
   },
   "dependencies": {
     "@supabase/supabase-js": "^2.49.0",
+    "@types/glob": "^9.0.0",
     "commander": "^13.0.0",
     "dotenv": "^16.4.0",
     "exceljs": "^4.4.0",
-    "playwright": "^1.58.2"
+    "glob": "^13.0.6",
+    "playwright": "^1.58.2",
+    "yaml": "^2.8.2"
   }
 }

package/pnpm-workspace.yaml

@@ -0,0 +1,3 @@
+packages:
+  - 'apps/*'
+  - 'lib'

package/scripts/check-table.ts

@@ -0,0 +1,24 @@
+import { createClient } from '@supabase/supabase-js'
+
+const url = 'https://hbfalrpswysryltysonm.supabase.co'
+const key = process.env.OPTIMAL_SUPABASE_SERVICE_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImhiZmFscnBzd3lzcnlsdHlzb25tIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTczODI0NTY0NywiZXhwIjoyMDUzODIxNjQ3fQ.placeholder'
+
+const supabase = createClient(url, key)
+
+async function checkTable() {
+  // Try to query the table
+  const { data, error } = await supabase
+    .from('agent_configs')
+    .select('*')
+    .limit(1)
+
+  if (error) {
+    console.log('Table status:', error.code === '42P01' ? 'DOES NOT EXIST' : 'ERROR')
+    console.log('Error:', error.message)
+  } else {
+    console.log('Table status: EXISTS')
+    console.log('Rows:', data.length)
+  }
+}
+
+checkTable()

package/scripts/create-tables.ts

@@ -0,0 +1,94 @@
+/**
+ * Run kanban migration - creates tables in supabase
+ */
+import { createClient } from '@supabase/supabase-js'
+
+const SUPABASE_URL = 'https://vvutttwunexshxkmygik.supabase.co'
+const SUPABASE_SERVICE_KEY = 'sb_secret_zokm_eFGX9ENuRV8hKA05Q_JQDOEOOl'
+
+const supabase = createClient(SUPABASE_URL, SUPABASE_SERVICE_KEY, {
+  db: { schema: 'public' }
+})
+
+const sql = `
+-- Projects table
+CREATE TABLE IF NOT EXISTS cli_projects (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  slug TEXT UNIQUE NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT,
+  status TEXT DEFAULT 'active' CHECK (status IN ('active', 'archived', 'on_hold')),
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Tasks table
+CREATE TABLE IF NOT EXISTS cli_tasks (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  project_id UUID REFERENCES cli_projects(id) ON DELETE CASCADE,
+  task_id TEXT NOT NULL,
+  title TEXT NOT NULL,
+  description TEXT,
+  status TEXT DEFAULT 'pending' CHECK (status IN ('pending', 'in_progress', 'done', 'cancelled')),
+  priority INTEGER DEFAULT 3 CHECK (priority BETWEEN 1 AND 4),
+  owner TEXT,
+  assignee TEXT,
+  tags JSONB DEFAULT '[]',
+  source TEXT,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW(),
+  completed_at TIMESTAMPTZ,
+  completed_by TEXT,
+  metadata JSONB DEFAULT '{}',
+  UNIQUE(project_id, task_id)
+);
+
+-- Sync log
+CREATE TABLE IF NOT EXISTS cli_sync_log (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  entity_type TEXT NOT NULL,
+  entity_id UUID NOT NULL,
+  action TEXT NOT NULL,
+  source TEXT NOT NULL,
+  synced_at TIMESTAMPTZ DEFAULT NOW(),
+  payload JSONB
+);
+
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_tasks_project ON cli_tasks(project_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON cli_tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_owner ON cli_tasks(owner);
+CREATE INDEX IF NOT EXISTS idx_tasks_assignee ON cli_tasks(assignee);
+`
+
+async function main() {
+  console.log('Running migration...')
+  
+  // Run raw SQL via postgrest
+  const { data, error } = await supabase.rpc('pg_catalog.exec', { 
+    query: sql 
+  }).catch(() => {
+    // Fallback: try via REST directly
+    return supabase.from('_temp').select('*').limit(0)
+  })
+
+  // Actually, rpc won't work - let's just create tables one by one via insert
+  // Since we can't run raw SQL easily, let's try a different approach
+  console.log('Trying alternative...')
+  
+  // Check if tables exist
+  const { data: tables } = await supabase
+    .from('information_schema.tables')
+    .select('table_name')
+    .eq('table_schema', 'public')
+    .in('table_name', ['cli_projects', 'cli_tasks'])
+  
+  console.log('Existing tables:', tables)
+  
+  if (!tables?.length) {
+    console.log('Tables do not exist. Trying to create via console...')
+    console.log('Please run manually or use supabase studio.')
+  }
+}
+
+main().catch(console.error)

package/scripts/migrate-kanban.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+# Migrate kanban tables to supabase
+
+SQL_FILE="supabase/migrations/20260306195000_create_kanban_tables.sql"
+
+# Load env from workspace secrets
+if [ -f ".secrets/dashboard-returnpro.vercel.env" ]; then
+  export "$(cat .secrets/dashboard-returnpro.vercel.env | grep -v '^#' | xargs)"
+fi
+
+# Check for supabase URL and key
+if [ -z "$SUPABASE_URL" ] || [ -z "$SUPABASE_SERVICE_ROLE_KEY" ]; then
+  echo "Error: SUPABASE_URL or SUPABASE_SERVICE_ROLE_KEY not found"
+  exit 1
+fi
+
+echo "Applying migration..."
+echo "SUPABASE_URL: $SUPABASE_URL"
+
+# Use psql if available, otherwise try with supabase cli
+if command -v psql &> /dev/null; then
+  # Extract password from the key (it's after the = sign)
+  DB_PASS="${SUPABASE_SERVICE_ROLE_KEY##*=}"
+  psql "host=vvutttwunexshxkmygik.supabase.co port=5432 dbname=postgres user=postgres password=$DB_PASS" -f "$SQL_FILE" 2>&1
+else
+  echo "psql not available, trying supabase cli..."
+  npx supabase db push 2>&1
+fi