optimal-cli 1.0.1 → 1.1.0

package/lib/kanban-sync.ts

@@ -0,0 +1,258 @@
+/**
+ * 3-way sync: Obsidian markdown tasks ↔ Supabase kanban
+ * 
+ * Flow:
+ * - obsidian: /home/oracle/Documents/optimal/tasks/*.md (source of truth for humans)
+ * - supabase: tasks table (source of truth for agents)
+ * - optimal cli: syncs between both
+ */
+import { readdir, readFile, writeFile, mkdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import { getSupabase } from './supabase.js'
+import { getProjectBySlug, createTask, updateTask, getBoard, type Task } from './kanban.js'
+
+const OBSIDIAN_TASKS_DIR = '/home/oracle/Documents/optimal/tasks'
+
+// --- Obsidian task parsing ---
+
+interface ObsidianTask {
+  id: string        // from filename: task__some-id__abc123
+  taskId: string    // full task__ prefix
+  title: string
+  status: 'pending' | 'in-progress' | 'done'
+  owner: string
+  assignee: string
+  priority: number
+  project: string
+  tags: string[]
+  source: string
+  description: string
+  metadata: Record<string, unknown>
+  created_at: string
+  updated_at: string
+}
+
+function parseObsidianTask(filename: string, content: string): ObsidianTask | null {
+  // filename format: task__some-slug__abc123.md
+  const match = filename.match(/^task__(.+?)__([a-z0-9]+)\.md$/)
+  if (!match) return null
+
+  const [, slug, shortId] = match
+  const taskId = `task__${slug}__${shortId}`
+
+  // Parse frontmatter
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/)
+  if (!fmMatch) return null
+
+  const frontmatter: Record<string, string> = {}
+  const lines = fmMatch[1].split('\n')
+  for (const line of lines) {
+    const [key, ...valueParts] = line.split(':')
+    if (key && valueParts.length) {
+      frontmatter[key.trim()] = valueParts.join(':').trim()
+    }
+  }
+
+  // Extract title from first heading after frontmatter
+  const bodyMatch = content.match(/^---\n[\s\S]*?\n---\n#?\s*(.+)/)
+  const title = bodyMatch ? bodyMatch[1].trim() : slug.replace(/-/g, ' ')
+
+  // Parse status
+  const statusMap: Record<string, ObsidianTask['status']> = {
+    'pending': 'pending',
+    'in-progress': 'in-progress',
+    'in_progress': 'in-progress',
+    'done': 'done',
+  }
+  const status = statusMap[frontmatter.status] || 'pending'
+
+  // Parse priority
+  const priorityMap: Record<string, number> = { 'high': 1, 'medium': 2, 'low': 3 }
+  const priority = priorityMap[frontmatter.priority] || 3
+
+  return {
+    id: shortId,
+    taskId,
+    title,
+    status,
+    owner: frontmatter.owner || 'unassigned',
+    assignee: frontmatter.assignee || frontmatter.owner || 'unassigned',
+    priority,
+    project: frontmatter.project || 'unknown',
+    tags: (frontmatter.tags || '[]').replace(/[\[\]]/g, '').split(',').map(t => t.trim()).filter(Boolean),
+    source: frontmatter.source || 'obsidian',
+    description: content.replace(/^---[\s\S]*?---\n/, '').trim(),
+    metadata: {},
+    created_at: frontmatter.created_at || new Date().toISOString(),
+    updated_at: frontmatter.updated_at || new Date().toISOString(),
+  }
+}
+
+async function readObsidianTasks(): Promise<ObsidianTask[]> {
+  const tasks: ObsidianTask[] = []
+  
+  try {
+    const files = await readdir(OBSIDIAN_TASKS_DIR)
+    for (const file of files) {
+      if (!file.startsWith('task__') || !file.endsWith('.md')) continue
+      try {
+        const content = await readFile(join(OBSIDIAN_TASKS_DIR, file), 'utf-8')
+        const task = parseObsidianTask(file, content)
+        if (task) tasks.push(task)
+      } catch (e) {
+        console.warn(`Failed to read ${file}:`, e)
+      }
+    }
+  } catch (e) {
+    console.error(`Failed to read obsidian tasks dir: ${e}`)
+  }
+  
+  return tasks
+}
+
+// --- Supabase helpers ---
+
+function mapStatusToSupabase(status: ObsidianTask['status']): Task['status'] {
+  const map: Record<ObsidianTask['status'], Task['status']> = {
+    'pending': 'backlog',
+    'in-progress': 'in_progress',
+    'done': 'done',
+  }
+  return map[status] || 'backlog'
+}
+
+function mapPriorityToSupabase(priority: number): number {
+  // obsidian: 1=high, 2=medium, 3=low -> supabase: 1=highest, 4=lowest
+  return Math.max(1, Math.min(4, priority))
+}
+
+// --- Sync operations ---
+
+export async function syncObsidianToSupabase(projectSlug: string, dryRun = false): Promise<void> {
+  const sb = getSupabase('optimal')
+  const obsidianTasks = await readObsidianTasks()
+  
+  console.log(`\n🔄 Syncing obsidian → supabase (project: ${projectSlug})`)
+  console.log(`Found ${obsidianTasks.length} obsidian tasks\n`)
+
+  // Get or create project
+  let projectId: string
+  try {
+    const { data: project } = await sb.from('projects').select('id').eq('slug', projectSlug).single()
+    if (!project) throw new Error('Project not found')
+    projectId = project.id
+  } catch {
+    console.log(`Creating project: ${projectSlug}`)
+    if (!dryRun) {
+      const { data: newProject } = await sb.from('projects').insert({
+        slug: projectSlug,
+        name: projectSlug.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
+        status: 'active',
+        priority: 3,
+      }).select('id').single()
+      projectId = newProject!.id
+    } else {
+      projectId = 'DRY-RUN-PROJECT-ID'
+    }
+  }
+
+  // Get existing supabase tasks
+  const { data: existingTasks } = await sb.from('tasks').select('id, title, status, description').eq('project_id', projectId)
+  const existingByTitle = new Map((existingTasks || []).map(t => [t.title, t]))
+
+  let created = 0
+  let updated = 0
+  let skipped = 0
+
+  for (const ot of obsidianTasks) {
+    const existing = existingByTitle.get(ot.title)
+    
+    if (existing) {
+      // Update existing task
+      if (!dryRun) {
+        await sb.from('tasks').update({
+          status: mapStatusToSupabase(ot.status),
+          priority: mapPriorityToSupabase(ot.priority),
+          assigned_to: ot.assignee !== 'unassigned' ? ot.assignee : null,
+          updated_at: new Date().toISOString(),
+          description: ot.description || null,
+        }).eq('id', existing.id)
+      }
+      updated++
+      console.log(`  ✓ Updated: ${ot.title}`)
+    } else {
+      // Create new task
+      if (!dryRun) {
+        await sb.from('tasks').insert({
+          project_id: projectId,
+          title: ot.title,
+          description: ot.description || null,
+          status: mapStatusToSupabase(ot.status),
+          priority: mapPriorityToSupabase(ot.priority),
+          assigned_to: ot.assignee !== 'unassigned' ? ot.assignee : null,
+          blocked_by: [],
+          sort_order: 0,
+        })
+      }
+      created++
+      console.log(`  + Created: ${ot.title}`)
+    }
+  }
+
+  console.log(`\n📊 Sync complete:`)
+  console.log(`  Created: ${created}`)
+  console.log(`  Updated: ${updated}`)
+  console.log(`  Skipped: ${skipped}`)
+  
+  if (dryRun) console.log(`\n⚠️  Dry run — no changes written`)
+}
+
+export async function syncSupabaseToObsidian(projectSlug: string, dryRun = false): Promise<void> {
+  console.log(`\n🔄 Syncing supabase → obsidian (project: ${projectSlug})`)
+  console.log(`Not yet implemented — need to reverse the flow\n`)
+}
+
+export async function getSyncStatus(projectSlug: string): Promise<void> {
+  const obsidianTasks = await readObsidianTasks()
+  const sb = getSupabase('optimal')
+
+  // Get project
+  const { data: project } = await sb.from('projects').select('id').eq('slug', projectSlug).single()
+  if (!project) {
+    console.log(`Project "${projectSlug}" not found in supabase`)
+    return
+  }
+
+  // Get supabase tasks
+  const { data: sbTasks } = await sb.from('tasks').select('title, status').eq('project_id', project.id)
+  
+  const sbTitles = new Set((sbTasks || []).map(t => t.title))
+  const obTitles = new Set(obsidianTasks.map(t => t.title))
+
+  const onlyInObsidian = obsidianTasks.filter(t => !sbTitles.has(t.title))
+  const onlyInSupabase = (sbTasks || []).filter(t => !obTitles.has(t.title))
+  const inBoth = obsidianTasks.filter(t => sbTitles.has(t.title))
+
+  console.log(`\n📊 Sync Status for "${projectSlug}":\n`)
+  console.log(`  Obsidian tasks: ${obsidianTasks.length}`)
+  console.log(`  Supabase tasks: ${sbTasks?.length || 0}`)
+  console.log(`  In both: ${inBoth.length}`)
+  console.log(`  Only in obsidian: ${onlyInObsidian.length}`)
+  console.log(`  Only in supabase: ${onlyInSupabase.length}`)
+  
+  if (onlyInObsidian.length > 0) {
+    console.log(`\n📝 Only in obsidian (run 'optimal sync push' to sync):`)
+    for (const t of onlyInObsidian.slice(0, 5)) {
+      console.log(`  - ${t.title}`)
+    }
+    if (onlyInObsidian.length > 5) console.log(`  ... and ${onlyInObsidian.length - 5} more`)
+  }
+  
+  if (onlyInSupabase.length > 0) {
+    console.log(`\n🗄️  Only in supabase (run 'optimal sync pull' to sync):`)
+    for (const t of onlyInSupabase.slice(0, 5)) {
+      console.log(`  - ${t.title}`)
+    }
+    if (onlyInSupabase.length > 5) console.log(`  ... and ${onlyInSupabase.length - 5} more`)
+  }
+}

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}`)
+  }
+}