team-anya 0.2.0

package/packages/core/dist/types/communication.js

@@ -0,0 +1,18 @@
+/**
+ * @deprecated 此模块已废弃，改为 Agent 自主判断/使用 memory 系统。
+ * 保留此文件仅为兼容历史数据，新代码请勿使用。
+ */
+import { z } from 'zod';
+import { IntentLevel } from '../constants.js';
+export const communicationEventSchema = z.object({
+    id: z.number().optional(),
+    source_type: z.enum(['feishu', 'file']),
+    source_ref: z.string().nullable().optional(),
+    intent_level: z.nativeEnum(IntentLevel),
+    sender: z.string().nullable().optional(),
+    summary: z.string(),
+    raw_content_path: z.string().nullable().optional(),
+    opportunity_id: z.string().nullable().optional(),
+    created_at: z.string().datetime().optional(),
+});
+//# sourceMappingURL=communication.js.map

package/packages/core/dist/types/index.js

@@ -0,0 +1,9 @@
+export * from './task.js';
+export * from './commitment.js';
+export * from './opportunity.js';
+export * from './audit.js';
+export * from './communication.js';
+export * from './org.js';
+export * from './backend.js';
+export * from './workspace.js';
+//# sourceMappingURL=index.js.map

package/packages/core/dist/types/opportunity.js

@@ -0,0 +1,27 @@
+/**
+ * @deprecated 此模块已废弃，改为 Agent 自主判断/使用 memory 系统。
+ * 保留此文件仅为兼容历史数据，新代码请勿使用。
+ */
+import { z } from 'zod';
+import { OpportunityStatus } from '../constants.js';
+export const opportunityScoreSchema = z.object({
+    impact: z.number().min(0).max(1),
+    urgency: z.number().min(0).max(1),
+    feasibility: z.number().min(0).max(1),
+    permission: z.number().min(0).max(1),
+});
+export const opportunitySchema = z.object({
+    id: z.string(),
+    status: z.nativeEnum(OpportunityStatus).default('detected'),
+    source_ref: z.string().nullable().optional(),
+    summary: z.string(),
+    score_impact: z.number().nullable().optional(),
+    score_urgency: z.number().nullable().optional(),
+    score_feasibility: z.number().nullable().optional(),
+    score_permission: z.number().nullable().optional(),
+    total_score: z.number().nullable().optional(),
+    converted_task_id: z.string().nullable().optional(),
+    detected_at: z.string().datetime().optional(),
+    claimed_at: z.string().datetime().nullable().optional(),
+});
+//# sourceMappingURL=opportunity.js.map

package/packages/core/dist/types/org.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export const orgMemberSchema = z.object({
+    member_id: z.string(),
+    name: z.string(),
+    role: z.string().nullable().optional(),
+    team: z.string().nullable().optional(),
+    timezone: z.string().nullable().optional(),
+    profile_path: z.string().nullable().optional(),
+    response_pattern: z.string().nullable().optional(),
+    updated_at: z.string().datetime().optional(),
+});
+export const ownershipSchema = z.object({
+    id: z.number().optional(),
+    scope: z.enum(['repo', 'module']),
+    target: z.string(),
+    member_id: z.string(),
+    role: z.string().default('owner'),
+});
+export const escalationRuleSchema = z.object({
+    id: z.number().optional(),
+    scope: z.string().default('global'),
+    after_minutes: z.number(),
+    action: z.enum(['notify', 'escalate']),
+    targets: z.array(z.string()),
+});
+//# sourceMappingURL=org.js.map

package/packages/core/dist/types/task.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { TaskStatus } from '../constants.js';
+// ── Zod Schemas ──
+export const taskSourceSchema = z.object({
+    type: z.enum(['file', 'feishu', 'meeting_note', 'manual']),
+    ref: z.string().optional(),
+    received_at: z.string().datetime().optional(),
+});
+export const clarificationSchema = z.object({
+    id: z.number().optional(),
+    question: z.string(),
+    answer: z.string().nullable().optional(),
+    asked_by: z.string().default('loid'),
+    answered_by: z.string().nullable().optional(),
+    asked_at: z.string().datetime().optional(),
+    answered_at: z.string().datetime().nullable().optional(),
+});
+export const taskSchema = z.object({
+    task_id: z.string(),
+    title: z.string(),
+    status: z.nativeEnum(TaskStatus),
+    // 来源
+    source_type: z.enum(['file', 'feishu', 'meeting_note', 'manual']),
+    source_ref: z.string().nullable().optional(),
+    // 需求定义
+    objective: z.string().nullable().optional(),
+    acceptance_criteria: z.array(z.string()).optional(),
+    context: z.string().nullable().optional(),
+    // 执行指引
+    execution_guidance: z.string().nullable().optional(),
+    // 执行信息
+    project_id: z.string().nullable().optional(),
+    assignee: z.string().nullable().optional(),
+    deliverable_summary: z.string().nullable().optional(),
+    // 重试与阻塞
+    retry_count: z.number().default(0),
+    max_retries: z.number().default(3),
+    blocked_reason: z.string().nullable().optional(),
+    blocked_since: z.string().datetime().nullable().optional(),
+    // 文件路径
+    workspace_path: z.string().nullable().optional(),
+    // 时间戳
+    created_at: z.string().datetime().optional(),
+    updated_at: z.string().datetime().optional(),
+});
+//# sourceMappingURL=task.js.map

package/packages/core/dist/types/workspace.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export const WorkspaceStatus = {
+    ACTIVE: 'active',
+    ARCHIVED: 'archived',
+};
+export const WorkspaceRole = {
+    YOR: 'yor',
+    FRANKY: 'franky',
+};
+export const WorkspaceOwnerType = {
+    TASK: 'task',
+    TOPIC: 'topic',
+};
+// .workspace.json schema
+export const workspaceMetaSchema = z.object({
+    id: z.string(),
+    created_at: z.string(),
+    project_id: z.string().nullable(),
+    repos: z.array(z.object({
+        name: z.string(),
+        branch: z.string(),
+        clone_path: z.string(),
+        remote_url: z.string().optional(),
+    })),
+    current: z.object({
+        role: z.enum(['yor', 'franky']),
+        owner_type: z.enum(['task', 'topic']),
+        owner_id: z.string(),
+        since: z.string(),
+    }),
+    history: z.array(z.object({
+        role: z.enum(['yor', 'franky']),
+        owner_type: z.enum(['task', 'topic']),
+        owner_id: z.string(),
+        from: z.string(),
+        to: z.string(),
+    })),
+});
+//# sourceMappingURL=workspace.js.map

package/packages/core/dist/workspace-manager.js

@@ -0,0 +1,314 @@
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+import { mkdir, copyFile, writeFile, readFile, rm, unlink, stat, cp, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { workspaceMetaSchema } from './types/workspace.js';
+const execFile = promisify(execFileCb);
+// ── 角色文件映射 ──
+/** 所有角色共享的文档（从 templateDir 根复制） */
+const SHARED_DOCS = ['CHARTER.md', 'PROTOCOL.md', 'TOOLS.md'];
+/** 角色专属文件（从 templateDir/<role>/ 复制） */
+const ROLE_FILES = {
+    yor: ['CLAUDE.md', 'PROFILE.md', 'PLAYBOOK.md', 'SELF-HEAL.md'],
+    franky: ['CLAUDE.md', 'PROFILE.md', 'PLAYBOOK.md'],
+};
+/** Yor 独有的文件（切换到 franky 时需删除） */
+const YOR_ONLY_FILES = ['SELF-HEAL.md'];
+// ── WorkspaceManager ──
+export class WorkspaceManager {
+    store;
+    config;
+    repoCache;
+    constructor(store, config, repoCache) {
+        this.store = store;
+        this.config = config;
+        this.repoCache = repoCache;
+    }
+    /**
+     * 创建工作区：目录 + 共享文档 + 角色文件 + .workspace.json + DB 记录
+     */
+    async createWorkspace(opts) {
+        const id = `WS-${randomUUID().slice(0, 8)}`;
+        const wsPath = join(this.config.workspacesPath, opts.role, opts.ownerId);
+        // 创建目录结构
+        await mkdir(wsPath, { recursive: true });
+        await mkdir(join(wsPath, 'feedback'), { recursive: true });
+        await mkdir(join(wsPath, 'checkpoints'), { recursive: true });
+        // 复制共享文档
+        for (const doc of SHARED_DOCS) {
+            await this.safeCopy(join(this.config.templateDir, doc), join(wsPath, doc));
+        }
+        // 复制角色文件
+        await this.copyRoleFiles(wsPath, opts.role);
+        // 写 .workspace.json
+        const now = new Date().toISOString();
+        const meta = {
+            id,
+            created_at: now,
+            project_id: opts.projectId ?? null,
+            repos: [],
+            current: {
+                role: opts.role,
+                owner_type: opts.ownerType,
+                owner_id: opts.ownerId,
+                since: now,
+            },
+            history: [],
+        };
+        await writeFile(join(wsPath, '.workspace.json'), JSON.stringify(meta, null, 2));
+        // 写 DB
+        const row = this.store.create({
+            id,
+            path: wsPath,
+            project_id: opts.projectId ?? null,
+            current_role: opts.role,
+            current_owner_type: opts.ownerType,
+            current_owner_id: opts.ownerId,
+        });
+        this.config.logger?.info(`[WorkspaceManager] 工作区已创建: ${id} (${opts.role}/${opts.ownerType}/${opts.ownerId})`);
+        return row;
+    }
+    /**
+     * 在工作区内设置代码仓库：clone --local + 修正 remote + 创建任务分支
+     */
+    async setupRepo(workspaceId, opts) {
+        const ws = this.store.get(workspaceId);
+        if (!ws)
+            throw new Error(`工作区不存在: ${workspaceId}`);
+        const wsPath = ws.path;
+        const cloneDest = join(wsPath, opts.repoName);
+        const baseBranch = opts.baseBranch ?? 'main';
+        // 确保 repos/ 缓存新鲜
+        const cachedRepoPath = await this.repoCache.ensureRepo(opts.repoName, opts.gitUrl);
+        // clone --local（利用 hardlink 加速）
+        await execFile('git', [
+            'clone', '--local',
+            '--branch', baseBranch,
+            cachedRepoPath,
+            cloneDest,
+        ]);
+        // 修正 remote 指向真实远程（而非 repos/ 本地路径）
+        await execFile('git', ['-C', cloneDest, 'remote', 'set-url', 'origin', opts.remoteUrl]);
+        // 创建任务分支
+        await execFile('git', ['-C', cloneDest, 'checkout', '-b', opts.taskBranch]);
+        // 更新 .workspace.json
+        const meta = await this.readMeta(wsPath);
+        meta.repos.push({
+            name: opts.repoName,
+            branch: opts.taskBranch,
+            clone_path: cloneDest,
+            remote_url: opts.remoteUrl,
+        });
+        await this.writeMeta(wsPath, meta);
+        this.config.logger?.info(`[WorkspaceManager] 仓库已设置: ${opts.repoName} @ ${opts.taskBranch}`);
+    }
+    /**
+     * 切换工作区角色：替换角色文件 + 更新元数据 + 更新 DB
+     */
+    async switchRole(workspaceId, newRole) {
+        const ws = this.store.get(workspaceId);
+        if (!ws)
+            throw new Error(`工作区不存在: ${workspaceId}`);
+        const wsPath = ws.path;
+        const oldRole = ws.current_role;
+        if (oldRole === newRole)
+            return;
+        // 删除旧角色独有文件
+        if (oldRole === 'yor') {
+            for (const file of YOR_ONLY_FILES) {
+                await this.safeUnlink(join(wsPath, file));
+            }
+        }
+        // 复制新角色文件（覆盖同名文件）
+        await this.copyRoleFiles(wsPath, newRole);
+        // franky 需要 context.md
+        if (newRole === 'franky') {
+            const contextPath = join(wsPath, 'context.md');
+            if (!(await this.fileExists(contextPath))) {
+                await writeFile(contextPath, '# Topic Context\n\n> 从任务升级而来，请继续迭代。\n');
+            }
+        }
+        // 更新 .workspace.json
+        const now = new Date().toISOString();
+        const meta = await this.readMeta(wsPath);
+        meta.history.push({
+            role: meta.current.role,
+            owner_type: meta.current.owner_type,
+            owner_id: meta.current.owner_id,
+            from: meta.current.since,
+            to: now,
+        });
+        meta.current = {
+            ...meta.current,
+            role: newRole,
+            since: now,
+        };
+        await this.writeMeta(wsPath, meta);
+        // 更新 DB
+        this.store.update(workspaceId, { current_role: newRole });
+        this.config.logger?.info(`[WorkspaceManager] 角色切换: ${oldRole} → ${newRole} (${workspaceId})`);
+    }
+    /**
+     * Fork 工作区：从源工作区复制出独立的新工作区，应用新角色文件。
+     * 源工作区保持不变（可供审计）。
+     *
+     * repo 目录使用 git clone --local（hardlink 优化），其余文件直接复制。
+     */
+    async forkWorkspace(sourceId, opts) {
+        const src = this.store.get(sourceId);
+        if (!src)
+            throw new Error(`源工作区不存在: ${sourceId}`);
+        const newId = `WS-${randomUUID().slice(0, 8)}`;
+        const newPath = join(this.config.workspacesPath, opts.newRole, opts.ownerId);
+        // 读取源工作区元数据
+        const srcMeta = await this.readMeta(src.path);
+        // 创建新工作区目录
+        await mkdir(newPath, { recursive: true });
+        await mkdir(join(newPath, 'feedback'), { recursive: true });
+        await mkdir(join(newPath, 'checkpoints'), { recursive: true });
+        // 复制非 repo 文件（共享文档、brief.md 等）
+        const entries = await readdir(src.path, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcItem = join(src.path, entry.name);
+            const destItem = join(newPath, entry.name);
+            if (entry.isDirectory()) {
+                // repo 目录用 git clone --local（hardlink 优化）
+                const isRepo = srcMeta.repos.some(r => r.name === entry.name);
+                if (isRepo) {
+                    await execFile('git', ['clone', '--local', srcItem, destItem]);
+                    // remote 已经是正确的（源工作区已修正过）
+                    continue;
+                }
+                // feedback/checkpoints 等普通目录直接复制
+                if (entry.name !== '.git') {
+                    await cp(srcItem, destItem, { recursive: true });
+                }
+            }
+            else {
+                // 普通文件直接复制
+                await copyFile(srcItem, destItem);
+            }
+        }
+        // 覆盖角色文件为新角色
+        await this.copyRoleFiles(newPath, opts.newRole);
+        // 删除旧角色独有文件（如 Yor 的 SELF-HEAL.md）
+        if (src.current_role === 'yor' && opts.newRole !== 'yor') {
+            for (const file of YOR_ONLY_FILES) {
+                await this.safeUnlink(join(newPath, file));
+            }
+        }
+        // Franky 需要 context.md（如果源工作区没有的话）
+        if (opts.newRole === 'franky') {
+            const contextPath = join(newPath, 'context.md');
+            if (!(await this.fileExists(contextPath))) {
+                await writeFile(contextPath, '# Topic Context\n\n> 从任务升级而来，请继续迭代。\n');
+            }
+        }
+        // 写新的 .workspace.json
+        const now = new Date().toISOString();
+        const newMeta = {
+            id: newId,
+            created_at: now,
+            project_id: srcMeta.project_id,
+            repos: srcMeta.repos.map(r => ({
+                ...r,
+                clone_path: join(newPath, r.name),
+            })),
+            current: {
+                role: opts.newRole,
+                owner_type: opts.ownerType,
+                owner_id: opts.ownerId,
+                since: now,
+            },
+            history: [],
+        };
+        await this.writeMeta(newPath, newMeta);
+        // 写 DB
+        const row = this.store.create({
+            id: newId,
+            path: newPath,
+            project_id: src.project_id,
+            current_role: opts.newRole,
+            current_owner_type: opts.ownerType,
+            current_owner_id: opts.ownerId,
+            parent_workspace_id: sourceId,
+        });
+        // 源工作区标记为 handed_off
+        this.store.update(sourceId, { status: 'handed_off' });
+        this.config.logger?.info(`[WorkspaceManager] 工作区 fork: ${sourceId} → ${newId} (${src.current_role} → ${opts.newRole})`);
+        return row;
+    }
+    /** 获取工作区记录 */
+    getWorkspace(id) {
+        return this.store.get(id);
+    }
+    /** 按 owner 查找工作区 */
+    findByOwner(ownerId) {
+        return this.store.findByOwner(ownerId);
+    }
+    /** 变更工作区 owner（task → topic 等场景） */
+    updateWorkspaceOwner(id, ownerType, ownerId) {
+        this.store.update(id, { current_owner_type: ownerType, current_owner_id: ownerId });
+        this.config.logger?.info(`[WorkspaceManager] owner 变更: ${ownerType}/${ownerId} (${id})`);
+    }
+    /**
+     * 归档工作区：标记 archived + 删除目录
+     */
+    async archiveWorkspace(id) {
+        const ws = this.store.get(id);
+        if (!ws)
+            throw new Error(`工作区不存在: ${id}`);
+        // 更新 DB 状态
+        this.store.update(id, { status: 'archived' });
+        // 删除目录
+        await rm(ws.path, { recursive: true, force: true });
+        this.config.logger?.info(`[WorkspaceManager] 工作区已归档: ${id}`);
+    }
+    // ── Private helpers ──
+    async copyRoleFiles(wsPath, role) {
+        const files = ROLE_FILES[role] ?? [];
+        for (const file of files) {
+            await this.safeCopy(join(this.config.templateDir, role, file), join(wsPath, file));
+        }
+    }
+    async safeCopy(src, dest) {
+        try {
+            await copyFile(src, dest);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                this.config.logger?.info(`[WorkspaceManager] 模板文件不存在，跳过: ${src}`);
+                return;
+            }
+            throw err;
+        }
+    }
+    async safeUnlink(path) {
+        try {
+            await unlink(path);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return;
+            throw err;
+        }
+    }
+    async readMeta(wsPath) {
+        const raw = await readFile(join(wsPath, '.workspace.json'), 'utf-8');
+        return workspaceMetaSchema.parse(JSON.parse(raw));
+    }
+    async writeMeta(wsPath, meta) {
+        await writeFile(join(wsPath, '.workspace.json'), JSON.stringify(meta, null, 2));
+    }
+    async fileExists(path) {
+        try {
+            await stat(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=workspace-manager.js.map

package/packages/core/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@team-anya/core",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "zod": "^3.24.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