intention-coding 0.3.7 → 0.4.0

package/bin/intention-coding.cjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+// 入口文件，加载编译后的主模块
+require('../dist/index.cjs');

package/dist/db/file-storage.js

@@ -0,0 +1,638 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dbOperations = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../utils/logger");
+const config_1 = require("../utils/config");
+class FileStorage {
+    constructor() {
+        try {
+            const storageDir = (0, config_1.getStorageDir)();
+            this.dataDir = path.join(storageDir, "api-test");
+            this.plansFile = path.join(this.dataDir, "test-plans.json");
+            this.tasksFile = path.join(this.dataDir, "test-tasks.json");
+            // 需求管理数据目录
+            this.requirementDataDir = path.join(storageDir, "requirements");
+            this.projectsFile = path.join(this.requirementDataDir, "projects.json");
+            this.analysesFile = path.join(this.requirementDataDir, "analyses.json");
+            this.requirementItemsFile = path.join(this.requirementDataDir, "requirement-items.json");
+            this.validationsFile = path.join(this.requirementDataDir, "validations.json");
+            // 代码生成数据目录
+            this.codeGenerationDataDir = path.join(storageDir, "code-generation");
+            this.codeSessionsFile = path.join(this.codeGenerationDataDir, "sessions.json");
+            this.codeTasksFile = path.join(this.codeGenerationDataDir, "tasks.json");
+            this.ensureDataDir();
+        }
+        catch (error) {
+            console.warn("FileStorage初始化失败，使用默认路径:", error);
+            // 使用默认路径
+            const defaultDir = path.join(process.cwd(), ".aico");
+            this.dataDir = path.join(defaultDir, "api-test");
+            this.plansFile = path.join(this.dataDir, "test-plans.json");
+            this.tasksFile = path.join(this.dataDir, "test-tasks.json");
+            this.requirementDataDir = path.join(defaultDir, "requirements");
+            this.projectsFile = path.join(this.requirementDataDir, "projects.json");
+            this.analysesFile = path.join(this.requirementDataDir, "analyses.json");
+            this.requirementItemsFile = path.join(this.requirementDataDir, "requirement-items.json");
+            this.validationsFile = path.join(this.requirementDataDir, "validations.json");
+            this.codeGenerationDataDir = path.join(defaultDir, "code-generation");
+            this.codeSessionsFile = path.join(this.codeGenerationDataDir, "sessions.json");
+            this.codeTasksFile = path.join(this.codeGenerationDataDir, "tasks.json");
+            this.ensureDataDir();
+        }
+    }
+    ensureDataDir() {
+        // API测试数据目录
+        if (!fs.existsSync(this.dataDir)) {
+            fs.mkdirSync(this.dataDir, { recursive: true });
+        }
+        // Initialize API test files if they don't exist
+        if (!fs.existsSync(this.plansFile)) {
+            fs.writeFileSync(this.plansFile, "[]", "utf8");
+        }
+        if (!fs.existsSync(this.tasksFile)) {
+            fs.writeFileSync(this.tasksFile, "[]", "utf8");
+        }
+        // 需求管理数据目录
+        if (!fs.existsSync(this.requirementDataDir)) {
+            fs.mkdirSync(this.requirementDataDir, { recursive: true });
+        }
+        // Initialize requirement files if they don't exist
+        if (!fs.existsSync(this.projectsFile)) {
+            fs.writeFileSync(this.projectsFile, "[]", "utf8");
+        }
+        if (!fs.existsSync(this.analysesFile)) {
+            fs.writeFileSync(this.analysesFile, "[]", "utf8");
+        }
+        if (!fs.existsSync(this.requirementItemsFile)) {
+            fs.writeFileSync(this.requirementItemsFile, "[]", "utf8");
+        }
+        if (!fs.existsSync(this.validationsFile)) {
+            fs.writeFileSync(this.validationsFile, "[]", "utf8");
+        }
+        // 代码生成数据目录
+        if (!fs.existsSync(this.codeGenerationDataDir)) {
+            fs.mkdirSync(this.codeGenerationDataDir, { recursive: true });
+        }
+        // Initialize code generation files if they don't exist
+        if (!fs.existsSync(this.codeSessionsFile)) {
+            fs.writeFileSync(this.codeSessionsFile, "[]", "utf8");
+        }
+        if (!fs.existsSync(this.codeTasksFile)) {
+            fs.writeFileSync(this.codeTasksFile, "[]", "utf8");
+        }
+    }
+    readPlans() {
+        try {
+            const data = fs.readFileSync(this.plansFile, "utf8");
+            return JSON.parse(data).map((p) => (Object.assign(Object.assign({}, p), { createdAt: new Date(p.createdAt), updatedAt: new Date(p.updatedAt) })));
+        }
+        catch (error) {
+            logger_1.logger.error("Error reading plans file", error);
+            return [];
+        }
+    }
+    writePlans(plans) {
+        fs.writeFileSync(this.plansFile, JSON.stringify(plans, null, 2), "utf8");
+    }
+    readTasks() {
+        try {
+            const data = fs.readFileSync(this.tasksFile, "utf8");
+            return JSON.parse(data).map((t) => (Object.assign(Object.assign({}, t), { createdAt: new Date(t.createdAt), updatedAt: new Date(t.updatedAt) })));
+        }
+        catch (error) {
+            logger_1.logger.error("Error reading tasks file", error);
+            return [];
+        }
+    }
+    writeTasks(tasks) {
+        fs.writeFileSync(this.tasksFile, JSON.stringify(tasks, null, 2), "utf8");
+    }
+    getNextId(items) {
+        return items.length > 0 ? Math.max(...items.map(i => i.id)) + 1 : 1;
+    }
+    // Test Plan operations
+    createTestPlan(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const plans = this.readPlans();
+            const newPlan = {
+                id: this.getNextId(plans),
+                uuid: data.uuid,
+                name: data.name,
+                status: data.status || "pending",
+                completed: false,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            plans.push(newPlan);
+            this.writePlans(plans);
+            return [newPlan];
+        });
+    }
+    getTestPlan(uuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const plans = this.readPlans();
+            return plans.filter(p => p.uuid === uuid);
+        });
+    }
+    getAllTestPlans() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.readPlans();
+        });
+    }
+    updateTestPlan(uuid, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const plans = this.readPlans();
+            const planIndex = plans.findIndex(p => p.uuid === uuid);
+            if (planIndex >= 0) {
+                plans[planIndex] = Object.assign(Object.assign(Object.assign({}, plans[planIndex]), data), { updatedAt: new Date() });
+                this.writePlans(plans);
+            }
+        });
+    }
+    // Test Task operations
+    createTestTask(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tasks = this.readTasks();
+            const newTask = {
+                id: this.getNextId(tasks),
+                uuid: data.uuid,
+                tableUuid: data.tableUuid,
+                url: data.url,
+                method: data.method || "GET",
+                query: data.query,
+                headers: data.headers,
+                body: data.body,
+                hopeRes: data.hopeRes,
+                status: "pending",
+                completed: false,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            tasks.push(newTask);
+            this.writeTasks(tasks);
+            return [newTask];
+        });
+    }
+    getTestTask(uuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tasks = this.readTasks();
+            return tasks.filter(t => t.uuid === uuid);
+        });
+    }
+    getTestTasksByPlan(tableUuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tasks = this.readTasks();
+            return tasks.filter(t => t.tableUuid === tableUuid);
+        });
+    }
+    updateTestTask(uuid, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tasks = this.readTasks();
+            const taskIndex = tasks.findIndex(t => t.uuid === uuid);
+            if (taskIndex >= 0) {
+                tasks[taskIndex] = Object.assign(Object.assign(Object.assign({}, tasks[taskIndex]), data), { updatedAt: new Date() });
+                this.writeTasks(tasks);
+            }
+        });
+    }
+    batchUpdateTaskSummaries(updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tasks = this.readTasks();
+            let updated = false;
+            for (const update of updates) {
+                const taskIndex = tasks.findIndex(t => t.uuid === update.uuid);
+                if (taskIndex >= 0) {
+                    tasks[taskIndex] = Object.assign(Object.assign({}, tasks[taskIndex]), { review: update.summary, suggest: update.suggest, completed: true, updatedAt: new Date() });
+                    updated = true;
+                }
+            }
+            if (updated) {
+                this.writeTasks(tasks);
+            }
+        });
+    }
+    // ==================== 需求管理相关方法 ====================
+    // 项目管理
+    readProjects() {
+        try {
+            const data = fs.readFileSync(this.projectsFile, "utf8");
+            return JSON.parse(data).map((p) => (Object.assign(Object.assign({}, p), { createdAt: new Date(p.createdAt), updatedAt: new Date(p.updatedAt) })));
+        }
+        catch (error) {
+            logger_1.logger.error("Error reading projects file", error);
+            return [];
+        }
+    }
+    writeProjects(projects) {
+        fs.writeFileSync(this.projectsFile, JSON.stringify(projects, null, 2), "utf8");
+    }
+    createRequirementProject(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projects = this.readProjects();
+            const newProject = {
+                id: this.getNextId(projects),
+                uuid: data.uuid,
+                name: data.name,
+                description: data.description,
+                status: "planning",
+                priority: data.priority || "medium",
+                stakeholders: data.stakeholders,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            projects.push(newProject);
+            this.writeProjects(projects);
+            return newProject;
+        });
+    }
+    getRequirementProject(uuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projects = this.readProjects();
+            return projects.find(p => p.uuid === uuid) || null;
+        });
+    }
+    getAllRequirementProjects() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.readProjects();
+        });
+    }
+    updateRequirementProject(uuid, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projects = this.readProjects();
+            const projectIndex = projects.findIndex(p => p.uuid === uuid);
+            if (projectIndex >= 0) {
+                projects[projectIndex] = Object.assign(Object.assign(Object.assign({}, projects[projectIndex]), data), { updatedAt: new Date() });
+                this.writeProjects(projects);
+            }
+        });
+    }
+    // 分析管理
+    readAnalyses() {
+        try {
+            const data = fs.readFileSync(this.analysesFile, "utf8");
+            return JSON.parse(data).map((a) => (Object.assign(Object.assign({}, a), { createdAt: new Date(a.createdAt), updatedAt: new Date(a.updatedAt) })));
+        }
+        catch (error) {
+            logger_1.logger.error("Error reading analyses file", error);
+            return [];
+        }
+    }
+    writeAnalyses(analyses) {
+        fs.writeFileSync(this.analysesFile, JSON.stringify(analyses, null, 2), "utf8");
+    }
+    createRequirementAnalysis(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const analyses = this.readAnalyses();
+            const newAnalysis = {
+                id: this.getNextId(analyses),
+                uuid: data.uuid,
+                projectUuid: data.projectUuid,
+                analysisType: data.analysisType,
+                title: data.title,
+                content: data.content,
+                originalInput: data.originalInput,
+                analysisParams: data.analysisParams,
+                filePath: data.filePath,
+                status: "completed",
+                version: 1,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            analyses.push(newAnalysis);
+            this.writeAnalyses(analyses);
+            return newAnalysis;
+        });
+    }
+    getRequirementAnalyses(projectUuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const analyses = this.readAnalyses();
+            return analyses.filter(a => a.projectUuid === projectUuid);
+        });
+    }
+    getRequirementAnalysis(uuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const analyses = this.readAnalyses();
+            return analyses.find(a => a.uuid === uuid) || null;
+        });
+    }
+    // 需求条目管理
+    readRequirementItems() {
+        try {
+            const data = fs.readFileSync(this.requirementItemsFile, "utf8");
+            return JSON.parse(data).map((r) => (Object.assign(Object.assign({}, r), { createdAt: new Date(r.createdAt), updatedAt: new Date(r.updatedAt) })));
+        }
+        catch (error) {
+            logger_1.logger.error("Error reading requirement items file", error);
+            return [];
+        }
+    }
+    writeRequirementItems(items) {
+        fs.writeFileSync(this.requirementItemsFile, JSON.stringify(items, null, 2), "utf8");
+    }
+    createRequirementItem(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const items = this.readRequirementItems();
+            const newItem = {
+                id: this.getNextId(items),
+                uuid: data.uuid,
+                projectUuid: data.projectUuid,
+                analysisUuid: data.analysisUuid,
+                type: data.type,
+                category: data.category,
+                title: data.title,
+                description: data.description,
+                priority: data.priority || "should",
+                status: "draft",
+                acceptanceCriteria: data.acceptanceCriteria,
+                dependencies: data.dependencies,
+                estimatedEffort: data.estimatedEffort,
+                assignee: data.assignee,
+                tags: data.tags,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            items.push(newItem);
+            this.writeRequirementItems(items);
+            return newItem;
+        });
+    }
+    getRequirementItems(projectUuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const items = this.readRequirementItems();
+            return items.filter(r => r.projectUuid === projectUuid);
+        });
+    }
+    updateRequirementItem(uuid, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const items = this.readRequirementItems();
+            const itemIndex = items.findIndex(r => r.uuid === uuid);
+            if (itemIndex >= 0) {
+                items[itemIndex] = Object.assign(Object.assign(Object.assign({}, items[itemIndex]), data), { updatedAt: new Date() });
+                this.writeRequirementItems(items);
+            }
+        });
+    }
+    // 验证管理
+    readValidations() {
+        try {
+            const data = fs.readFileSync(this.validationsFile, "utf8");
+            return JSON.parse(data).map((v) => (Object.assign(Object.assign({}, v), { createdAt: new Date(v.createdAt), updatedAt: new Date(v.updatedAt) })));
+        }
+        catch (error) {
+            logger_1.logger.error("Error reading validations file", error);
+            return [];
+        }
+    }
+    writeValidations(validations) {
+        fs.writeFileSync(this.validationsFile, JSON.stringify(validations, null, 2), "utf8");
+    }
+    createRequirementValidation(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validations = this.readValidations();
+            const newValidation = {
+                id: this.getNextId(validations),
+                uuid: data.uuid,
+                requirementUuid: data.requirementUuid,
+                validationType: data.validationType,
+                status: data.status,
+                issues: data.issues,
+                suggestions: data.suggestions,
+                validatedBy: data.validatedBy,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            validations.push(newValidation);
+            this.writeValidations(validations);
+            return newValidation;
+        });
+    }
+    getRequirementValidations(requirementUuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validations = this.readValidations();
+            return validations.filter(v => v.requirementUuid === requirementUuid);
+        });
+    }
+    initCodeGenerationStorage() {
+        this.codeGenerationDataDir = path.join((0, config_1.getStorageDir)(), "code-generation");
+        this.codeSessionsFile = path.join(this.codeGenerationDataDir, "sessions.json");
+        this.codeTasksFile = path.join(this.codeGenerationDataDir, "tasks.json");
+        if (!fs.existsSync(this.codeGenerationDataDir)) {
+            fs.mkdirSync(this.codeGenerationDataDir, { recursive: true });
+        }
+        if (!fs.existsSync(this.codeSessionsFile)) {
+            fs.writeFileSync(this.codeSessionsFile, "[]", "utf8");
+        }
+        if (!fs.existsSync(this.codeTasksFile)) {
+            fs.writeFileSync(this.codeTasksFile, "[]", "utf8");
+        }
+    }
+    readCodeSessions() {
+        try {
+            if (!fs.existsSync(this.codeSessionsFile)) {
+                this.initCodeGenerationStorage();
+                return [];
+            }
+            const data = fs.readFileSync(this.codeSessionsFile, "utf8");
+            return JSON.parse(data).map((s) => (Object.assign(Object.assign({}, s), { createdAt: new Date(s.createdAt), updatedAt: new Date(s.updatedAt), startedAt: s.startedAt ? new Date(s.startedAt) : undefined, completedAt: s.completedAt ? new Date(s.completedAt) : undefined })));
+        }
+        catch (error) {
+            logger_1.logger.error("Error reading code sessions file", error);
+            return [];
+        }
+    }
+    writeCodeSessions(sessions) {
+        if (!fs.existsSync(this.codeGenerationDataDir)) {
+            this.initCodeGenerationStorage();
+        }
+        fs.writeFileSync(this.codeSessionsFile, JSON.stringify(sessions, null, 2), "utf8");
+    }
+    readCodeTasks() {
+        try {
+            if (!fs.existsSync(this.codeTasksFile)) {
+                this.initCodeGenerationStorage();
+                return [];
+            }
+            const data = fs.readFileSync(this.codeTasksFile, "utf8");
+            return JSON.parse(data).map((t) => (Object.assign(Object.assign({}, t), { createdAt: new Date(t.createdAt), updatedAt: new Date(t.updatedAt), startedAt: t.startedAt ? new Date(t.startedAt) : undefined, completedAt: t.completedAt ? new Date(t.completedAt) : undefined })));
+        }
+        catch (error) {
+            logger_1.logger.error("Error reading code tasks file", error);
+            return [];
+        }
+    }
+    writeCodeTasks(tasks) {
+        if (!fs.existsSync(this.codeGenerationDataDir)) {
+            this.initCodeGenerationStorage();
+        }
+        fs.writeFileSync(this.codeTasksFile, JSON.stringify(tasks, null, 2), "utf8");
+    }
+    createCodeGenerationSession(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessions = this.readCodeSessions();
+            const newSession = {
+                id: this.getNextId(sessions),
+                uuid: data.uuid,
+                sessionId: data.sessionId,
+                taskTitle: data.taskTitle,
+                taskDescription: data.taskDescription,
+                projectName: data.projectName,
+                programmingLanguage: data.programmingLanguage,
+                framework: data.framework,
+                featureType: data.featureType,
+                priority: data.priority,
+                userStory: data.userStory,
+                acceptanceCriteria: JSON.stringify(data.acceptanceCriteria),
+                technicalRequirements: data.technicalRequirements,
+                testRequirements: data.testRequirements,
+                customContext: data.customContext,
+                sessionDir: data.sessionDir,
+                status: "pending",
+                generatedFiles: 0,
+                totalDuration: 0,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            sessions.push(newSession);
+            this.writeCodeSessions(sessions);
+            return newSession;
+        });
+    }
+    getCodeGenerationSession(uuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessions = this.readCodeSessions();
+            return sessions.find(s => s.uuid === uuid) || null;
+        });
+    }
+    getAllCodeGenerationSessions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.readCodeSessions();
+        });
+    }
+    updateCodeGenerationSession(uuid, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessions = this.readCodeSessions();
+            const sessionIndex = sessions.findIndex(s => s.uuid === uuid);
+            if (sessionIndex >= 0) {
+                sessions[sessionIndex] = Object.assign(Object.assign(Object.assign({}, sessions[sessionIndex]), data), { updatedAt: new Date() });
+                this.writeCodeSessions(sessions);
+            }
+        });
+    }
+    createCodeGenerationTask(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tasks = this.readCodeTasks();
+            const newTask = {
+                id: this.getNextId(tasks),
+                uuid: data.uuid,
+                sessionUuid: data.sessionUuid,
+                taskType: data.taskType,
+                taskName: data.taskName,
+                description: data.description,
+                inputData: data.inputData,
+                outputPath: data.outputPath,
+                fileSize: data.fileSize,
+                status: "pending",
+                duration: 0,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            tasks.push(newTask);
+            this.writeCodeTasks(tasks);
+            return newTask;
+        });
+    }
+    getCodeGenerationTasksBySession(sessionUuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tasks = this.readCodeTasks();
+            return tasks.filter(t => t.sessionUuid === sessionUuid);
+        });
+    }
+    updateCodeGenerationTask(uuid, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tasks = this.readCodeTasks();
+            const taskIndex = tasks.findIndex(t => t.uuid === uuid);
+            if (taskIndex >= 0) {
+                tasks[taskIndex] = Object.assign(Object.assign(Object.assign({}, tasks[taskIndex]), data), { updatedAt: new Date() });
+                this.writeCodeTasks(tasks);
+            }
+        });
+    }
+}
+const storage = new FileStorage();
+exports.dbOperations = {
+    // API测试相关
+    createTestPlan: storage.createTestPlan.bind(storage),
+    getTestPlan: storage.getTestPlan.bind(storage),
+    getAllTestPlans: storage.getAllTestPlans.bind(storage),
+    updateTestPlan: storage.updateTestPlan.bind(storage),
+    createTestTask: storage.createTestTask.bind(storage),
+    getTestTask: storage.getTestTask.bind(storage),
+    getTestTasksByPlan: storage.getTestTasksByPlan.bind(storage),
+    updateTestTask: storage.updateTestTask.bind(storage),
+    batchUpdateTaskSummaries: storage.batchUpdateTaskSummaries.bind(storage),
+    // 需求管理相关
+    createRequirementProject: storage.createRequirementProject.bind(storage),
+    getRequirementProject: storage.getRequirementProject.bind(storage),
+    getAllRequirementProjects: storage.getAllRequirementProjects.bind(storage),
+    updateRequirementProject: storage.updateRequirementProject.bind(storage),
+    createRequirementAnalysis: storage.createRequirementAnalysis.bind(storage),
+    getRequirementAnalyses: storage.getRequirementAnalyses.bind(storage),
+    getRequirementAnalysis: storage.getRequirementAnalysis.bind(storage),
+    createRequirementItem: storage.createRequirementItem.bind(storage),
+    getRequirementItems: storage.getRequirementItems.bind(storage),
+    updateRequirementItem: storage.updateRequirementItem.bind(storage),
+    createRequirementValidation: storage.createRequirementValidation.bind(storage),
+    getRequirementValidations: storage.getRequirementValidations.bind(storage),
+    // 代码生成相关
+    createCodeGenerationSession: storage.createCodeGenerationSession.bind(storage),
+    getCodeGenerationSession: storage.getCodeGenerationSession.bind(storage),
+    getAllCodeGenerationSessions: storage.getAllCodeGenerationSessions.bind(storage),
+    updateCodeGenerationSession: storage.updateCodeGenerationSession.bind(storage),
+    createCodeGenerationTask: storage.createCodeGenerationTask.bind(storage),
+    getCodeGenerationTasksBySession: storage.getCodeGenerationTasksBySession.bind(storage),
+    updateCodeGenerationTask: storage.updateCodeGenerationTask.bind(storage)
+};