cc-insight 0.1.0

package/src/db/queries.js

@@ -0,0 +1,314 @@
+// src/db/queries.js
+import { getDb } from './db.js'
+
+export function upsertSession({ id, source, startTime, endTime, durationSec,
+                                 projectPath, messageCount, toolUseCount, jsonlFile,
+                                 topic = null, topicKeywords = null, firstUserMsg = null }) {
+  getDb().prepare(`
+    INSERT OR REPLACE INTO sessions
+      (id, source, start_time, end_time, duration_sec, project_path, message_count, tool_use_count, jsonl_file,
+       topic, topic_keywords, first_user_msg)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, source, startTime, endTime, durationSec, projectPath, messageCount, toolUseCount, jsonlFile,
+         topic, topicKeywords ? JSON.stringify(topicKeywords) : null, firstUserMsg ?? null)
+}
+
+export function upsertTool({ id, name, type, subtype, description, sourceType, sourceUrl,
+                              installedAt, updatedAt, securityScanResult }) {
+  getDb().prepare(`
+    INSERT OR REPLACE INTO tools
+      (id, name, type, subtype, description, source_type, source_url, installed_at, updated_at, security_scan_result)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, name, type, subtype ?? null, description, sourceType, sourceUrl, installedAt, updatedAt, securityScanResult)
+}
+
+export function insertInvocations(invocations) {
+  const stmt = getDb().prepare(
+    'INSERT OR IGNORE INTO tool_invocations (session_id, tool_name, invoked_at) VALUES (?, ?, ?)'
+  )
+  const insert = getDb().transaction((rows) => {
+    for (const r of rows) stmt.run(r.sessionId, r.toolName, r.invokedAt)
+  })
+  insert(invocations)
+}
+
+export function getSessionCount({ after }) {
+  return getDb().prepare(
+    'SELECT COUNT(*) as n FROM sessions WHERE start_time >= ?'
+  ).get(after).n
+}
+
+// 每个 session 最多计 4 小时（14400s），避免长时间挂起的对话文件虚增时长
+const SESSION_DUR_CAP = 14400
+
+export function getTotalDurationSec({ after }) {
+  return getDb().prepare(
+    'SELECT COALESCE(SUM(MIN(duration_sec, ?)), 0) as total FROM sessions WHERE start_time >= ?'
+  ).get(SESSION_DUR_CAP, after).total
+}
+
+export function getAvgDailyDurationSec({ after }) {
+  const db = getDb()
+  const total = getTotalDurationSec({ after })
+  const days = db.prepare(
+    "SELECT COUNT(DISTINCT date(start_time / 1000, 'unixepoch', '+8 hours')) as n FROM sessions WHERE start_time >= ?"
+  ).get(after).n
+  return days > 0 ? Math.round(total / days) : 0
+}
+
+export function getPeakPeriod({ after }) {
+  const rows = getDb().prepare(`
+    SELECT strftime('%H', start_time / 1000, 'unixepoch', '+8 hours') as hour, COUNT(*) as n
+    FROM sessions WHERE start_time >= ?
+    GROUP BY hour ORDER BY n DESC LIMIT 1
+  `).get(after)
+  if (!rows) return null
+  const h = parseInt(rows.hour)
+  return `${String(h).padStart(2,'0')}:00–${String(h+2 > 23 ? 23 : h+2).padStart(2,'0')}:59`
+}
+
+// 2020-01-01 毫秒时间戳，用于过滤明显异常的历史时间戳
+const MIN_VALID_TS = 1577836800000
+
+export function getSilentDays() {
+  const db = getDb()
+  // 连续静默期 = 距今最近一次使用间隔多少天，与时间范围无关，始终查全量
+  const activeDays = new Set(
+    db.prepare("SELECT DISTINCT date(start_time / 1000, 'unixepoch', '+8 hours') as d FROM sessions WHERE start_time >= ?")
+      .all(MIN_VALID_TS).map(r => r.d)
+  )
+  const today = new Date(Date.now() + 8 * 3600_000)
+  today.setUTCHours(0, 0, 0, 0)
+  let silent = 0
+  for (let d = new Date(today); silent < 365; d.setUTCDate(d.getUTCDate() - 1)) {
+    if (activeDays.has(d.toISOString().slice(0, 10))) break
+    silent++
+  }
+  return silent
+}
+
+export function getHeatmapData({ after }) {
+  return getDb().prepare(`
+    SELECT date(start_time / 1000, 'unixepoch', '+8 hours') as day, COUNT(*) as count
+    FROM sessions WHERE start_time >= ?
+    GROUP BY day ORDER BY day
+  `).all(after)
+}
+
+export function get24hDistribution({ after }) {
+  return getDb().prepare(`
+    SELECT strftime('%H', start_time / 1000, 'unixepoch', '+8 hours') as hour, COUNT(*) as count
+    FROM sessions WHERE start_time >= ?
+    GROUP BY hour ORDER BY hour
+  `).all(after)
+}
+
+export function getInvocationsByTool({ after }) {
+  return getDb().prepare(`
+    SELECT tool_name as toolName, COUNT(*) as count
+    FROM tool_invocations WHERE invoked_at >= ?
+    GROUP BY tool_name ORDER BY count DESC
+  `).all(after)
+}
+
+export function getAllTools() {
+  return getDb().prepare('SELECT * FROM tools ORDER BY installed_at DESC').all()
+}
+
+export function getToolUsageStats({ after }) {
+  // plugin 的子 skill 调用格式为 "pluginName:subSkill"，按冒号前缀归组
+  // 这样 superpowers:brainstorming 等会归到 "superpowers"
+  return getDb().prepare(`
+    SELECT
+      CASE
+        WHEN tool_name GLOB '*:*'
+          THEN substr(tool_name, 1, instr(tool_name, ':') - 1)
+        ELSE tool_name
+      END as toolName,
+      COUNT(*) as useCount,
+      MAX(invoked_at) as lastUsedAt
+    FROM tool_invocations WHERE invoked_at >= ?
+    GROUP BY toolName
+  `).all(after)
+}
+
+export function getDustToolNames({ after }) {
+  const used = new Set(
+    getDb().prepare(`
+      SELECT DISTINCT tool_name FROM tool_invocations WHERE invoked_at >= ?
+    `).all(after).map(r => r.tool_name)
+  )
+  return getDb().prepare('SELECT name FROM tools').all()
+    .map(r => r.name)
+    .filter(name => !used.has(name))
+}
+
+export function deleteTool(name) {
+  getDb().prepare('DELETE FROM tools WHERE name = ?').run(name)
+}
+
+// 全量同步：删除不在 foundIds 集合中的工具（用于重建索引时清理旧记录）
+export function syncToolIds(foundIds) {
+  const all = getDb().prepare('SELECT id FROM tools').all().map(r => r.id)
+  const toDelete = all.filter(id => !foundIds.has(id))
+  const del = getDb().prepare('DELETE FROM tools WHERE id = ?')
+  const run = getDb().transaction(ids => { for (const id of ids) del.run(id) })
+  run(toDelete)
+}
+
+// plugin 子技能调用明细（tool_name 格式：pluginName:subSkill）
+export function getPluginSubskillStats({ name, after }) {
+  return getDb().prepare(`
+    SELECT tool_name as toolName, COUNT(*) as count
+    FROM tool_invocations
+    WHERE tool_name GLOB ? AND invoked_at >= ?
+    GROUP BY tool_name ORDER BY count DESC
+  `).all(name + ':*', after)
+}
+
+export function getToolDistribution({ after }) {
+  // 只取内置工具：首字母大写、不含 : 或 __ (GLOB 里 _ 不是通配符)
+  return getDb().prepare(`
+    SELECT tool_name as toolName, COUNT(*) as count
+    FROM tool_invocations
+    WHERE invoked_at >= ?
+      AND tool_name GLOB '[A-Z]*'
+      AND tool_name NOT GLOB '*:*'
+      AND tool_name NOT GLOB '*__*'
+    GROUP BY tool_name ORDER BY count DESC
+  `).all(after)
+}
+
+export function getIndexedFiles() {
+  return new Set(
+    getDb().prepare('SELECT jsonl_file FROM sessions WHERE jsonl_file IS NOT NULL').all()
+      .map(r => r.jsonl_file)
+  )
+}
+
+export function getFilesNeedingTopics() {
+  return new Set(
+    getDb().prepare('SELECT jsonl_file FROM sessions WHERE topic IS NULL AND jsonl_file IS NOT NULL').all()
+      .map(r => r.jsonl_file)
+  )
+}
+
+export function getTopicsOverview({ after }) {
+  return getDb().prepare(`
+    SELECT topic,
+           COUNT(*) as count,
+           ROUND(COUNT(*) * 100.0 / SUM(COUNT(*)) OVER (), 1) as pct
+    FROM sessions
+    WHERE start_time >= ? AND topic IS NOT NULL
+    GROUP BY topic
+    ORDER BY count DESC
+  `).all(after)
+}
+
+// ── Insights / Efficiency 查询 ──
+
+export function getAvgRoundsByTopic({ after }) {
+  return getDb().prepare(`
+    SELECT topic, ROUND(AVG(message_count), 1) as avgRounds
+    FROM sessions
+    WHERE start_time >= ? AND topic IS NOT NULL
+    GROUP BY topic
+    ORDER BY avgRounds DESC
+  `).all(after)
+}
+
+export function getDurationByTopic({ after }) {
+  return getDb().prepare(`
+    SELECT topic,
+           SUM(MIN(duration_sec, 14400)) as totalSec,
+           ROUND(SUM(MIN(duration_sec, 14400)) * 100.0
+             / SUM(SUM(MIN(duration_sec, 14400))) OVER (), 1) as pct
+    FROM sessions
+    WHERE start_time >= ? AND topic IS NOT NULL
+    GROUP BY topic
+    ORDER BY totalSec DESC
+  `).all(after)
+}
+
+export function getToolDensityByTopic({ after }) {
+  return getDb().prepare(`
+    SELECT topic,
+           ROUND(AVG(CAST(tool_use_count AS REAL) / NULLIF(message_count / 2.0, 0)), 2) as density,
+           ROUND(AVG(message_count / 2.0), 0) as avgTurns,
+           ROUND(AVG(tool_use_count), 0) as avgTools
+    FROM sessions
+    WHERE start_time >= ? AND topic IS NOT NULL AND message_count > 0
+    GROUP BY topic
+    ORDER BY density DESC
+  `).all(after)
+}
+
+export function getTimeTopicHeatmap({ after }) {
+  return getDb().prepare(`
+    SELECT strftime('%H', start_time / 1000, 'unixepoch', '+8 hours') as hour,
+           topic,
+           COUNT(*) as count
+    FROM sessions
+    WHERE start_time >= ? AND topic IS NOT NULL
+    GROUP BY hour, topic
+    ORDER BY hour
+  `).all(after)
+}
+
+export function getOutlierSessions({ after }) {
+  return getDb().prepare(`
+    WITH avg_mc AS (
+      SELECT AVG(message_count) as v FROM sessions WHERE start_time >= ?
+    )
+    SELECT s.topic,
+           s.message_count  as messageCount,
+           s.first_user_msg as firstUserMsg,
+           s.start_time     as startTime
+    FROM sessions s, avg_mc
+    WHERE s.start_time >= ?
+      AND avg_mc.v > 0
+      AND s.message_count > avg_mc.v * 2
+      AND s.topic IS NOT NULL
+      AND s.first_user_msg IS NOT NULL
+      AND s.first_user_msg != ''
+    ORDER BY s.message_count DESC
+    LIMIT 50
+  `).all(after, after)
+}
+
+export function getProjectDist({ after }) {
+  return getDb().prepare(`
+    SELECT COALESCE(project_path, '未知') as project,
+           COUNT(*) as count,
+           ROUND(COUNT(*) * 100.0 / SUM(COUNT(*)) OVER (), 1) as pct
+    FROM sessions
+    WHERE start_time >= ?
+    GROUP BY project
+    ORDER BY count DESC
+    LIMIT 8
+  `).all(after)
+}
+
+export function getTopicKeywords({ after }) {
+  const rows = getDb().prepare(`
+    SELECT topic, topic_keywords
+    FROM sessions
+    WHERE start_time >= ? AND topic_keywords IS NOT NULL
+  `).all(after)
+
+  const freq = {}
+  const topicMap = {}
+  for (const r of rows) {
+    let words
+    try { words = JSON.parse(r.topic_keywords) } catch { continue }
+    for (const w of words) {
+      freq[w] = (freq[w] ?? 0) + 1
+      if (!topicMap[w]) topicMap[w] = r.topic
+    }
+  }
+
+  return Object.entries(freq)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 20)
+    .map(([word, count]) => ({ word, count, topic: topicMap[word] ?? '其他' }))
+}

package/src/db/schema.js

@@ -0,0 +1,46 @@
+export const CREATE_TABLES = `
+  CREATE TABLE IF NOT EXISTS sessions (
+    id            TEXT PRIMARY KEY,
+    source        TEXT NOT NULL DEFAULT 'claude-code',
+    start_time    INTEGER NOT NULL,
+    end_time      INTEGER,
+    duration_sec  INTEGER,
+    project_path  TEXT,
+    message_count INTEGER DEFAULT 0,
+    tool_use_count INTEGER DEFAULT 0,
+    jsonl_file    TEXT,
+    topic              TEXT,
+    topic_keywords     TEXT,
+    first_user_msg     TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS tools (
+    id                  TEXT PRIMARY KEY,
+    name                TEXT NOT NULL,
+    type                TEXT NOT NULL,
+    subtype             TEXT,
+    description         TEXT,
+    source_type         TEXT DEFAULT 'downloaded',
+    source_url          TEXT,
+    installed_at        INTEGER,
+    updated_at          INTEGER,
+    security_scan_result TEXT DEFAULT 'unscanned'
+  );
+
+  CREATE TABLE IF NOT EXISTS tool_invocations (
+    id         INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    tool_name  TEXT NOT NULL,
+    invoked_at INTEGER NOT NULL,
+    FOREIGN KEY (session_id) REFERENCES sessions(id)
+  );
+
+  CREATE TABLE IF NOT EXISTS meta (
+    key   TEXT PRIMARY KEY,
+    value TEXT
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_sessions_start ON sessions(start_time);
+  CREATE INDEX IF NOT EXISTS idx_invocations_tool ON tool_invocations(tool_name);
+  CREATE INDEX IF NOT EXISTS idx_invocations_session ON tool_invocations(session_id);
+`

package/src/indexer.js

@@ -0,0 +1,158 @@
+// src/indexer.js
+import fs from 'fs'
+import path from 'path'
+import { getClaudeDir, getExtraSessionDirs } from './config.js'
+import { parseJsonlFile } from './parsers/jsonl.js'
+import { parseSkillMd } from './parsers/skill-md.js'
+import { scanSkillSecurity } from './parsers/security.js'
+import { upsertSession, upsertTool, insertInvocations, getIndexedFiles, getFilesNeedingTopics, syncToolIds } from './db/queries.js'
+import { classifyTopic, extractKeywords } from './classifiers/topic-rules.js'
+import { getMeta, setMeta } from './db/db.js'
+
+function findAllJsonlFiles(claudeDir) {
+  const results = []
+  function walk(dir) {
+    if (!fs.existsSync(dir)) return
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) walk(full)
+      else if (entry.name.endsWith('.jsonl')) results.push(full)
+    }
+  }
+  // CLI 数据目录
+  walk(path.join(claudeDir, 'projects'))
+  // 桌面 App 额外目录（macOS），自动检测
+  for (const extraDir of getExtraSessionDirs()) {
+    walk(extraDir)
+  }
+  return results
+}
+
+function findAllTools(claudeDir) {
+  const tools = []
+  // Skills
+  const skillsDir = path.join(claudeDir, 'skills')
+  if (fs.existsSync(skillsDir)) {
+    for (const name of fs.readdirSync(skillsDir)) {
+      try {
+        const skillPath = path.join(skillsDir, name)
+        const stat = fs.statSync(skillPath)
+        if (!stat.isDirectory()) continue
+        const skillMd = path.join(skillPath, 'SKILL.md')
+        const meta = parseSkillMd(skillMd, name) ?? { name, description: '', type: 'skill', source: null }
+        const security = scanSkillSecurity(skillMd)
+        const toolType = ['skill', 'agent'].includes(meta.type) ? meta.type : 'skill'
+        const sourceType = meta.source ? 'downloaded' : 'self'
+        const sourceUrl  = meta.source ?? null
+        tools.push({ id: `${toolType}:${name}`, name: meta.name, type: toolType,
+          subtype: null, description: meta.description, sourceType, sourceUrl,
+          installedAt: stat.birthtimeMs, updatedAt: stat.mtimeMs,
+          securityScanResult: security })
+      } catch {}
+    }
+  }
+  // Plugins
+  const pluginsDir = path.join(claudeDir, 'plugins', 'cache')
+  if (fs.existsSync(pluginsDir)) {
+    for (const marketplace of fs.readdirSync(pluginsDir)) {
+      try {
+        const mDir = path.join(pluginsDir, marketplace)
+        if (!fs.statSync(mDir).isDirectory()) continue
+        const children = fs.readdirSync(mDir).filter(n => {
+          try { return fs.statSync(path.join(mDir, n)).isDirectory() } catch { return false }
+        })
+        if (children.length > 1) {
+          // 多子 plugin（如 knowledge-work-plugins）→ 以 marketplace 为整体注册
+          const stat = fs.statSync(mDir)
+          tools.push({ id: `plugin:${marketplace}:${marketplace}`, name: marketplace,
+            type: 'plugin', subtype: null, description: '', sourceType: 'downloaded',
+            sourceUrl: null, installedAt: stat.birthtimeMs, updatedAt: stat.mtimeMs,
+            securityScanResult: 'unscanned' })
+        } else {
+          // 单 plugin（如 claude-plugins-official/superpowers）→ 以 pluginName 注册
+          for (const pluginName of children) {
+            try {
+              const stat = fs.statSync(path.join(mDir, pluginName))
+              tools.push({ id: `plugin:${marketplace}:${pluginName}`, name: pluginName,
+                type: 'plugin', subtype: null, description: '', sourceType: 'downloaded',
+                sourceUrl: null, installedAt: stat.birthtimeMs, updatedAt: stat.mtimeMs,
+                securityScanResult: 'unscanned' })
+            } catch {}
+          }
+        }
+      } catch {}
+    }
+  }
+  return tools
+}
+
+// 返回所有正在扫描的目录列表（用于空视图展示检测路径）
+export function getScanPaths() {
+  const claudeDir = getClaudeDir()
+  const dirs = [path.join(claudeDir, 'projects'), ...getExtraSessionDirs()]
+  return dirs
+}
+
+export async function indexJsonlFile(filePath) {
+  const result = parseJsonlFile(filePath)
+  if (!result) return
+
+  // 优先用第一条用户消息分类，匹配不到时用全量文本兜底
+  let topic = classifyTopic(result.firstUserMessage)
+  if (topic === '其他') topic = classifyTopic(result.allUserText)
+  const topicKeywords = extractKeywords(result.allUserText)
+
+  upsertSession({
+    ...result,
+    id: result.sessionId,
+    source: 'claude-code',
+    jsonlFile: filePath,
+    topic,
+    topicKeywords,
+    firstUserMsg: result.firstUserMessage ?? null,
+  })
+
+  if (result.invocations.length > 0) {
+    insertInvocations(result.invocations.map(inv => ({
+      sessionId: result.sessionId, ...inv
+    })))
+  }
+}
+
+// 只同步工具（skills/plugins），不重新索引 JSONL，速度快，每次启动都调用
+export function syncToolsOnly() {
+  const claudeDir = getClaudeDir()
+  const tools = findAllTools(claudeDir)
+  for (const tool of tools) upsertTool(tool)
+  syncToolIds(new Set(tools.map(t => t.id)))
+}
+
+export async function runFullIndex(onProgress) {
+  const claudeDir = getClaudeDir()
+  const files = findAllJsonlFiles(claudeDir)
+  const tools = findAllTools(claudeDir)
+
+  // Index tools first (fast)，并同步删除已不存在的工具记录
+  for (const tool of tools) upsertTool(tool)
+  syncToolIds(new Set(tools.map(t => t.id)))
+
+  // Index JSONL files with progress
+  // 同时处理：新文件 + 已索引但 topic 为 NULL 的文件（补分类）
+  const indexed = getIndexedFiles()
+  const needsTopics = getFilesNeedingTopics()
+  const toIndex = files.filter(f => !indexed.has(f) || needsTopics.has(f))
+  const total = toIndex.length
+
+  for (let i = 0; i < toIndex.length; i++) {
+    await indexJsonlFile(toIndex[i])
+    const pct = Math.round(((i + 1) / Math.max(total, 1)) * 100)
+    onProgress?.(pct)
+  }
+
+  if (total === 0) onProgress?.(100)
+  setMeta('last_full_index', Date.now().toString())
+}
+
+export async function runIncrementalIndex(filePath) {
+  await indexJsonlFile(filePath)
+}

package/src/parsers/jsonl.js

@@ -0,0 +1,70 @@
+import fs from 'fs'
+
+export function parseJsonlFile(filePath) {
+  const raw = fs.readFileSync(filePath, 'utf8')
+  const lines = raw.split('\n').filter(l => l.trim())
+
+  const records = []
+  for (const line of lines) {
+    try { records.push(JSON.parse(line)) } catch { /* skip */ }
+  }
+
+  const userMsgs = records.filter(r => r.type === 'user' && r.sessionId && r.timestamp)
+  if (userMsgs.length === 0) return null
+
+  const sessionId = userMsgs[0].sessionId
+  const timestamps = userMsgs.map(r => new Date(r.timestamp).getTime()).filter(Boolean).sort((a, b) => a - b)
+  const startTime = timestamps[0]
+  const endTime = timestamps[timestamps.length - 1]
+  const durationSec = Math.round((endTime - startTime) / 1000)
+  const projectPath = userMsgs[0].cwd ?? null
+  const messageCount = records.filter(r => r.type === 'user' || r.type === 'assistant').length
+
+  const invocations = []
+  for (const r of records) {
+    if (r.type !== 'assistant') continue
+    const content = r.message?.content ?? []
+    for (const block of content) {
+      if (block.type === 'tool_use' && block.name) {
+        // Skill 调用：用 input.skill 作为 toolName，保留真实 skill 名称
+        const toolName = block.name === 'Skill' && block.input?.skill
+          ? block.input.skill
+          : block.name
+        invocations.push({
+          toolName,
+          invokedAt: new Date(r.timestamp).getTime() || startTime,
+        })
+      }
+    }
+  }
+
+  // 提取用户消息文本（排除 tool_result 类型内容）
+  function extractText(msg) {
+    const content = msg.message?.content ?? msg.content ?? ''
+    if (typeof content === 'string') return content
+    if (Array.isArray(content)) {
+      return content
+        .filter(b => b.type === 'text')
+        .map(b => b.text ?? '')
+        .join(' ')
+    }
+    return ''
+  }
+
+  const userTextList = userMsgs.map(r => extractText(r)).filter(Boolean)
+  const firstUserMessage = userTextList[0] ?? ''
+  const allUserText = userTextList.join(' ')
+
+  return {
+    sessionId,
+    startTime,
+    endTime,
+    durationSec,
+    projectPath,
+    messageCount,
+    toolUseCount: invocations.length,
+    invocations,
+    firstUserMessage,
+    allUserText,
+  }
+}

package/src/parsers/security.js

@@ -0,0 +1,23 @@
+import fs from 'fs'
+
+const RED_FLAGS = [
+  /curl\s+https?:\/\/(?!raw\.githubusercontent\.com|api\.github\.com)/,
+  /wget\s+https?:\/\//,
+  /rm\s+-rf/,
+  /base64\s+--decode/,
+  /base64\s+-d/,
+  /eval\s*\(/,
+  /exec\s*\(/,
+  /\bsudo\b/,
+  /\~\/\.ssh/,
+  /\~\/\.aws/,
+]
+
+export function scanSkillSecurity(filePath) {
+  if (!fs.existsSync(filePath)) return 'unscanned'
+  const raw = fs.readFileSync(filePath, 'utf8')
+  for (const pattern of RED_FLAGS) {
+    if (pattern.test(raw)) return 'warning'
+  }
+  return 'safe'
+}

package/src/parsers/skill-md.js

@@ -0,0 +1,38 @@
+import fs from 'fs'
+
+export function parseSkillMd(filePath, fallbackName = '') {
+  if (!fs.existsSync(filePath)) return null
+  const raw = fs.readFileSync(filePath, 'utf8')
+
+  let name = fallbackName
+  let description = ''
+  let type = 'skill'
+  let source = null
+
+  const fmMatch = raw.match(/^---\n([\s\S]*?)\n---/)
+  if (fmMatch) {
+    const fm = fmMatch[1]
+    const nameMatch   = fm.match(/^name:\s*(.+)$/m)
+    const typeMatch   = fm.match(/^type:\s*(.+)$/m)
+    const sourceMatch = fm.match(/^source:\s*(.+)$/m)
+    if (nameMatch)   name   = nameMatch[1].trim()
+    if (typeMatch)   type   = typeMatch[1].trim()
+    if (sourceMatch) source = sourceMatch[1].trim()
+
+    // 支持 YAML block scalar（description: > 或 description: |）
+    const descInline = fm.match(/^description:\s*([^>|].+)$/m)
+    const descBlock  = fm.match(/^description:\s*[>|]\n((?:[ \t]+.+\n?)+)/m)
+    if (descInline) {
+      description = descInline[1].trim()
+    } else if (descBlock) {
+      description = descBlock[1]
+        .split('\n')
+        .map(l => l.trim())
+        .filter(Boolean)
+        .join(' ')
+        .trim()
+    }
+  }
+
+  return { name, description, type, source }
+}