@web42/stask 0.1.5

package/lib/slack-sync.mjs

@@ -0,0 +1,388 @@
+/**
+ * slack-sync.mjs — Bidirectional Slack List ↔ SQLite sync.
+ *
+ * Uses timestamps to determine which side changed:
+ *   - Slack items have `updated_timestamp` (Unix epoch)
+ *   - DB tasks have `updated_at` (ISO 8601)
+ *   - `sync_state` table tracks last-known timestamps from both sides
+ *
+ * Conflict resolution: most recent timestamp wins.
+ * Slack→DB sync skips guards/cascading (human authority).
+ *
+ * ALL human-editable fields are synced:
+ *   Status, Assigned To, Type, Task Name, Completed checkbox
+ */
+
+import { CONFIG, getWorkspaceLibs } from './env.mjs';
+import { getNameBySlackUserId } from './roles.mjs';
+import { getSlackRowId } from './slack-row.mjs';
+
+const SLACK = CONFIG.slack;
+const COLS = SLACK.columns;
+
+// ─── Reverse lookup maps (built from config) ─────────────────────
+
+const OPTION_TO_STATUS = Object.fromEntries(
+  Object.entries(SLACK.statusOptions).map(([name, optId]) => [optId, name])
+);
+
+const OPTION_TO_TYPE = Object.fromEntries(
+  Object.entries(SLACK.typeOptions || {}).map(([name, optId]) => [optId, name])
+);
+
+const SLACK_USER_TO_NAME = {};
+SLACK_USER_TO_NAME[CONFIG.human.slackUserId] = CONFIG.human.name;
+for (const [name, agent] of Object.entries(CONFIG.agents)) {
+  SLACK_USER_TO_NAME[agent.slackUserId] = name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+// Column ID → parser key
+const COL_TO_FIELD = {};
+if (COLS.status)    COL_TO_FIELD[COLS.status]    = 'status';
+if (COLS.assignee)  COL_TO_FIELD[COLS.assignee]  = 'assigned_to';
+if (COLS.completed) COL_TO_FIELD[COLS.completed] = 'completed';
+if (COLS.type)      COL_TO_FIELD[COLS.type]      = 'type';
+if (COLS.name)      COL_TO_FIELD[COLS.name]      = 'task_name';
+
+// ─── Parse Slack item → task fields ───────────────────────────────
+
+/**
+ * Extract all human-editable fields from a Slack List item.
+ * Returns DB column names → values (e.g. { status, assigned_to, type, task_name }).
+ */
+export function parseSlackItem(item) {
+  const result = {};
+  if (!item?.fields) return result;
+
+  for (const field of item.fields) {
+    // Slack returns column_id in the field; match against our config
+    const colId = field.column_id;
+    const fieldName = COL_TO_FIELD[colId];
+    if (!fieldName) continue;
+
+    // ── Status (select) ──
+    if (fieldName === 'status') {
+      const optId = field.select ? field.select[0] : null;
+      if (optId) {
+        const status = OPTION_TO_STATUS[optId];
+        if (status) result.status = status;
+      }
+    }
+
+    // ── Assigned To (user) ──
+    if (fieldName === 'assigned_to') {
+      const userId = field.user ? field.user[0] : null;
+      if (userId) {
+        const name = getNameBySlackUserId(userId);
+        if (name) result.assigned_to = name;
+      }
+    }
+
+    // ── Type (select) ──
+    if (fieldName === 'type') {
+      const optId = field.select ? field.select[0] : null;
+      if (optId) {
+        const typeName = OPTION_TO_TYPE[optId];
+        if (typeName) result.type = typeName;
+      }
+    }
+
+    // ── Task Name (rich_text — use .text shortcut) ──
+    if (fieldName === 'task_name') {
+      const text = field.text || '';
+      if (text.trim()) result.task_name = text.trim();
+    }
+
+    // ── Completed (checkbox / boolean) ──
+    if (fieldName === 'completed') {
+      // Slack returns boolean directly or in value.checkbox
+      const checked = typeof field.value === 'boolean'
+        ? field.value
+        : field.value?.checkbox ?? false;
+      if (checked === true) result._completed = true;
+      if (checked === false) result._uncompleted = true;
+    }
+  }
+
+  // Checkbox overrides: completed=true forces Done, uncompleted=true forces un-Done
+  if (result._completed && result.status !== 'Done') {
+    result.status = 'Done';
+  }
+  delete result._completed;
+  delete result._uncompleted;
+
+  return result;
+}
+
+// ─── Match Slack items to DB tasks ────────────────────────────────
+
+function indexSlackItems(items) {
+  const map = new Map();
+  for (const item of items) {
+    if (item.id) map.set(item.id, item);
+  }
+  return map;
+}
+
+// ─── Core sync cycle ──────────────────────────────────────────────
+
+/**
+ * Run one full bidirectional sync cycle.
+ * Returns { pulled: [], pushed: [], skipped: number, errors: [] }.
+ */
+export async function runSyncCycle() {
+  const libs = await getWorkspaceLibs();
+  const db = libs.trackerDb.getDb();
+  const { getListItems } = libs.slackApi;
+
+  libs.trackerDb.ensureSyncStateTable();
+
+  const summary = { pulled: [], pushed: [], deleted: [], skipped: 0, errors: [] };
+
+  // 1. Fetch all Slack items
+  let slackItems;
+  try {
+    slackItems = await getListItems(SLACK.listId);
+  } catch (err) {
+    summary.errors.push(`Failed to fetch Slack items: ${err.message}`);
+    return summary;
+  }
+  const slackMap = indexSlackItems(slackItems);
+
+  // 2. Fetch all DB tasks
+  const allTasks = libs.trackerDb.getAllTasks();
+
+  // 3. For each task, compare timestamps and sync
+  for (const task of allTasks) {
+    const taskId = task['Task ID'];
+    const rowId = getSlackRowId(db, taskId);
+    if (!rowId) {
+      summary.skipped++;
+      continue;
+    }
+
+    const slackItem = slackMap.get(rowId);
+    if (!slackItem) {
+      // Row exists in mapping but gone from Slack → deleted on Slack side
+      try {
+        deleteLocalTask(db, libs, taskId);
+        summary.deleted.push(taskId);
+      } catch (err) {
+        summary.errors.push(`${taskId} delete: ${err.message}`);
+      }
+      continue;
+    }
+
+    try {
+      const syncResult = syncOneTask(db, libs, task, slackItem);
+      if (syncResult === 'pulled') {
+        summary.pulled.push(taskId);
+      } else if (syncResult === 'pushed') {
+        summary.pushed.push(taskId);
+      } else {
+        summary.skipped++;
+      }
+    } catch (err) {
+      summary.errors.push(`${taskId}: ${err.message}`);
+    }
+  }
+
+  return summary;
+}
+
+/**
+ * Sync a single task/item pair.
+ * Returns 'pulled' | 'pushed' | 'skipped'.
+ */
+function syncOneTask(db, libs, task, slackItem) {
+  const taskId = task['Task ID'];
+  const syncState = libs.trackerDb.getSyncState(taskId);
+
+  const slackTs = slackItem.updated_timestamp || 0;
+  const dbTs = task['updated_at'] || '';
+
+  const lastSlackTs = syncState?.last_slack_ts || 0;
+  const lastDbTs = syncState?.last_db_ts || '';
+
+  const slackChanged = slackTs > lastSlackTs;
+  const dbChanged = dbTs > lastDbTs;
+
+  if (!slackChanged && !dbChanged) {
+    // Safety: even if timestamps match, check for value drift
+    // (e.g. config was updated with new option IDs after a previous sync)
+    return checkValueDrift(db, libs, taskId, task, slackItem, slackTs);
+  }
+
+  if (slackChanged && !dbChanged) {
+    return pullFromSlack(db, libs, taskId, task, slackItem, slackTs);
+  }
+
+  if (!slackChanged && dbChanged) {
+    // DB was edited → record sync state (push handled by mutation commands)
+    libs.trackerDb.setSyncState(taskId, slackTs, dbTs);
+    return 'skipped';
+  }
+
+  // Both changed → most recent wins
+  const dbUnix = Math.floor(new Date(dbTs + 'Z').getTime() / 1000);
+  if (slackTs >= dbUnix) {
+    return pullFromSlack(db, libs, taskId, task, slackItem, slackTs);
+  } else {
+    libs.trackerDb.setSyncState(taskId, slackTs, dbTs);
+    return 'skipped';
+  }
+}
+
+/**
+ * Safety fallback: even when timestamps haven't changed, compare actual values.
+ * Catches cases where config was updated (new option IDs) after a previous sync.
+ */
+function checkValueDrift(db, libs, taskId, task, slackItem, slackTs) {
+  const parsed = parseSlackItem(slackItem);
+  const updates = {};
+  if (parsed.status && parsed.status !== task['Status']) updates.status = parsed.status;
+  if (parsed.assigned_to && parsed.assigned_to !== task['Assigned To']) updates.assigned_to = parsed.assigned_to;
+  if (parsed.type && parsed.type !== task['Type']) updates.type = parsed.type;
+  if (parsed.task_name && parsed.task_name !== task['Task Name']) updates.task_name = parsed.task_name;
+
+  if (Object.keys(updates).length === 0) return 'skipped';
+
+  // Found drift — apply Slack values (Slack is authoritative for drift)
+  libs.trackerDb.updateTaskDirect(taskId, updates);
+  const changes = Object.entries(updates).map(([k, v]) => `${k}: ${v}`).join(', ');
+  libs.trackerDb.addLogEntry(taskId, `[sync] Value drift corrected from Slack: ${changes}`);
+  const updatedTask = libs.trackerDb.findTask(taskId);
+  libs.trackerDb.setSyncState(taskId, slackTs, updatedTask?.['updated_at'] || '');
+  return 'pulled';
+}
+
+/**
+ * Pull changes from a Slack item into the DB task.
+ */
+function pullFromSlack(db, libs, taskId, task, slackItem, slackTs) {
+  const parsed = parseSlackItem(slackItem);
+  if (Object.keys(parsed).length === 0) {
+    const currentDbTs = task['updated_at'] || '';
+    libs.trackerDb.setSyncState(taskId, slackTs, currentDbTs);
+    return 'skipped';
+  }
+
+  // Diff: only update fields that actually changed
+  const updates = {};
+  if (parsed.status && parsed.status !== task['Status']) {
+    updates.status = parsed.status;
+  }
+  if (parsed.assigned_to && parsed.assigned_to !== task['Assigned To']) {
+    updates.assigned_to = parsed.assigned_to;
+  }
+  if (parsed.type && parsed.type !== task['Type']) {
+    updates.type = parsed.type;
+  }
+  if (parsed.task_name && parsed.task_name !== task['Task Name']) {
+    updates.task_name = parsed.task_name;
+  }
+
+  if (Object.keys(updates).length === 0) {
+    const currentDbTs = task['updated_at'] || '';
+    libs.trackerDb.setSyncState(taskId, slackTs, currentDbTs);
+    return 'skipped';
+  }
+
+  // Apply direct update (bypasses guards — human override)
+  libs.trackerDb.updateTaskDirect(taskId, updates);
+
+  // Log the change
+  const changes = Object.entries(updates).map(([k, v]) => `${k}: ${v}`).join(', ');
+  libs.trackerDb.addLogEntry(taskId, `[sync] Pulled from Slack: ${changes}`);
+
+  // Update sync state with new timestamps
+  const updatedTask = libs.trackerDb.findTask(taskId);
+  const newDbTs = updatedTask?.['updated_at'] || '';
+  libs.trackerDb.setSyncState(taskId, slackTs, newDbTs);
+
+  return 'pulled';
+}
+
+// ─── Delete local task (Slack row was deleted) ────────────────────
+
+/**
+ * Delete a task from the local DB after it was removed on Slack.
+ * Handles subtasks, log entries, session claims, and sync state.
+ * Mirrors the logic in commands/delete.mjs but without Slack API calls.
+ */
+function deleteLocalTask(db, libs, taskId) {
+  const task = libs.trackerDb.findTask(taskId);
+  if (!task) return; // Already gone
+
+  // Collect all IDs (parent + subtasks)
+  const subtasks = libs.trackerDb.getSubtasks(taskId);
+  const allIds = [taskId, ...subtasks.map(s => s['Task ID'])];
+
+  // Drop protective triggers temporarily
+  db.exec('DROP TRIGGER IF EXISTS validate_status_transition');
+  db.exec('DROP TRIGGER IF EXISTS log_no_delete');
+  db.exec('DROP TRIGGER IF EXISTS log_no_update');
+  db.exec('DROP TRIGGER IF EXISTS enforce_in_progress_requirements');
+  db.exec('DROP TRIGGER IF EXISTS enforce_ready_for_review_requirements');
+  db.exec('DROP TRIGGER IF EXISTS update_timestamp');
+
+  try {
+    db.exec('BEGIN');
+    for (const id of allIds) {
+      db.prepare('DELETE FROM slack_row_ids WHERE task_id = ?').run(id);
+      db.prepare('DELETE FROM sync_state WHERE task_id = ?').run(id);
+      db.prepare('DELETE FROM active_sessions WHERE task_id = ?').run(id);
+      db.prepare('DELETE FROM log WHERE task_id = ?').run(id);
+    }
+    // Delete subtasks first (FK constraint), then parent
+    for (const sub of subtasks) {
+      db.prepare('DELETE FROM tasks WHERE task_id = ?').run(sub['Task ID']);
+    }
+    db.prepare('DELETE FROM tasks WHERE task_id = ?').run(taskId);
+    db.exec('COMMIT');
+  } catch (err) {
+    db.exec('ROLLBACK');
+    throw err;
+  } finally {
+    // Restore triggers
+    db.exec(`
+      CREATE TRIGGER IF NOT EXISTS validate_status_transition
+      BEFORE UPDATE OF status ON tasks WHEN OLD.status != NEW.status
+      BEGIN SELECT CASE
+        WHEN OLD.status = 'Done' THEN RAISE(ABORT, 'Cannot transition from Done')
+        WHEN OLD.status = 'To-Do' AND NEW.status NOT IN ('In-Progress','Blocked') THEN RAISE(ABORT, 'Invalid transition from To-Do')
+        WHEN OLD.status = 'In-Progress' AND NEW.status NOT IN ('Testing','Blocked') THEN RAISE(ABORT, 'Invalid transition from In-Progress')
+        WHEN OLD.status = 'Testing' AND NEW.status NOT IN ('Ready for Human Review','In-Progress','Blocked') THEN RAISE(ABORT, 'Invalid transition from Testing')
+        WHEN OLD.status = 'Ready for Human Review' AND NEW.status NOT IN ('Done','In-Progress','Blocked') THEN RAISE(ABORT, 'Invalid transition from RHR')
+        WHEN OLD.status = 'Blocked' AND NEW.status NOT IN ('To-Do','In-Progress','Testing','Ready for Human Review') THEN RAISE(ABORT, 'Invalid transition from Blocked')
+      END; END;
+
+      CREATE TRIGGER IF NOT EXISTS log_no_update BEFORE UPDATE ON log
+      BEGIN SELECT RAISE(ABORT, 'Log entries are immutable'); END;
+
+      CREATE TRIGGER IF NOT EXISTS log_no_delete BEFORE DELETE ON log
+      BEGIN SELECT RAISE(ABORT, 'Log entries cannot be deleted'); END;
+
+      CREATE TRIGGER IF NOT EXISTS enforce_in_progress_requirements
+      BEFORE UPDATE OF status ON tasks
+      WHEN NEW.status = 'In-Progress' AND OLD.status = 'To-Do' AND NEW.parent_id IS NULL
+      BEGIN SELECT CASE
+        WHEN NEW.worktree IS NULL OR NEW.worktree = '' THEN
+          RAISE(ABORT, 'Worktree required for In-Progress')
+      END; END;
+
+      CREATE TRIGGER IF NOT EXISTS enforce_ready_for_review_requirements
+      BEFORE UPDATE OF status ON tasks
+      WHEN NEW.status = 'Ready for Human Review' AND NEW.parent_id IS NULL
+      BEGIN SELECT CASE
+        WHEN NEW.qa_fail_count = 0 AND (NEW.qa_report_1 IS NULL OR NEW.qa_report_1 = '') THEN RAISE(ABORT, 'QA Report required')
+        WHEN NEW.worktree IS NULL OR NEW.worktree = '' THEN RAISE(ABORT, 'Worktree required')
+        WHEN NEW.pr IS NULL OR NEW.pr = '' THEN RAISE(ABORT, 'PR required')
+      END; END;
+
+      CREATE TRIGGER IF NOT EXISTS update_timestamp
+      AFTER UPDATE ON tasks
+      BEGIN UPDATE tasks SET updated_at = datetime('now') WHERE task_id = NEW.task_id; END;
+    `);
+  }
+}

package/lib/sync-daemon.mjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+/**
+ * sync-daemon.mjs — Long-running bidirectional sync process.
+ *
+ * Runs `runSyncCycle()` at a configurable interval.
+ * Designed to be forked as a detached child process by `stask sync-daemon start`.
+ *
+ * Writes PID file for single-instance management.
+ * Logs to cli/stask/logs/sync-daemon.log.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import os from 'os';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const STASK_HOME = process.env.STASK_HOME || path.join(os.homedir(), '.stask');
+
+// Load env before anything else (from STASK_HOME)
+const envPath = path.join(STASK_HOME, '.env');
+try {
+  const lines = fs.readFileSync(envPath, 'utf-8').split('\n');
+  for (const line of lines) {
+    const match = line.match(/^([^#=]+)=(.*)$/);
+    if (match) {
+      const key = match[1].trim();
+      const val = match[2].trim();
+      if (!process.env[key]) process.env[key] = val;
+    }
+  }
+} catch (_) {}
+
+// Now import modules that need env
+import { loadEnv, CONFIG } from './env.mjs';
+loadEnv();
+
+import { runSyncCycle } from './slack-sync.mjs';
+
+const PID_FILE = path.join(STASK_HOME, 'sync-daemon.pid');
+const LOG_DIR = path.join(STASK_HOME, 'logs');
+const LOG_FILE = path.resolve(LOG_DIR, 'sync-daemon.log');
+const INTERVAL_MS = (CONFIG.syncIntervalSeconds || 60) * 1000;
+
+// ─── Logging ──────────────────────────────────────────────────────
+
+function ensureLogDir() {
+  if (!fs.existsSync(LOG_DIR)) fs.mkdirSync(LOG_DIR, { recursive: true });
+}
+
+function log(level, msg) {
+  const ts = new Date().toISOString();
+  const line = `[${ts}] [${level}] ${msg}\n`;
+  try { fs.appendFileSync(LOG_FILE, line); } catch (_) {}
+  if (level === 'ERROR') process.stderr.write(line);
+}
+
+// ─── PID management ───────────────────────────────────────────────
+
+function writePid() {
+  fs.writeFileSync(PID_FILE, String(process.pid), 'utf-8');
+}
+
+function cleanupPid() {
+  try { fs.unlinkSync(PID_FILE); } catch (_) {}
+}
+
+// ─── Main loop ────────────────────────────────────────────────────
+
+let running = true;
+let timer = null;
+
+async function tick() {
+  if (!running) return;
+  try {
+    const summary = await runSyncCycle();
+    const pulled = summary.pulled.length;
+    const pushed = summary.pushed.length;
+    const errors = summary.errors.length;
+    if (pulled > 0 || pushed > 0 || errors > 0) {
+      log('INFO', `Sync cycle: pulled=${pulled} pushed=${pushed} errors=${errors} skipped=${summary.skipped}`);
+      if (pulled > 0) log('INFO', `  Pulled: ${summary.pulled.join(', ')}`);
+      if (pushed > 0) log('INFO', `  Pushed: ${summary.pushed.join(', ')}`);
+      for (const err of summary.errors) log('ERROR', `  ${err}`);
+    }
+  } catch (err) {
+    log('ERROR', `Sync cycle failed: ${err.message}`);
+  }
+  if (running) {
+    timer = setTimeout(tick, INTERVAL_MS);
+  }
+}
+
+function shutdown(signal) {
+  log('INFO', `Received ${signal}, shutting down`);
+  running = false;
+  if (timer) clearTimeout(timer);
+  cleanupPid();
+  process.exit(0);
+}
+
+// ─── Start ────────────────────────────────────────────────────────
+
+ensureLogDir();
+writePid();
+log('INFO', `Sync daemon started (PID ${process.pid}, interval ${INTERVAL_MS / 1000}s)`);
+
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+process.on('SIGINT', () => shutdown('SIGINT'));
+process.on('uncaughtException', (err) => {
+  log('ERROR', `Uncaught: ${err.message}`);
+  cleanupPid();
+  process.exit(1);
+});
+
+// Run first cycle immediately, then on interval
+tick();