sillyspec 3.8.4 → 3.8.6

package/packages/dashboard/server/parser.js

@@ -1,363 +1,59 @@
-import { readFileSync, existsSync, readdirSync, statSync } from 'fs'
-import { execSync } from 'child_process'
+import { readFileSync, existsSync, readdirSync } from 'fs'
 import { join } from 'path'
 import { fileURLToPath } from 'url'
 import { dirname } from 'path'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 
-/**
- * Parse docs tree for a project
- * @param {string} projectPath - Path to the project directory
- * @returns {object} Docs tree grouped by type
- */
-// Known framework detection keywords in package.json dependencies
-const FRAMEWORK_PATTERNS = [
-  { keys: ['react', 'react-dom'], name: 'React' },
-  { keys: ['vue'], name: 'Vue' },
-  { keys: ['next'], name: 'Next.js' },
-  { keys: ['nuxt'], name: 'Nuxt' },
-  { keys: ['express'], name: 'Express' },
-  { keys: ['koa'], name: 'Koa' },
-  { keys: ['fastify'], name: 'Fastify' },
-  { keys: ['nestjs', '@nestjs/core'], name: 'NestJS' },
-  { keys: ['svelte'], name: 'Svelte' },
-  { keys: ['astro'], name: 'Astro' },
-  { keys: ['vite'], name: 'Vite' },
-  { keys: ['webpack'], name: 'Webpack' },
-  { keys: ['typescript'], name: 'TypeScript' },
-  { keys: ['tailwindcss'], name: 'Tailwind' },
-  { keys: ['prisma'], name: 'Prisma' },
-  { keys: ['drizzle-orm'], name: 'Drizzle' },
-]
-
-/**
- * Parse project overview info
- * @param {string} projectPath
- * @returns {object} Overview data
- */
-export function parseProjectOverview(projectPath) {
-  const result = {
-    techStack: [],
-    lastActive: null,
-    docStats: { design: 0, plan: 0, archive: 0, changes: 0, scan: 0, quicklog: 0, total: 0 },
-    git: { branch: '', lastCommit: '', dirtyCount: 0 }
-  }
-
-  // --- Tech stack ---
-  const pkgPath = join(projectPath, 'package.json')
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'))
-      const deps = Object.keys({ ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) })
-      for (const pattern of FRAMEWORK_PATTERNS) {
-        if (pattern.keys.some(k => deps.includes(k))) {
-          result.techStack.push(pattern.name)
-        }
-      }
-    } catch {}
-  }
-  if (existsSync(join(projectPath, 'pom.xml'))) {
-    result.techStack.push('Java')
-    try {
-      const content = readFileSync(join(projectPath, 'pom.xml'), 'utf-8')
-      if (content.includes('spring-boot')) result.techStack.push('Spring Boot')
-    } catch {}
-  }
-  if (existsSync(join(projectPath, 'build.gradle')) || existsSync(join(projectPath, 'build.gradle.kts'))) {
-    if (!result.techStack.includes('Java')) result.techStack.push('Gradle')
-  }
-  if (existsSync(join(projectPath, 'requirements.txt')) || existsSync(join(projectPath, 'pyproject.toml'))) {
-    result.techStack.push('Python')
-  }
-  if (existsSync(join(projectPath, 'go.mod'))) {
-    result.techStack.push('Go')
-  }
-  if (result.techStack.length === 0) result.techStack = []
-
-  // --- Last active ---
-  const sillyspecDir = join(projectPath, '.sillyspec')
-  const progressPath = join(sillyspecDir, '.runtime', 'progress.json')
-  if (existsSync(progressPath)) {
-    try {
-      const progress = JSON.parse(readFileSync(progressPath, 'utf-8'))
-      if (progress.stages) {
-        for (const stageData of Object.values(progress.stages)) {
-          if (stageData.lastActive && (!result.lastActive || new Date(stageData.lastActive) > new Date(result.lastActive))) {
-            result.lastActive = stageData.lastActive
-          }
-        }
-      }
-      if (progress.lastActive) result.lastActive = progress.lastActive
-    } catch {}
-  }
-  if (!result.lastActive) {
-    // Fallback: most recently modified file in .sillyspec
-    try {
-      const findRecent = (dir) => {
-        let latest = null
-        if (!existsSync(dir)) return latest
-        for (const entry of readdirSync(dir, { withFileTypes: true })) {
-          const p = join(dir, entry.name)
-          try {
-            const s = statSync(p)
-            if (entry.isDirectory()) {
-              const sub = findRecent(p)
-              if (sub && (!latest || sub > latest)) latest = sub
-            } else if (!latest || s.mtimeMs > latest) {
-              latest = s.mtimeMs
-            }
-          } catch {}
-        }
-        return latest
-      }
-      const ts = findRecent(sillyspecDir)
-      if (ts) result.lastActive = new Date(ts).toISOString()
-    } catch {}
-  }
-
-  // --- Doc stats ---
-  const docsDir = join(sillyspecDir, 'docs')
-  if (existsSync(docsDir)) {
-    const typeMap = { brainstorm: 'design', plan: 'plan', archive: 'archive', changes: 'changes', scan: 'scan', quicklog: 'quicklog' }
-    try {
-      for (const projDir of readdirSync(docsDir, { withFileTypes: true }).filter(d => d.isDirectory())) {
-        for (const typeDir of readdirSync(join(docsDir, projDir.name), { withFileTypes: true }).filter(d => d.isDirectory())) {
-          const key = typeMap[typeDir.name]
-          if (!key) continue
-          const count = countMdFiles(join(docsDir, projDir.name, typeDir.name))
-          result.docStats[key] += count
-          result.docStats.total += count
-        }
-      }
-    } catch {}
-  }
-
-  // --- Git info ---
-  try {
-    result.git.lastCommit = execSync('git log -1 --format=%s', { cwd: projectPath, encoding: 'utf-8' }).trim()
-  } catch {}
-  try {
-    result.git.branch = execSync('git branch --show-current', { cwd: projectPath, encoding: 'utf-8' }).trim()
-  } catch {}
-  try {
-    result.git.dirtyCount = parseInt(execSync('git status --porcelain', { cwd: projectPath, encoding: 'utf-8' }).trim().split('\n').filter(Boolean).length, 10) || 0
-  } catch {}
-
-  return result
-}
-
-export function parseGitDetail(projectPath) {
-  const result = { branch: '', commits: [], untracked: [] }
-  try {
-    result.branch = execSync('git branch --show-current', { cwd: projectPath, encoding: 'utf-8' }).trim()
-  } catch {}
-  try {
-    const log = execSync('git log -5 --format=%h|%s|%an|%aI', { cwd: projectPath, encoding: 'utf-8' }).trim()
-    result.commits = log.split('\n').filter(Boolean).map(line => {
-      const [hash, message, author, date] = line.split('|')
-      return { hash, message, author, date }
-    })
-  } catch {}
-  try {
-    const status = execSync('git status --porcelain', { cwd: projectPath, encoding: 'utf-8' }).trim()
-    result.untracked = status.split('\n').filter(Boolean).map(line => ({
-      status: line.slice(0, 2).trim(),
-      file: line.slice(3)
-    }))
-  } catch {}
-  return result
-}
-
-export function parseTechStackDetail(projectPath) {
-  const result = { frameworks: [], dependencies: {}, devDependencies: {} }
-  const pkgPath = join(projectPath, 'package.json')
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'))
-      result.dependencies = pkg.dependencies || {}
-      result.devDependencies = pkg.devDependencies || {}
-      const allDeps = Object.keys({ ...result.dependencies, ...result.devDependencies })
-      for (const pattern of FRAMEWORK_PATTERNS) {
-        if (pattern.keys.some(k => allDeps.includes(k))) {
-          result.frameworks.push(pattern.name)
-        }
-      }
-    } catch {}
-  }
-  return result
-}
-
-export function parseDocsList(projectPath) {
-  const sillyspecDir = join(projectPath, '.sillyspec')
-  const docsDir = join(sillyspecDir, 'docs')
-  const groups = []
-  if (!existsSync(docsDir)) return groups
-  const typeMap = {
-    brainstorm: { label: '设计文档', icon: '📋' },
-    plan: { label: '实现计划', icon: '📐' },
-    archive: { label: '已归档', icon: '📦' },
-    changes: { label: '当前变更', icon: '⚙️' },
-    scan: { label: '架构文档', icon: '🔍' },
-    quicklog: { label: '快速修复', icon: '⚡' }
-  }
-  try {
-    for (const projDir of readdirSync(docsDir, { withFileTypes: true }).filter(d => d.isDirectory())) {
-      for (const typeDir of readdirSync(join(docsDir, projDir.name), { withFileTypes: true }).filter(d => d.isDirectory())) {
-        const cfg = typeMap[typeDir.name]
-        if (!cfg) continue
-        const files = listFilesRecursive(join(docsDir, projDir.name, typeDir.name))
-        if (files.length) {
-          groups.push({ key: typeDir.name, label: cfg.label, icon: cfg.icon, files })
-        }
-      }
-    }
-  } catch {}
-  return groups
-}
-
-function listFilesRecursive(dir) {
-  const files = []
-  try {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const p = join(dir, entry.name)
-      if (entry.isDirectory()) {
-        const sub = listFilesRecursive(p)
-        for (const f of sub) f.name = entry.name + '/' + f.name
-        files.push(...sub)
-      } else if (entry.name.endsWith('.md')) {
-        const s = statSync(p)
-        files.push({ name: entry.name, path: p, size: s.size, mtime: s.mtime.toISOString() })
-      }
-    }
-  } catch {}
-  return files
-}
-
-function countMdFiles(dir) {
-  let count = 0
-  try {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      if (entry.isDirectory()) {
-        count += countMdFiles(join(dir, entry.name))
-      } else if (entry.name.endsWith('.md')) {
-        count++
-      }
-    }
-  } catch {}
-  return count
-}
-
-export function parseDocsTree(projectPath) {
-  const sillyspecDir = join(projectPath, '.sillyspec')
-  const docsDir = join(sillyspecDir, 'docs')
-
-  if (!existsSync(docsDir)) {
-    return { groups: [] }
-  }
-
-  const groupConfig = [
-    { key: 'brainstorm', label: '📋 设计文档', icon: '📋', dir: 'brainstorm' },
-    { key: 'plan', label: '📐 实现计划', icon: '📐', dir: 'plan' },
-    { key: 'changes', label: '⚙️ 当前变更', icon: '⚙️', dir: 'changes' },
-    { key: 'archive', label: '📦 已归档', icon: '📦', dir: 'archive' },
-    { key: 'scan', label: '🔍 架构文档', icon: '🔍', dir: 'scan' },
-    { key: 'quicklog', label: '⚡ 快速修复', icon: '⚡', dir: 'quicklog' },
-  ]
-
-  const groups = []
-
-  // Find project dirs under docs/
-  const projectDirs = existsSync(docsDir) ? readdirSync(docsDir, { withFileTypes: true })
-    .filter(d => d.isDirectory()).map(d => d.name) : []
-
-  for (const projName of projectDirs) {
-    const projDocsDir = join(docsDir, projName)
-
-    for (const group of groupConfig) {
-      const groupDir = join(projDocsDir, group.dir)
-      if (!existsSync(groupDir)) continue
-
-      const files = []
-      try {
-        const entries = readdirSync(groupDir, { withFileTypes: true })
-        for (const entry of entries) {
-          if (entry.isDirectory()) {
-            // For changes/ and archive/ subdirs
-            const subDir = join(groupDir, entry.name)
-            try {
-              const subFiles = readdirSync(subDir).filter(f => f.endsWith('.md'))
-              for (const sf of subFiles) {
-                const filePath = join(subDir, sf)
-                files.push({
-                  name: `${entry.name}/${sf}`,
-                  path: filePath,
-                  title: sf.replace('.md', '')
-                })
-              }
-            } catch {}
-          } else if (entry.name.endsWith('.md')) {
-            const filePath = join(groupDir, entry.name)
-            let title = entry.name.replace('.md', '')
-            try {
-              const content = readFileSync(filePath, 'utf-8')
-              const titleMatch = content.match(/^#\s+(.+)$/m)
-              if (titleMatch) title = titleMatch[1]
-            } catch {}
-            files.push({ name: entry.name, path: filePath, title })
-          }
-        }
-      } catch {}
-
-      if (files.length > 0) {
-        groups.push({
-          key: `${projName}::${group.key}`,
-          label: group.label,
-          project: projName,
-          files
-        })
-      }
-    }
-  }
-
-  return { groups }
-}
-
 /**
  * Parse project state from .sillyspec directory
  * @param {string} projectPath - Path to the project directory
  * @returns {object} Project state with currentStage, nextStep, progress, stages, specs, lastActive
  */
-export function parseProjectState(projectPath) {
+export async function parseProjectState(projectPath) {
   const sillyspecDir = join(projectPath, '.sillyspec')
 
   if (!existsSync(sillyspecDir)) {
     return null
   }
 
-  let currentStage = ''
+  let currentStage = 'unknown'
   let nextStep = null
   let progress = { stages: {} }
   let stages = []
   let specs = []
   let lastActive = null
 
-  // Read progress.json for current stage
+  // Read STATE.md for current stage and next step
+  const statePath = join(sillyspecDir, 'STATE.md')
+  if (existsSync(statePath)) {
+    try {
+      const stateContent = readFileSync(statePath, 'utf-8')
+      const stageMatch = stateContent.match(/current_stage:\s*(\w+)/i)
+      const stepMatch = stateContent.match(/next_step:\s*(.+)/i)
+
+      if (stageMatch) currentStage = stageMatch[1]
+      if (stepMatch) nextStep = stepMatch[1].trim()
+    } catch (err) {
+      // State file exists but couldn't be read
+    }
+  }
+
+  // Read progress.json from .runtime directory
   const progressPath = join(sillyspecDir, '.runtime', 'progress.json')
   if (existsSync(progressPath)) {
     try {
-      const progressData = JSON.parse(readFileSync(progressPath, 'utf-8'))
-      progress = progressData
-      currentStage = progressData.currentStage || ''
-      stages = Object.keys(progressData.stages || {})
+      const progressContent = readFileSync(progressPath, 'utf-8')
+      progress = JSON.parse(progressContent)
+      stages = Object.keys(progress.stages || {})
 
-      // Find last active
-      if (progressData.lastActive) lastActive = progressData.lastActive
-      if (progressData.stages) {
-        for (const [stageName, stageData] of Object.entries(progressData.stages)) {
-          if (stageData.lastActive || stageData.startedAt) {
-            const t = stageData.lastActive || stageData.startedAt
-            if (!lastActive || new Date(t) > new Date(lastActive)) lastActive = t
+      // Find last active stage
+      if (progress.stages) {
+        for (const [stageName, stageData] of Object.entries(progress.stages)) {
+          if (stageData.lastActive) {
+            if (!lastActive || new Date(stageData.lastActive) > new Date(lastActive)) {
+              lastActive = stageData.lastActive
+            }
           }
         }
       }