dave-code 1.0.4 → 1.2.0

package/bin/planManager.js

@@ -0,0 +1,291 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+const STORE_VERSION = 2;
+const VALID_STATUSES = new Set(['ready', 'running', 'completed', 'blocked']);
+let plansBaseDir = path.join(os.homedir(), '.dave-code-plans');
+
+export function setPlansBaseDirForTesting(directory) {
+  plansBaseDir = directory;
+}
+
+export function canonicalWorkspaceRoot(workspaceRoot) {
+  const resolved = path.resolve(workspaceRoot || process.cwd());
+  let canonical = resolved;
+  try {
+    canonical = fs.realpathSync.native(resolved);
+  } catch {
+    // A workspace is validated by the caller. Keep the resolved value for diagnostics.
+  }
+  return process.platform === 'win32' ? canonical.toLowerCase() : canonical;
+}
+
+function workspaceKey(workspaceRoot) {
+  return crypto.createHash('sha256').update(canonicalWorkspaceRoot(workspaceRoot)).digest('hex');
+}
+
+export function getPlansFile(workspaceRoot) {
+  return path.join(plansBaseDir, `${workspaceKey(workspaceRoot)}.json`);
+}
+
+function ensurePlansDir() {
+  fs.mkdirSync(plansBaseDir, { recursive: true, mode: 0o700 });
+  try {
+    fs.chmodSync(plansBaseDir, 0o700);
+  } catch {
+    // Windows does not implement POSIX modes in the same way.
+  }
+}
+
+function normalizeName(name) {
+  return String(name || '').trim().toLocaleLowerCase();
+}
+
+export function validatePlanName(name) {
+  const value = String(name || '').trim();
+  if (!value) throw new Error('Plan name is required.');
+  if ([...value].length > 60) throw new Error('Plan name must be 60 characters or fewer.');
+  if (value.includes(':') || /[\u0000-\u001f\u007f]/.test(value)) {
+    throw new Error('Plan name cannot contain a colon or control characters.');
+  }
+  return value;
+}
+
+export function validatePlanContent(content) {
+  const text = String(content || '');
+  const checks = [
+    { label: 'goal and acceptance criteria', pattern: /目标|验收|goal|acceptance/i },
+    { label: 'verified current-state facts', pattern: /当前|现状|事实|current state|verified facts/i },
+    { label: 'ordered implementation steps', pattern: /步骤|step\s*\d|implementation steps/i },
+    { label: 'what and how details', pattern: /做什么|怎么做|具体实现|what|how|implementation/i },
+    { label: 'validation', pattern: /验证|测试|validation|test plan/i },
+    { label: 'risks and rollback', pattern: /风险|回退|回滚|risk|rollback/i }
+  ];
+  return checks.filter(check => !check.pattern.test(text)).map(check => check.label);
+}
+
+function validateStoredPlan(plan) {
+  if (!plan || typeof plan !== 'object') return null;
+  try {
+    const name = validatePlanName(plan.name);
+    const status = VALID_STATUSES.has(plan.status) ? plan.status : 'ready';
+    return {
+      id: String(plan.id || crypto.randomUUID()),
+      name,
+      status,
+      request: String(plan.request || ''),
+      content: String(plan.content || ''),
+      createdAt: Number(plan.createdAt) || Date.now(),
+      updatedAt: Number(plan.updatedAt) || Date.now(),
+      lastRun: plan.lastRun && typeof plan.lastRun === 'object' ? plan.lastRun : null,
+      workflowMode: plan.workflowMode === 'thunder' ? 'thunder' : 'highway',
+      teamId: plan.teamId ? String(plan.teamId) : null,
+      resourceProposal: plan.resourceProposal && typeof plan.resourceProposal === 'object' ? plan.resourceProposal : null,
+      teamSnapshot: plan.teamSnapshot && typeof plan.teamSnapshot === 'object' ? plan.teamSnapshot : null,
+      taskGraph: Array.isArray(plan.taskGraph) ? plan.taskGraph : [],
+      decisions: Array.isArray(plan.decisions) ? plan.decisions.map(String) : []
+    };
+  } catch {
+    return null;
+  }
+}
+
+function emptyStore(workspaceRoot) {
+  return {
+    version: STORE_VERSION,
+    workspaceRoot: canonicalWorkspaceRoot(workspaceRoot),
+    plans: []
+  };
+}
+
+export function loadPlanStore(workspaceRoot) {
+  const filePath = getPlansFile(workspaceRoot);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    if (!parsed || ![1, STORE_VERSION].includes(parsed.version) || !Array.isArray(parsed.plans)) {
+      return emptyStore(workspaceRoot);
+    }
+    return {
+      version: STORE_VERSION,
+      workspaceRoot: canonicalWorkspaceRoot(workspaceRoot),
+      plans: parsed.plans.map(validateStoredPlan).filter(Boolean)
+    };
+  } catch {
+    return emptyStore(workspaceRoot);
+  }
+}
+
+function atomicWriteJson(filePath, value) {
+  ensurePlansDir();
+  const tempPath = `${filePath}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`;
+  fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), { encoding: 'utf8', mode: 0o600 });
+  try {
+    fs.chmodSync(tempPath, 0o600);
+  } catch {
+    // Best effort on platforms without POSIX permissions.
+  }
+  try {
+    fs.renameSync(tempPath, filePath);
+  } catch (error) {
+    if (process.platform !== 'win32' || !fs.existsSync(filePath)) throw error;
+    fs.unlinkSync(filePath);
+    fs.renameSync(tempPath, filePath);
+  } finally {
+    if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+  }
+}
+
+export function savePlanStore(workspaceRoot, store) {
+  const normalized = {
+    version: STORE_VERSION,
+    workspaceRoot: canonicalWorkspaceRoot(workspaceRoot),
+    plans: (store.plans || []).map(validateStoredPlan).filter(Boolean)
+  };
+  atomicWriteJson(getPlansFile(workspaceRoot), normalized);
+  return normalized;
+}
+
+export function listPlans(workspaceRoot) {
+  return loadPlanStore(workspaceRoot).plans.sort((a, b) => {
+    const rank = status => status === 'running' ? 0 : status === 'ready' ? 1 : status === 'blocked' ? 2 : 3;
+    return rank(a.status) - rank(b.status) || b.updatedAt - a.updatedAt;
+  });
+}
+
+export function findPlan(workspaceRoot, name) {
+  const key = normalizeName(name);
+  return listPlans(workspaceRoot).find(plan => normalizeName(plan.name) === key) || null;
+}
+
+export function upsertPlan(workspaceRoot, { name, request, content, workflowMode = 'highway', teamId = null, resourceProposal = null, teamSnapshot = null, taskGraph = [], decisions = [] }, { replace = false } = {}) {
+  const validName = validatePlanName(name);
+  const validContent = String(content || '').trim();
+  const missingSections = validatePlanContent(validContent);
+  if (missingSections.length > 0) throw new Error(`Plan content is incomplete: missing ${missingSections.join(', ')}.`);
+  const store = loadPlanStore(workspaceRoot);
+  const index = store.plans.findIndex(plan => normalizeName(plan.name) === normalizeName(validName));
+  const now = Date.now();
+  if (index !== -1 && !replace) throw new Error(`Plan already exists: ${store.plans[index].name}`);
+
+  const next = index === -1
+    ? {
+        id: crypto.randomUUID(),
+        name: validName,
+        status: 'ready',
+        request: String(request || '').trim(),
+        content: validContent,
+        createdAt: now,
+        updatedAt: now,
+        lastRun: null,
+        workflowMode: workflowMode === 'thunder' ? 'thunder' : 'highway',
+        teamId,
+        resourceProposal,
+        teamSnapshot,
+        taskGraph,
+        decisions
+      }
+    : {
+        ...store.plans[index],
+        name: validName,
+        status: 'ready',
+        request: String(request || '').trim(),
+        content: validContent,
+        updatedAt: now,
+        lastRun: null,
+        workflowMode: workflowMode === 'thunder' ? 'thunder' : 'highway',
+        teamId,
+        resourceProposal,
+        teamSnapshot,
+        taskGraph,
+        decisions
+      };
+
+  if (index === -1) store.plans.push(next);
+  else store.plans[index] = next;
+  savePlanStore(workspaceRoot, store);
+  return next;
+}
+
+export function updatePlan(workspaceRoot, planId, updates = {}) {
+  const store = loadPlanStore(workspaceRoot);
+  const index = store.plans.findIndex(plan => plan.id === planId);
+  if (index === -1) return null;
+  const nextStatus = updates.status === undefined ? store.plans[index].status : updates.status;
+  if (!VALID_STATUSES.has(nextStatus)) throw new Error(`Invalid plan status: ${nextStatus}`);
+  store.plans[index] = {
+    ...store.plans[index],
+    ...updates,
+    id: store.plans[index].id,
+    name: updates.name === undefined ? store.plans[index].name : validatePlanName(updates.name),
+    status: nextStatus,
+    updatedAt: Date.now()
+  };
+  savePlanStore(workspaceRoot, store);
+  return store.plans[index];
+}
+
+export function renamePlan(workspaceRoot, planId, nextName) {
+  const validName = validatePlanName(nextName);
+  const store = loadPlanStore(workspaceRoot);
+  if (store.plans.some(plan => plan.id !== planId && normalizeName(plan.name) === normalizeName(validName))) {
+    throw new Error(`Plan already exists: ${validName}`);
+  }
+  const index = store.plans.findIndex(plan => plan.id === planId);
+  if (index === -1) return null;
+  store.plans[index] = { ...store.plans[index], name: validName, updatedAt: Date.now() };
+  savePlanStore(workspaceRoot, store);
+  return store.plans[index];
+}
+
+export function deletePlan(workspaceRoot, planId) {
+  const store = loadPlanStore(workspaceRoot);
+  const next = store.plans.filter(plan => plan.id !== planId);
+  if (next.length === store.plans.length) return false;
+  store.plans = next;
+  savePlanStore(workspaceRoot, store);
+  return true;
+}
+
+export function planStatusLines(workspaceRoot, limit = 4) {
+  const panel = planStatusPanel(workspaceRoot, limit);
+  const symbols = { ready: '○', running: '▶', completed: '✓', blocked: '!' };
+  const lines = panel.items.map(plan => `${symbols[plan.status] || '○'} ${plan.name}`);
+  if (panel.hidden > 0) lines.push(`+${panel.hidden} more`);
+  return lines;
+}
+
+/**
+ * Select plans for the persistent header panel. When active and completed plans
+ * coexist, reserve one slot for the most recently completed plan so completed
+ * work never disappears behind a long ready queue.
+ */
+export function planStatusPanel(workspaceRoot, limit = 4) {
+  const plans = listPlans(workspaceRoot);
+  const safeLimit = Math.max(1, Math.floor(Number(limit) || 4));
+  const active = plans.filter(plan => plan.status !== 'completed');
+  const completed = plans
+    .filter(plan => plan.status === 'completed')
+    .sort((a, b) => b.updatedAt - a.updatedAt);
+
+  let items;
+  if (active.length > 0 && completed.length > 0 && safeLimit > 1) {
+    items = [...active.slice(0, safeLimit - 1), completed[0]];
+  } else {
+    items = (active.length > 0 ? active : completed).slice(0, safeLimit);
+  }
+
+  return {
+    items,
+    total: plans.length,
+    hidden: Math.max(0, plans.length - items.length),
+    counts: {
+      ready: plans.filter(plan => plan.status === 'ready').length,
+      running: plans.filter(plan => plan.status === 'running').length,
+      blocked: plans.filter(plan => plan.status === 'blocked').length,
+      completed: completed.length,
+      active: active.length
+    }
+  };
+}