team-anya-cli 0.1.0

package/packages/db/dist/client.js

@@ -0,0 +1,69 @@
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readFileSync, existsSync, mkdirSync } from 'node:fs';
+import Database from 'better-sqlite3';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import { migrate } from 'drizzle-orm/better-sqlite3/migrator';
+import * as schema from './schema/index.js';
+/**
+ * 获取 migrations 目录的绝对路径
+ *
+ * 兼容两种运行方式：
+ * - 源码运行（vitest/tsx）：import.meta.url → src/client.ts → src/migrations/
+ * - 编译后运行（node dist/）：import.meta.url → dist/client.js → 回溯到 src/migrations/
+ */
+function getMigrationsPath() {
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    // 优先尝试同级 migrations 目录（源码模式）
+    const sameLevelPath = resolve(currentDir, 'migrations');
+    if (existsSync(resolve(sameLevelPath, 'meta', '_journal.json'))) {
+        return sameLevelPath;
+    }
+    // 回溯到 src/migrations（编译后 dist/ 模式）
+    const srcPath = resolve(currentDir, '..', 'src', 'migrations');
+    if (existsSync(resolve(srcPath, 'meta', '_journal.json'))) {
+        return srcPath;
+    }
+    throw new Error(`找不到 migrations 目录，已尝试:\n  - ${sameLevelPath}\n  - ${srcPath}`);
+}
+/**
+ * 创建数据库连接并自动运行 migration
+ */
+export function createDB(dbPath) {
+    // 确保数据库文件所在目录存在
+    mkdirSync(dirname(dbPath), { recursive: true });
+    const sqlite = new Database(dbPath);
+    // 启用 WAL 模式（支持并发读）
+    sqlite.pragma('journal_mode = WAL');
+    sqlite.pragma('foreign_keys = ON');
+    const db = drizzle(sqlite, { schema });
+    // 自动运行 migration（幂等，已执行过的不会重复执行）
+    migrate(db, { migrationsFolder: getMigrationsPath() });
+    return db;
+}
+/**
+ * 创建内存数据库（测试用，直接从 migration SQL 建表）
+ */
+export function createTestDB() {
+    const sqlite = new Database(':memory:');
+    sqlite.pragma('foreign_keys = ON');
+    const db = drizzle(sqlite, { schema });
+    // 读取 migration SQL 直接执行（内存库不走 migration 元数据表）
+    const migrationsPath = getMigrationsPath();
+    const journalPath = resolve(migrationsPath, 'meta', '_journal.json');
+    const journal = JSON.parse(readFileSync(journalPath, 'utf-8'));
+    for (const entry of journal.entries) {
+        const sqlPath = resolve(migrationsPath, `${entry.tag}.sql`);
+        const sqlContent = readFileSync(sqlPath, 'utf-8');
+        // drizzle migration SQL 用 --> statement-breakpoint 分隔语句
+        const statements = sqlContent
+            .split('--> statement-breakpoint')
+            .map(s => s.trim())
+            .filter(Boolean);
+        for (const stmt of statements) {
+            sqlite.exec(stmt);
+        }
+    }
+    return db;
+}
+//# sourceMappingURL=client.js.map

package/packages/db/dist/index.js

@@ -0,0 +1,603 @@
+import { eq, desc, gte, like, and, sql, count, isNull, isNotNull } from 'drizzle-orm';
+import { tasks, taskClarifications, commitments, opportunities, auditEvents, orgMembers, orgOwnership, orgEscalationRules, communicationEvents, messageLog, traceSpans, chats, chatMembers, projects, projectRepos, ccSessions } from './schema/index.js';
+export { createDB, createTestDB } from './client.js';
+export * from './schema/index.js';
+// ── Task CRUD ──
+export function createTask(db, data) {
+    return db.insert(tasks).values(data).returning().get();
+}
+export function getTask(db, taskId) {
+    return db.select().from(tasks).where(eq(tasks.task_id, taskId)).get();
+}
+export function updateTask(db, taskId, data) {
+    return db.update(tasks)
+        .set({ ...data, updated_at: new Date().toISOString() })
+        .where(eq(tasks.task_id, taskId))
+        .returning()
+        .get();
+}
+export function getTasksByStatus(db, status) {
+    return db.select().from(tasks).where(eq(tasks.status, status)).orderBy(desc(tasks.created_at)).all();
+}
+export function getTasksByProject(db, projectId) {
+    return db.select().from(tasks).where(eq(tasks.project_id, projectId)).orderBy(desc(tasks.created_at)).all();
+}
+export function getAllTasks(db) {
+    return db.select().from(tasks).orderBy(desc(tasks.created_at)).all();
+}
+export function getTasksByAssignee(db, assignee) {
+    return db.select().from(tasks).where(eq(tasks.assignee, assignee)).orderBy(desc(tasks.created_at)).all();
+}
+export function getTasksByChatId(db, chatId) {
+    return db.select().from(tasks).where(eq(tasks.source_chat_id, chatId)).orderBy(desc(tasks.created_at)).all();
+}
+// ── Clarification CRUD ──
+export function addClarification(db, data) {
+    return db.insert(taskClarifications).values(data).returning().get();
+}
+export function getClarifications(db, taskId) {
+    return db.select().from(taskClarifications)
+        .where(eq(taskClarifications.task_id, taskId)).all();
+}
+export function answerClarification(db, id, answer, answeredBy) {
+    return db.update(taskClarifications)
+        .set({
+        answer,
+        answered_by: answeredBy,
+        answered_at: new Date().toISOString(),
+    })
+        .where(eq(taskClarifications.id, id))
+        .returning()
+        .get();
+}
+// ── Commitment CRUD ──
+export function createCommitment(db, data) {
+    return db.insert(commitments).values(data).returning().get();
+}
+export function getCommitment(db, id) {
+    return db.select().from(commitments).where(eq(commitments.id, id)).get();
+}
+export function getCommitmentByTask(db, taskId) {
+    return db.select().from(commitments).where(eq(commitments.task_id, taskId)).get();
+}
+export function getCommitmentsByTaskId(db, taskId) {
+    return db.select().from(commitments).where(eq(commitments.task_id, taskId)).all();
+}
+export function getActiveCommitments(db) {
+    return db.select().from(commitments).where(eq(commitments.status, 'active')).all();
+}
+export function getCommitmentsByStatus(db, status) {
+    return db.select().from(commitments).where(eq(commitments.status, status)).all();
+}
+export function getAllCommitments(db) {
+    return db.select().from(commitments).all();
+}
+export function updateCommitment(db, id, data) {
+    return db.update(commitments)
+        .set(data)
+        .where(eq(commitments.id, id))
+        .returning()
+        .get();
+}
+// ── Audit Events ──
+export function insertAuditEvent(db, data) {
+    return db.insert(auditEvents).values(data).returning().get();
+}
+export function getAuditEventsByTask(db, taskId) {
+    return db.select().from(auditEvents).where(eq(auditEvents.task_id, taskId)).all();
+}
+export function getAuditEventsByType(db, eventType) {
+    return db.select().from(auditEvents).where(eq(auditEvents.event_type, eventType)).all();
+}
+export function getAuditEventsByDate(db, date) {
+    return db.select().from(auditEvents).where(like(auditEvents.created_at, `${date}%`)).all();
+}
+// ── Opportunity ──
+export function createOpportunity(db, data) {
+    return db.insert(opportunities).values(data).returning().get();
+}
+export function getOpenOpportunities(db) {
+    return db.select().from(opportunities)
+        .where(eq(opportunities.status, 'detected'))
+        .all();
+}
+export function getOpportunity(db, id) {
+    return db.select().from(opportunities).where(eq(opportunities.id, id)).get();
+}
+export function getAllOpportunities(db) {
+    return db.select().from(opportunities).all();
+}
+export function getOpportunitiesByStatus(db, status) {
+    return db.select().from(opportunities).where(eq(opportunities.status, status)).all();
+}
+export function updateOpportunity(db, id, data) {
+    return db.update(opportunities)
+        .set(data)
+        .where(eq(opportunities.id, id))
+        .returning()
+        .get();
+}
+// ── Org ──
+export function getOrgMember(db, memberId) {
+    return db.select().from(orgMembers).where(eq(orgMembers.member_id, memberId)).get();
+}
+export function upsertOrgMember(db, data) {
+    const setFields = {
+        name: data.name,
+        updated_at: sql `(datetime('now'))`,
+    };
+    if (data.platform !== undefined)
+        setFields.platform = data.platform;
+    if (data.union_id !== undefined)
+        setFields.union_id = data.union_id;
+    if (data.user_id !== undefined)
+        setFields.user_id = data.user_id;
+    if (data.en_name !== undefined)
+        setFields.en_name = data.en_name;
+    if (data.email !== undefined)
+        setFields.email = data.email;
+    if (data.employee_no !== undefined)
+        setFields.employee_no = data.employee_no;
+    if (data.avatar_url !== undefined)
+        setFields.avatar_url = data.avatar_url;
+    if (data.metadata !== undefined)
+        setFields.metadata = data.metadata;
+    if (data.last_synced_at !== undefined)
+        setFields.last_synced_at = data.last_synced_at;
+    return db.insert(orgMembers)
+        .values({
+        member_id: data.member_id,
+        name: data.name,
+        platform: data.platform,
+        union_id: data.union_id,
+        user_id: data.user_id,
+        en_name: data.en_name,
+        email: data.email,
+        employee_no: data.employee_no,
+        avatar_url: data.avatar_url,
+        metadata: data.metadata,
+        last_synced_at: data.last_synced_at,
+    })
+        .onConflictDoUpdate({
+        target: orgMembers.member_id,
+        set: setFields,
+    })
+        .returning()
+        .get();
+}
+export function getOwnershipByTarget(db, target) {
+    return db.select().from(orgOwnership).where(eq(orgOwnership.target, target)).all();
+}
+export function getEscalationRules(db, scope = 'global') {
+    return db.select().from(orgEscalationRules)
+        .where(eq(orgEscalationRules.scope, scope))
+        .all();
+}
+// ── 统计 ──
+export function getTaskCountByStatus(db) {
+    const all = db.select().from(tasks).all();
+    const counts = {};
+    for (const task of all) {
+        counts[task.status] = (counts[task.status] || 0) + 1;
+    }
+    return counts;
+}
+// ── CommunicationEvent ──
+export function insertCommunicationEvent(db, data) {
+    return db.insert(communicationEvents).values(data).returning().get();
+}
+export function getRecentCommunicationEvents(db, limit = 50, since) {
+    if (since) {
+        return db.select().from(communicationEvents)
+            .where(gte(communicationEvents.created_at, since))
+            .orderBy(desc(communicationEvents.created_at))
+            .limit(limit)
+            .all();
+    }
+    return db.select().from(communicationEvents)
+        .orderBy(desc(communicationEvents.created_at))
+        .limit(limit)
+        .all();
+}
+/**
+ * 获取今日新建任务的最大序号（用于生成 task_id）
+ */
+export function getTodayMaxSequence(db) {
+    const today = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+    const all = db.select().from(tasks).all();
+    let max = 0;
+    for (const task of all) {
+        if (task.task_id.startsWith(`ANYA-${today}-`)) {
+            const seq = parseInt(task.task_id.split('-')[2], 10);
+            if (seq > max)
+                max = seq;
+        }
+    }
+    return max;
+}
+// ── MessageLog CRUD ──
+export function insertMessageLog(db, data) {
+    return db.insert(messageLog).values(data).returning().get();
+}
+export function getRecentMessages(db, opts = {}) {
+    const { limit = 50, offset = 0, direction, since, message_type, sender, receiver, chat_id, chat_type, sort: sortOrder } = opts;
+    const conditions = [];
+    if (direction)
+        conditions.push(eq(messageLog.direction, direction));
+    if (since)
+        conditions.push(gte(messageLog.created_at, since));
+    if (message_type)
+        conditions.push(eq(messageLog.message_type, message_type));
+    if (sender)
+        conditions.push(eq(messageLog.sender, sender));
+    if (receiver)
+        conditions.push(eq(messageLog.receiver, receiver));
+    if (chat_id)
+        conditions.push(eq(messageLog.chat_id, chat_id));
+    if (chat_type)
+        conditions.push(eq(messageLog.chat_type, chat_type));
+    const query = conditions.length > 0
+        ? db.select().from(messageLog).where(and(...conditions))
+        : db.select().from(messageLog);
+    const orderBy = sortOrder === 'asc' ? messageLog.created_at : desc(messageLog.created_at);
+    return query
+        .orderBy(orderBy)
+        .limit(limit)
+        .offset(offset)
+        .all();
+}
+export function getMessageStats(db) {
+    const today = new Date().toISOString().slice(0, 10);
+    const todayMessages = db.select().from(messageLog)
+        .where(gte(messageLog.created_at, today))
+        .all();
+    let inbound = 0;
+    let outbound = 0;
+    for (const msg of todayMessages) {
+        if (msg.direction === 'inbound')
+            inbound++;
+        else if (msg.direction === 'outbound')
+            outbound++;
+    }
+    return { today: today, inbound, outbound, total: inbound + outbound };
+}
+// ── Trace Spans CRUD ──
+export function insertTraceSpan(db, data) {
+    return db.insert(traceSpans).values(data).returning().get();
+}
+export function updateTraceSpan(db, spanId, data) {
+    return db.update(traceSpans)
+        .set(data)
+        .where(eq(traceSpans.span_id, spanId))
+        .returning()
+        .get();
+}
+export function getTraceSpans(db, traceId) {
+    return db.select().from(traceSpans)
+        .where(eq(traceSpans.trace_id, traceId))
+        .orderBy(traceSpans.started_at)
+        .all();
+}
+/**
+ * 查询 trace 列表（按根 span 聚合）
+ */
+export function listTraces(db, opts = {}) {
+    const limit = opts.limit ?? 50;
+    const offset = opts.offset ?? 0;
+    // 用子查询按 trace_id 聚合，取每个 trace 的根 span 信息
+    const conditions = [];
+    if (opts.operation) {
+        conditions.push(like(traceSpans.operation, `%${opts.operation}%`));
+    }
+    if (opts.status) {
+        conditions.push(eq(traceSpans.status, opts.status));
+    }
+    const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
+    // 查总数（按 trace_id 去重）
+    const countResult = db
+        .select({ count: sql `count(distinct ${traceSpans.trace_id})` })
+        .from(traceSpans)
+        .where(whereClause)
+        .get();
+    const total = countResult?.count ?? 0;
+    // 查列表：每个 trace_id 取聚合信息
+    const rows = db.all(sql `
+    SELECT
+      ${traceSpans.trace_id} as trace_id,
+      min(${traceSpans.started_at}) as started_at,
+      max(${traceSpans.ended_at}) as ended_at,
+      count(*) as span_count,
+      group_concat(distinct ${traceSpans.operation}) as operations,
+      CASE
+        WHEN sum(CASE WHEN ${traceSpans.status} = 'error' THEN 1 ELSE 0 END) > 0 THEN 'error'
+        WHEN sum(CASE WHEN ${traceSpans.status} = 'in_progress' THEN 1 ELSE 0 END) > 0 THEN 'in_progress'
+        ELSE 'success'
+      END as status,
+      CASE
+        WHEN max(${traceSpans.ended_at}) IS NOT NULL
+        THEN (julianday(max(${traceSpans.ended_at})) - julianday(min(${traceSpans.started_at}))) * 86400000
+        ELSE NULL
+      END as total_duration_ms
+    FROM ${traceSpans}
+    ${whereClause ? sql `WHERE ${whereClause}` : sql ``}
+    GROUP BY ${traceSpans.trace_id}
+    ORDER BY min(${traceSpans.started_at}) DESC
+    LIMIT ${limit}
+    OFFSET ${offset}
+  `);
+    return { data: rows, total };
+}
+export function getMessageLogById(db, id) {
+    return db.select().from(messageLog).where(eq(messageLog.id, id)).get();
+}
+export function getMessageLogBySourceRef(db, sourceRef) {
+    return db.select().from(messageLog).where(eq(messageLog.source_ref, sourceRef)).get();
+}
+// ── Chats CRUD ──
+export function upsertChat(db, data) {
+    return db.insert(chats)
+        .values(data)
+        .onConflictDoUpdate({
+        target: chats.chat_id,
+        set: {
+            name: data.name,
+            description: data.description,
+            avatar: data.avatar,
+            owner_id: data.owner_id,
+            chat_mode: data.chat_mode,
+            chat_type: data.chat_type,
+            chat_tag: data.chat_tag,
+            chat_status: data.chat_status,
+            external: data.external,
+            tenant_key: data.tenant_key,
+            user_count: data.user_count,
+            bot_count: data.bot_count,
+            metadata: data.metadata,
+            last_synced_at: data.last_synced_at,
+            updated_at: sql `(datetime('now'))`,
+        },
+    })
+        .returning()
+        .get();
+}
+export function getChat(db, chatId) {
+    return db.select().from(chats).where(eq(chats.chat_id, chatId)).get();
+}
+export function getAllChats(db, opts) {
+    const conditions = [];
+    if (opts?.platform)
+        conditions.push(eq(chats.platform, opts.platform));
+    if (opts?.chat_type)
+        conditions.push(eq(chats.chat_type, opts.chat_type));
+    if (opts?.name)
+        conditions.push(like(chats.name, `%${opts.name}%`));
+    const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
+    return db.select().from(chats).where(whereClause).orderBy(desc(chats.updated_at)).all();
+}
+export function getChatStats(db) {
+    const all = db.select().from(chats).all();
+    const byType = {};
+    for (const chat of all) {
+        const t = chat.chat_type ?? 'unknown';
+        byType[t] = (byType[t] || 0) + 1;
+    }
+    return { total: all.length, byType };
+}
+// ── Chat Members CRUD ──
+export function upsertChatMember(db, data) {
+    // 先查是否存在
+    const existing = db.select().from(chatMembers)
+        .where(and(eq(chatMembers.chat_id, data.chat_id), eq(chatMembers.member_id, data.member_id)))
+        .get();
+    if (existing) {
+        return db.update(chatMembers)
+            .set({ role: data.role ?? existing.role, synced_at: sql `(datetime('now'))` })
+            .where(eq(chatMembers.id, existing.id))
+            .returning()
+            .get();
+    }
+    return db.insert(chatMembers)
+        .values({ chat_id: data.chat_id, member_id: data.member_id, role: data.role ?? 'member' })
+        .returning()
+        .get();
+}
+export function getChatMembers(db, chatId) {
+    return db.select({
+        id: chatMembers.id,
+        chat_id: chatMembers.chat_id,
+        member_id: chatMembers.member_id,
+        role: chatMembers.role,
+        synced_at: chatMembers.synced_at,
+        name: orgMembers.name,
+        en_name: orgMembers.en_name,
+        email: orgMembers.email,
+        employee_no: orgMembers.employee_no,
+        avatar_url: orgMembers.avatar_url,
+        member_role: orgMembers.role,
+        team: orgMembers.team,
+    })
+        .from(chatMembers)
+        .innerJoin(orgMembers, eq(chatMembers.member_id, orgMembers.member_id))
+        .where(eq(chatMembers.chat_id, chatId))
+        .all();
+}
+export function getMemberChats(db, memberId) {
+    return db.select({
+        chat_id: chats.chat_id,
+        name: chats.name,
+        chat_type: chats.chat_type,
+        chat_tag: chats.chat_tag,
+        user_count: chats.user_count,
+        role: chatMembers.role,
+    })
+        .from(chatMembers)
+        .innerJoin(chats, eq(chatMembers.chat_id, chats.chat_id))
+        .where(eq(chatMembers.member_id, memberId))
+        .all();
+}
+export function removeChatMembers(db, chatId) {
+    return db.delete(chatMembers).where(eq(chatMembers.chat_id, chatId)).run();
+}
+export function getAllOrgMembers(db) {
+    return db.select().from(orgMembers).all();
+}
+// ── Projects CRUD ──
+export function upsertProject(db, data) {
+    return db.insert(projects)
+        .values(data)
+        .onConflictDoUpdate({
+        target: projects.project_id,
+        set: {
+            name: data.name,
+            description: data.description,
+            platform: data.platform,
+            claude_md: data.claude_md,
+            updated_at: sql `(datetime('now'))`,
+        },
+    })
+        .returning()
+        .get();
+}
+export function getProject(db, projectId, includeDeleted = false) {
+    const conditions = [eq(projects.project_id, projectId)];
+    if (!includeDeleted) {
+        conditions.push(isNull(projects.deleted_at));
+    }
+    return db.select().from(projects).where(and(...conditions)).get();
+}
+export function getAllProjects(db, includeDeleted = false) {
+    const where = includeDeleted ? undefined : isNull(projects.deleted_at);
+    return db.select().from(projects).where(where).orderBy(desc(projects.updated_at)).all();
+}
+export function softDeleteProject(db, projectId) {
+    return db.update(projects)
+        .set({ deleted_at: new Date().toISOString() })
+        .where(eq(projects.project_id, projectId))
+        .run();
+}
+// ── Project Repos CRUD ──
+export function upsertProjectRepo(db, data) {
+    return db.insert(projectRepos).values(data).returning().get();
+}
+export function getProjectRepos(db, projectId) {
+    return db.select().from(projectRepos)
+        .where(eq(projectRepos.project_id, projectId))
+        .all();
+}
+export function removeProjectRepos(db, projectId) {
+    return db.delete(projectRepos).where(eq(projectRepos.project_id, projectId)).run();
+}
+export function syncProjectRepos(db, projectId, repos) {
+    removeProjectRepos(db, projectId);
+    return repos.map(r => upsertProjectRepo(db, {
+        project_id: projectId,
+        name: r.name,
+        git_url: r.git_url ?? null,
+        repo_path: r.repo_path ?? null,
+        default_branch: r.default_branch ?? 'main',
+    }));
+}
+export function getProjectWithRepos(db, projectId) {
+    const project = getProject(db, projectId);
+    if (!project)
+        return null;
+    const repos = getProjectRepos(db, projectId);
+    return { ...project, repos };
+}
+// ── CC Sessions CRUD ──
+export function insertCCSession(db, data) {
+    return db.insert(ccSessions).values(data).returning().get();
+}
+export function getCCSessionsByTask(db, taskId) {
+    return db.select().from(ccSessions)
+        .where(eq(ccSessions.task_id, taskId))
+        .orderBy(desc(ccSessions.started_at))
+        .all();
+}
+export function getCCSessionBySessionId(db, sessionId) {
+    return db.select().from(ccSessions)
+        .where(eq(ccSessions.session_id, sessionId))
+        .get();
+}
+export function updateCCSessionEnded(db, sessionId) {
+    return db.update(ccSessions)
+        .set({ ended_at: new Date().toISOString() })
+        .where(eq(ccSessions.session_id, sessionId))
+        .returning()
+        .get();
+}
+export function getAllCCSessions(db, filters = {}) {
+    const conditions = [];
+    if (filters.role)
+        conditions.push(eq(ccSessions.role, filters.role));
+    if (filters.taskId)
+        conditions.push(eq(ccSessions.task_id, filters.taskId));
+    if (filters.chatId)
+        conditions.push(eq(ccSessions.chat_id, filters.chatId));
+    if (filters.active === true)
+        conditions.push(isNull(ccSessions.ended_at));
+    if (filters.active === false)
+        conditions.push(isNotNull(ccSessions.ended_at));
+    const where = conditions.length > 0 ? and(...conditions) : undefined;
+    const total = db.select({ count: count() }).from(ccSessions)
+        .where(where).get()?.count ?? 0;
+    const data = db.select().from(ccSessions)
+        .where(where)
+        .orderBy(desc(ccSessions.started_at))
+        .limit(filters.limit ?? 50)
+        .offset(filters.offset ?? 0)
+        .all();
+    return { data, total };
+}
+export function getCCSessionsByChat(db, chatId) {
+    return db.select().from(ccSessions)
+        .where(eq(ccSessions.chat_id, chatId))
+        .orderBy(desc(ccSessions.started_at))
+        .all();
+}
+export function getAllProjectsWithStats(db, includeDeleted = false) {
+    const where = includeDeleted ? undefined : isNull(projects.deleted_at);
+    const allProjects = db.select().from(projects).where(where).orderBy(desc(projects.updated_at)).all();
+    const allTasks = db.select({
+        project_id: tasks.project_id,
+        status: tasks.status,
+        updated_at: tasks.updated_at,
+    }).from(tasks).all();
+    // 每个项目的仓库数量
+    const allRepos = db.select({
+        project_id: projectRepos.project_id,
+    }).from(projectRepos).all();
+    const repoCountByProject = {};
+    for (const r of allRepos) {
+        repoCountByProject[r.project_id] = (repoCountByProject[r.project_id] || 0) + 1;
+    }
+    const tasksByProject = {};
+    for (const t of allTasks) {
+        if (!t.project_id)
+            continue;
+        if (!tasksByProject[t.project_id]) {
+            tasksByProject[t.project_id] = { total: 0, done: 0, in_progress: 0, blocked: 0, last_activity: null };
+        }
+        const stats = tasksByProject[t.project_id];
+        stats.total++;
+        if (t.status === 'DONE')
+            stats.done++;
+        else if (t.status === 'IN_PROGRESS')
+            stats.in_progress++;
+        else if (t.status === 'BLOCKED')
+            stats.blocked++;
+        if (!stats.last_activity || t.updated_at > stats.last_activity) {
+            stats.last_activity = t.updated_at;
+        }
+    }
+    return allProjects.map(p => ({
+        ...p,
+        repo_count: repoCountByProject[p.project_id] ?? 0,
+        task_count: tasksByProject[p.project_id]?.total ?? 0,
+        done_count: tasksByProject[p.project_id]?.done ?? 0,
+        in_progress_count: tasksByProject[p.project_id]?.in_progress ?? 0,
+        blocked_count: tasksByProject[p.project_id]?.blocked ?? 0,
+        last_activity_at: tasksByProject[p.project_id]?.last_activity ?? p.updated_at,
+    }));
+}
+//# sourceMappingURL=index.js.map

package/packages/db/dist/schema/audit-events.js

@@ -0,0 +1,13 @@
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
+import { sql } from 'drizzle-orm';
+export const auditEvents = sqliteTable('audit_events', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    event_type: text('event_type').notNull(),
+    actor: text('actor').notNull(),
+    task_id: text('task_id'),
+    summary: text('summary').notNull(),
+    detail: text('detail'), // JSON 字符串
+    file_ref: text('file_ref'),
+    created_at: text('created_at').notNull().default(sql `(datetime('now'))`),
+});
+//# sourceMappingURL=audit-events.js.map

package/packages/db/dist/schema/cc-sessions.js

@@ -0,0 +1,14 @@
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
+import { sql } from 'drizzle-orm';
+export const ccSessions = sqliteTable('cc_sessions', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    session_id: text('session_id').notNull(),
+    role: text('role').notNull(), // 'loid' | 'yor'
+    instance_id: text('instance_id'),
+    task_id: text('task_id'),
+    chat_id: text('chat_id'),
+    project_path: text('project_path'),
+    started_at: text('started_at').notNull().default(sql `(datetime('now'))`),
+    ended_at: text('ended_at'),
+});
+//# sourceMappingURL=cc-sessions.js.map