dave-code 1.0.3 → 1.1.0

package/bin/install.js

@@ -2,8 +2,8 @@ import ora from 'ora';
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-async function runInstallationAnimation() {
-  console.log('\n\x1b[1;38;2;250;100;30m=== Dave Code Installer ===\x1b[0m\n');
+export async function runWelcomeAnimation() {
+  console.log('\n\x1b[1;38;2;250;100;30m=== Welcome to Dave Code ===\x1b[0m\n');
 
   // Stage 1: Environment Check
   const spinner1 = ora({
@@ -40,11 +40,9 @@ async function runInstallationAnimation() {
  / /_/ / /_/ /| |/ /  __// /___/ /_/ / /_/ /  __/ 
 /_____/\\__,_/ |___/\\___/ \\____/\\____/\\__,_/\\___/  ` + '\x1b[0m\n');
 
-  console.log('\x1b[1;32m✔ Installation completed successfully! 🎉\x1b[0m');
+  console.log('\x1b[1;32m✔ Initialization completed successfully! 🎉\x1b[0m');
   console.log('\x1b[90m--------------------------------------------------\x1b[0m');
   console.log('🚀 \x1b[1;36mDave Code\x1b[0m is now ready for use!');
   console.log('💡 Type \x1b[33mcalldave\x1b[0m in your terminal to start pair programming.');
   console.log('\x1b[90m--------------------------------------------------\x1b[0m\n');
 }
-
-runInstallationAnimation().catch(console.error);

package/bin/planManager.js

@@ -0,0 +1,239 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+const STORE_VERSION = 1;
+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
+    };
+  } 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 || parsed.version !== STORE_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 }, { 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
+      }
+    : {
+        ...store.plans[index],
+        name: validName,
+        status: 'ready',
+        request: String(request || '').trim(),
+        content: validContent,
+        updatedAt: now,
+        lastRun: null
+      };
+
+  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 plans = listPlans(workspaceRoot);
+  const symbols = { ready: '○', running: '▶', completed: '✓', blocked: '!' };
+  const lines = plans.slice(0, limit).map(plan => `${symbols[plan.status] || '○'} ${plan.name}`);
+  if (plans.length > limit) lines.push(`+${plans.length - limit} more`);
+  return lines;
+}

package/bin/runtimeEvents.js

@@ -0,0 +1,62 @@
+import { EventEmitter } from 'events';
+
+export const RUNTIME_EVENT_TYPES = new Set([
+  'turn.started',
+  'turn.completed',
+  'turn.failed',
+  'turn.cancelled',
+  'model.started',
+  'model.delta',
+  'model.tool_call',
+  'model.completed',
+  'model.retry',
+  'tool.requested',
+  'tool.started',
+  'tool.progress',
+  'tool.completed',
+  'tool.failed',
+  'permission.requested',
+  'permission.resolved',
+  'context.compacted'
+]);
+
+export function createRuntimeEvents({ turnId, now = Date.now } = {}) {
+  const emitter = new EventEmitter();
+  const resolvedTurnId = turnId || `turn-${now()}-${Math.random().toString(36).slice(2, 8)}`;
+  let seq = 0;
+  let closed = false;
+
+  function emit(type, data = {}) {
+    if (closed) return null;
+    if (!RUNTIME_EVENT_TYPES.has(type)) {
+      throw new Error(`Unknown runtime event type: ${type}`);
+    }
+    const event = {
+      version: 1,
+      seq: ++seq,
+      type,
+      turnId: resolvedTurnId,
+      timestamp: now(),
+      data: data && typeof data === 'object' ? data : { value: data }
+    };
+    emitter.emit('event', event);
+    return event;
+  }
+
+  function subscribe(listener) {
+    emitter.on('event', listener);
+    return () => emitter.off('event', listener);
+  }
+
+  function close() {
+    closed = true;
+    emitter.removeAllListeners();
+  }
+
+  return {
+    turnId: resolvedTurnId,
+    emit,
+    subscribe,
+    close
+  };
+}

package/bin/sessionManager.js

@@ -0,0 +1,166 @@
+/**
+ * ── DESIGN PHILOSOPHY / 视觉设计与交互规范 ──
+ * 为了向用户提供极致、顺滑的交互体验，Dave Code 规定：
+ * 1. 所有耗时的 API 请求、大文件处理和本地工具调用，都必须具有动画化（Animated）或动态（Dynamic）的终端 UI。
+ * 2. 严禁使用静态、刷屏式的连续 Log 输出。对于多步骤操作（如分片消化），应使用单行原地更新（In-place update）的进度条和加载动画。
+ * 3. 使用富文本终端色彩（如精心调配的 HSL/ANSI 颜色）和微型字符动画（如 Spinner）来提供实时的视觉反馈。
+ * 后续维护与功能续写时，必须严格遵守此设计理念。
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+
+export let SESSIONS_DIR = path.join(os.homedir(), '.dave-code-sessions');
+
+export function setSessionsDirForTesting(directory) {
+  SESSIONS_DIR = directory;
+}
+
+function normalizeMessage(message) {
+  if (!message || typeof message !== 'object') return null;
+  if (!['user', 'assistant', 'tool'].includes(message.role)) return null;
+  if (typeof message.content !== 'string') return null;
+  return { ...message, role: message.role, content: message.content };
+}
+
+function normalizeSession(session) {
+  if (!session || typeof session !== 'object' || !session.id || !Array.isArray(session.messages)) return null;
+  if (!/^[A-Za-z0-9_-]+$/.test(String(session.id))) return null;
+  const messages = session.messages.map(normalizeMessage).filter(Boolean);
+  return {
+    ...session,
+    id: String(session.id),
+    title: String(session.title || 'New Chat'),
+    timestamp: Number(session.timestamp) || Date.now(),
+    messages,
+    workspaceRoot: typeof session.workspaceRoot === 'string' ? session.workspaceRoot : null,
+    activeOpenFile: typeof session.activeOpenFile === 'string' ? session.activeOpenFile : null
+  };
+}
+
+function atomicWriteSession(filePath, sessionData) {
+  const tempPath = `${filePath}.${process.pid}.${crypto.randomBytes(5).toString('hex')}.tmp`;
+  fs.writeFileSync(tempPath, JSON.stringify(sessionData, null, 2), { encoding: 'utf8', mode: 0o600 });
+  try {
+    fs.chmodSync(tempPath, 0o600);
+  } catch {
+    // Best effort on Windows.
+  }
+  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 ensureSessionsDir() {
+  try {
+    if (!fs.existsSync(SESSIONS_DIR)) {
+      fs.mkdirSync(SESSIONS_DIR, { recursive: true, mode: 0o700 });
+    }
+    try {
+      fs.chmodSync(SESSIONS_DIR, 0o700);
+    } catch {
+      // Best effort on Windows.
+    }
+  } catch (e) {
+    // Ignore folder creation errors (handled gracefully during saves)
+  }
+}
+
+/**
+ * List all saved chat sessions sorted by timestamp descending (newest first).
+ * @returns {Array} Array of session objects
+ */
+export function listSessions() {
+  ensureSessionsDir();
+  try {
+    if (!fs.existsSync(SESSIONS_DIR)) return [];
+    
+    const files = fs.readdirSync(SESSIONS_DIR);
+    const sessions = [];
+    for (const file of files) {
+      if (file.endsWith('.json')) {
+        try {
+          const filePath = path.join(SESSIONS_DIR, file);
+          const content = fs.readFileSync(filePath, 'utf8');
+          const session = normalizeSession(JSON.parse(content));
+          if (session && session.id) {
+            sessions.push(session);
+          }
+        } catch (e) {
+          // Skip invalid JSON files
+        }
+      }
+    }
+    return sessions.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Save or update a session file.
+ * @param {string} sessionId Unique session identifier
+ * @param {object} sessionData Session object containing messages, title, timestamp, and workspace metadata
+ */
+export function saveSession(sessionId, sessionData) {
+  ensureSessionsDir();
+  try {
+    const safeId = String(sessionId || '');
+    if (!/^[A-Za-z0-9_-]+$/.test(safeId)) return false;
+    const normalized = normalizeSession({ ...sessionData, id: safeId });
+    if (!normalized) return false;
+    const filePath = path.join(SESSIONS_DIR, `${safeId}.json`);
+    atomicWriteSession(filePath, normalized);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Load a session from its identifier.
+ * @param {string} sessionId Unique session identifier
+ * @returns {object|null} Loaded session or null if not found
+ */
+export function loadSession(sessionId) {
+  ensureSessionsDir();
+  try {
+    if (!/^[A-Za-z0-9_-]+$/.test(String(sessionId || ''))) return null;
+    const filePath = path.join(SESSIONS_DIR, `${sessionId}.json`);
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf8');
+      return normalizeSession(JSON.parse(content));
+    }
+  } catch (e) {
+    // Return null on parsing or read failures
+  }
+  return null;
+}
+
+/**
+ * Delete a session from storage.
+ * @param {string} sessionId Unique session identifier
+ * @returns {boolean} True if successfully deleted
+ */
+export function deleteSession(sessionId) {
+  ensureSessionsDir();
+  try {
+    if (!/^[A-Za-z0-9_-]+$/.test(String(sessionId || ''))) return false;
+    const filePath = path.join(SESSIONS_DIR, `${sessionId}.json`);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      return true;
+    }
+  } catch (e) {
+    // Ignore unlink failures
+  }
+  return false;
+}