optimal-cli 1.0.0 → 1.1.0

package/docs/MIGRATION_NEEDED.md

@@ -0,0 +1,37 @@
+# Supabase Migration Required
+
+The `cli_config_registry` table needs to be created in your Supabase database for the config sync feature to work.
+
+## Manual Steps
+
+1. Go to your Supabase project: https://app.supabase.com/project/_/sql
+2. Run this SQL:
+
+```sql
+create table if not exists public.cli_config_registry (
+  id uuid primary key default gen_random_uuid(),
+  owner text not null,
+  profile text not null default 'default',
+  config_version text not null,
+  payload jsonb not null,
+  payload_hash text not null,
+  source text not null default 'optimal-cli',
+  updated_by text,
+  updated_at timestamptz not null default now(),
+  created_at timestamptz not null default now(),
+  unique (owner, profile)
+);
+
+create index if not exists idx_cli_config_registry_owner_profile
+  on public.cli_config_registry (owner, profile);
+
+create index if not exists idx_cli_config_registry_updated_at
+  on public.cli_config_registry (updated_at desc);
+```
+
+3. After running the migration, the `optimal config sync push/pull` commands will work.
+
+## File Location
+
+The migration file is also available at:
+`optimal-cli/supabase/migrations/20260305111300_create_cli_config_registry.sql`

package/docs/plans/optimal-cli-config-registry-v1.md

@@ -0,0 +1,71 @@
+# optimal-cli shared config registry v1 (draft)
+
+## objective
+define a repeatable config-sharing model for `optimal-cli` with versioned schema, supabase-backed sync, and clear command surface.
+
+## v1 scope
+- single-user + team-ready config profile storage
+- deterministic import/export format
+- pull/push sync with conflict visibility
+- schema migration path (`version` field)
+
+## config schema (v1)
+```json
+{
+  "version": "1.0.0",
+  "profile": {
+    "name": "default",
+    "owner": "clenisa",
+    "updated_at": "2026-03-05T04:40:00-05:00"
+  },
+  "providers": {
+    "supabase": {
+      "project_ref": "<ref>",
+      "url": "<url>",
+      "anon_key_present": true
+    },
+    "strapi": {
+      "base_url": "https://strapi.op-hub.com",
+      "token_present": true
+    }
+  },
+  "defaults": {
+    "brand": "CRE-11TRUST",
+    "timezone": "America/New_York"
+  },
+  "features": {
+    "cms": true,
+    "tasks": true,
+    "deploy": false
+  }
+}
+```
+
+## supabase model (proposed)
+`cli_config_registry`
+- `id uuid pk`
+- `owner text not null`
+- `profile_name text not null`
+- `schema_version text not null`
+- `config_json jsonb not null`
+- `config_hash text not null`
+- `updated_at timestamptz not null default now()`
+- unique `(owner, profile_name)`
+
+## command surface (v1)
+- `optimal config init [--profile default]`
+- `optimal config export --out ./optimal.config.json`
+- `optimal config import --file ./optimal.config.json [--merge|--replace]`
+- `optimal config sync pull [--profile default]`
+- `optimal config sync push [--profile default] [--force]`
+- `optimal config doctor`
+
+## conflict model
+- compare local `config_hash` vs remote `config_hash`
+- if diverged and no `--force`, abort with resolution hints
+- write pull/merge decisions to local audit log (`~/.optimal/config-history.log`)
+
+## next implementation step
+1. add `lib/config/schema.ts` + zod validator
+2. add `bin/optimal.ts` `config` command group with `doctor` + `export`
+3. scaffold supabase read/write adapter in `lib/config/registry.ts`

package/lib/config/registry.ts

@@ -6,9 +6,10 @@ import { createHash } from 'node:crypto'
 import { getSupabase } from '../supabase.js'
 import { assertOptimalConfigV1, type OptimalConfigV1 } from './schema.js'
 
-const DIR = join(homedir(), '.optimal')
-const LOCAL_CONFIG_PATH = join(DIR, 'optimal.config.json')
-const HISTORY_PATH = join(DIR, 'config-history.log')
+// Support optional config directory override via env var (useful for testing)
+const CONFIG_DIR = process.env.OPTIMAL_CONFIG_DIR || join(homedir(), '.optimal')
+const LOCAL_CONFIG_PATH = join(CONFIG_DIR, 'optimal.config.json')
+const HISTORY_PATH = join(CONFIG_DIR, 'config-history.log')
 const REGISTRY_TABLE = 'cli_config_registry'
 
 let supabaseProvider: typeof getSupabase = getSupabase
@@ -33,7 +34,7 @@ export function resetRegistrySupabaseProviderForTests(): void {
 }
 
 export async function ensureConfigDir(): Promise<void> {
-  await mkdir(DIR, { recursive: true })
+  await mkdir(CONFIG_DIR, { recursive: true })
 }
 
 export function getLocalConfigPath(): string {

package/lib/kanban-obsidian.ts

@@ -0,0 +1,232 @@
+/**
+ * Obsidian-backed Kanban board operations
+ * Works directly with markdown task files in the tasks vault
+ */
+import { readFile, writeFile, readdir } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { join, basename } from 'node:path'
+import { glob } from 'glob'
+
+const TASKS_DIR = process.env.OPTIMAL_TASKS_DIR || '/home/oracle/Documents/optimal/tasks'
+
+export interface ObsidianTask {
+  id: string
+  title: string
+  description: string
+  status: 'pending' | 'in-progress' | 'done'
+  priority: number
+  owner: string | null
+  assignee: string | null
+  project: string | null
+  tags: string[]
+  createdAt: string | null
+  updatedAt: string | null
+  source: string | null
+  filePath: string
+}
+
+export interface BoardColumn {
+  name: string
+  status: string
+  tasks: ObsidianTask[]
+}
+
+function parseFrontmatter(content: string): Record<string, string> {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/)
+  if (!fmMatch) return {}
+  
+  const fm: Record<string, string> = {}
+  const lines = fmMatch[1].split('\n')
+  for (const line of lines) {
+    const colonIdx = line.indexOf(':')
+    if (colonIdx === -1) continue
+    const key = line.slice(0, colonIdx).trim()
+    const value = line.slice(colonIdx + 1).trim()
+    fm[key] = value
+  }
+  return fm
+}
+
+function getTaskIdFromFilename(filename: string): string {
+  // filename format: task__description__hash.md
+  return filename.replace(/^task__/, '').replace(/\.md$/, '')
+}
+
+export async function listTaskFiles(): Promise<string[]> {
+  const files = await readdir(TASKS_DIR)
+  return files
+    .filter(f => f.startsWith('task__') && f.endsWith('.md'))
+    .map(f => join(TASKS_DIR, f))
+}
+
+export async function loadTaskFromFile(filePath: string): Promise<ObsidianTask | null> {
+  try {
+    const content = await readFile(filePath, 'utf-8')
+    const fm = parseFrontmatter(content)
+    
+    // Extract body as description (first paragraph after frontmatter)
+    const bodyMatch = content.match(/^---\n[\s\S]*?\n---\n\n?(.*)$/)
+    const description = bodyMatch ? bodyMatch[1].trim() : ''
+    
+    // Parse status from frontmatter
+    let status: 'pending' | 'in-progress' | 'done' = 'pending'
+    const statusStr = fm.status?.toLowerCase()
+    if (statusStr === 'in-progress' || statusStr === 'inprogress') status = 'in-progress'
+    else if (statusStr === 'done' || statusStr === 'completed') status = 'done'
+    
+    // Parse tags from frontmatter
+    const tagsStr = fm.tags || '[]'
+    let tags: string[] = []
+    try {
+      tags = JSON.parse(tagsStr)
+    } catch {
+      if (fm.tags) tags = fm.tags.split(',').map(t => t.trim())
+    }
+    
+    return {
+      id: fm.id || basename(filePath).replace(/\.md$/, ''),
+      title: fm.title || basename(filePath, '.md'),
+      description: description.slice(0, 200),
+      status,
+      priority: parseInt(fm.priority) || 3,
+      owner: fm.owner || null,
+      assignee: fm.assignee || null,
+      project: fm.project || null,
+      tags,
+      createdAt: fm.created_at || null,
+      updatedAt: fm.updated_at || null,
+      source: fm.source || null,
+      filePath,
+    }
+  } catch (err) {
+    console.error(`Failed to load task from ${filePath}:`, err)
+    return null
+  }
+}
+
+export async function loadAllTasks(): Promise<ObsidianTask[]> {
+  const files = await listTaskFiles()
+  const tasks: ObsidianTask[] = []
+  
+  for (const file of files) {
+    const task = await loadTaskFromFile(file)
+    if (task) tasks.push(task)
+  }
+  
+  return tasks
+}
+
+export async function getBoardByProject(projectSlug?: string): Promise<BoardColumn[]> {
+  const allTasks = await loadAllTasks()
+  
+  // Filter by project if specified
+  const filtered = projectSlug 
+    ? allTasks.filter(t => t.project === projectSlug)
+    : allTasks
+  
+  return [
+    { name: 'To Do', status: 'pending', tasks: filtered.filter(t => t.status === 'pending') },
+    { name: 'In Progress', status: 'in-progress', tasks: filtered.filter(t => t.status === 'in-progress') },
+    { name: 'Done', status: 'done', tasks: filtered.filter(t => t.status === 'done') },
+  ]
+}
+
+export async function findTaskById(taskId: string): Promise<ObsidianTask | null> {
+  const files = await listTaskFiles()
+  const targetFile = files.find(f => f.includes(taskId) || f.includes(taskId.replace(/-/g, '')))
+  
+  if (!targetFile) return null
+  return loadTaskFromFile(targetFile)
+}
+
+export interface UpdateTaskResult {
+  ok: boolean
+  message: string
+  task?: ObsidianTask
+}
+
+export async function updateTaskStatus(taskId: string, newStatus: string, message?: string): Promise<UpdateTaskResult> {
+  const task = await findTaskById(taskId)
+  if (!task) {
+    return { ok: false, message: `Task not found: ${taskId}` }
+  }
+  
+  // Map status
+  let status = 'pending'
+  if (newStatus === 'in-progress' || newStatus === 'inprogress') status = 'in-progress'
+  else if (newStatus === 'done' || newStatus === 'completed') status = 'done'
+  else if (newStatus === 'pending') status = 'pending'
+  else return { ok: false, message: `Invalid status: ${newStatus}` }
+  
+  try {
+    let content = await readFile(task.filePath, 'utf-8')
+    const now = new Date().toISOString()
+    
+    // Update frontmatter status
+    content = content.replace(/^status:.*$/m, `status: ${status}`)
+    content = content.replace(/^updated_at:.*$/m, `updated_at: ${now}`)
+    
+    // Add log entry if message provided
+    if (message) {
+      content = content.replace(
+        /^## progress log$/m,
+        `## progress log\n- ${now} ${message}`
+      )
+    }
+    
+    await writeFile(task.filePath, content, 'utf-8')
+    
+    return { 
+      ok: true, 
+      message: `Updated task ${taskId} status to ${status}`,
+      task: await loadTaskFromFile(task.filePath) || undefined
+    }
+  } catch (err) {
+    return { ok: false, message: `Failed to update: ${err}` }
+  }
+}
+
+export async function createTask(options: {
+  title: string
+  description?: string
+  project?: string
+  priority?: number
+  owner?: string
+  assignee?: string
+  tags?: string[]
+}): Promise<UpdateTaskResult> {
+  const id = `task__${options.title.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '')}_${Date.now().toString(36)}`
+  const now = new Date().toISOString()
+  
+  const frontmatter = `---
+id: ${id}
+type: task
+status: pending
+owner: ${options.owner || 'oracle'}
+assignee: ${options.assignee || ''}
+project: ${options.project || ''}
+priority: ${options.priority || 3}
+source: cli:board:create
+created_at: ${now}
+updated_at: ${now}
+tags: ${JSON.stringify(options.tags || [])}
+---
+
+# ${options.title}
+
+${options.description || ''}
+`.trim()
+  
+  const filePath = join(TASKS_DIR, `${id}.md`)
+  
+  try {
+    await writeFile(filePath, frontmatter, 'utf-8')
+    return { 
+      ok: true, 
+      message: `Created task: ${options.title}`,
+      task: await loadTaskFromFile(filePath) || undefined
+    }
+  } catch (err) {
+    return { ok: false, message: `Failed to create task: ${err}` }
+  }
+}

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