@bicorne/task-flow 0.1.0

package/dist/commands/design.d.ts

@@ -0,0 +1,38 @@
+/**
+ * commands/design.ts
+ * Generate technical specification from PRD document
+ *
+ * This command is OPTIONAL - use it when:
+ * - The feature requires special technology choices
+ * - Complex architecture decisions are needed
+ * - Technical risks need to be documented
+ */
+export interface DesignOptions {
+    cwd?: string;
+    change?: string;
+    force?: boolean;
+    input?: string;
+    context?: string;
+    contextFile?: string;
+    skipPrompt?: boolean;
+}
+export interface DesignResult {
+    success: boolean;
+    reason?: string;
+    message?: string;
+    changeName?: string;
+    changeDir?: string;
+    designPath?: string;
+    prdInfo?: Record<string, unknown>;
+    needsContext?: boolean;
+    contextPrompt?: string[];
+}
+declare function extractPRDInfo(prdContent: string): Record<string, unknown>;
+export declare function generateDesign(options?: DesignOptions): Promise<DesignResult>;
+export declare function main(): Promise<void>;
+declare const _default: {
+    generateDesign: typeof generateDesign;
+    extractPRDInfo: typeof extractPRDInfo;
+    main: typeof main;
+};
+export default _default;

package/dist/commands/design.js

@@ -0,0 +1,492 @@
+"use strict";
+/**
+ * commands/design.ts
+ * Generate technical specification from PRD document
+ *
+ * This command is OPTIONAL - use it when:
+ * - The feature requires special technology choices
+ * - Complex architecture decisions are needed
+ * - Technical risks need to be documented
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDesign = generateDesign;
+exports.main = main;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../lib/config");
+const interactive_1 = require("../lib/interactive");
+function parseArgs(argv) {
+    const args = {};
+    for (let i = 2; i < argv.length; i += 1) {
+        const token = argv[i] || '';
+        if (!token.startsWith('--')) {
+            continue;
+        }
+        const key = token.slice(2);
+        const next = argv[i + 1] || '';
+        if (!next || next.startsWith('--')) {
+            args[key] = true;
+            continue;
+        }
+        args[key] = next;
+        i += 1;
+    }
+    return args;
+}
+function loadTemplate() {
+    const templatePath = path.resolve(__dirname, '../../assets/design.md');
+    if (fs.existsSync(templatePath)) {
+        return fs.readFileSync(templatePath, 'utf8');
+    }
+    return `# 技术规格文档
+
+## 文档基础信息
+
+- **需求名称**: [待填写]
+- **文档状态**: 草稿
+- **技术负责人**: [待填写]
+- **修订历史**: 
+  - [日期] - v1.0 - 初始版本
+
+## 技术选型
+
+### 核心技术栈
+<!-- 列出本次需求涉及的核心技术及选型理由 -->
+
+### 新增依赖
+<!-- 列出需要引入的新依赖库及其用途 -->
+
+### 技术决策
+<!-- 记录关键技术决策及其权衡 -->
+
+## 架构设计
+
+### 系统架构图
+<!-- 提供系统架构图，展示各组件关系 -->
+
+### 模块划分
+<!-- 描述模块划分及职责边界 -->
+
+### 数据流向
+<!-- 描述核心数据流转路径 -->
+
+## 接口设计
+
+### API 接口
+<!-- 列出需要新增或修改的 API 接口 -->
+
+### 数据格式
+<!-- 定义请求和响应的数据格式 -->
+
+### 错误处理
+<!-- 定义错误码和错误处理策略 -->
+
+## 数据模型
+
+### 数据库设计
+<!-- 描述数据库表结构设计 -->
+
+### 数据关系
+<!-- 描述实体间的关系 -->
+
+### 数据迁移
+<!-- 描述数据迁移策略 -->
+
+## 技术风险与缓解
+
+### 已识别风险
+<!-- 列出技术实现中的潜在风险 -->
+
+### 缓解措施
+<!-- 针对每个风险的缓解方案 -->
+
+## 性能与扩展
+
+### 性能要求
+<!-- 描述性能指标和优化策略 -->
+
+### 扩展性设计
+<!-- 描述如何支持未来的扩展需求 -->
+`;
+}
+function toChangeName(input) {
+    const sanitized = String(input || '')
+        .trim()
+        .replace(/[^a-zA-Z0-9-_]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    if (sanitized.includes('..') || sanitized.startsWith('/')) {
+        return '';
+    }
+    return sanitized;
+}
+function validateConfig(config) {
+    if (!config.projectRoot) {
+        return {
+            valid: false,
+            reason: 'missing-project-root',
+            message: 'Config missing projectRoot',
+        };
+    }
+    return { valid: true };
+}
+function extractPRDInfo(prdContent) {
+    const lines = prdContent.split(/\r?\n/);
+    const info = {
+        title: '',
+        background: '',
+        goals: [],
+        scope: [],
+    };
+    let currentSection = '';
+    let currentContent = [];
+    for (const line of lines) {
+        if (line.startsWith('# ')) {
+            info.title = line.replace(/^#\s+/, '').trim();
+            continue;
+        }
+        if (line.startsWith('## ')) {
+            if (currentSection && currentContent.length > 0) {
+                info[currentSection] = currentContent.join('\n').trim();
+            }
+            currentSection = line.replace(/^##\s+/, '').trim().toLowerCase().replace(/\s+/g, '_');
+            currentContent = [];
+            continue;
+        }
+        if (currentSection) {
+            currentContent.push(line);
+        }
+    }
+    if (currentSection && currentContent.length > 0) {
+        info[currentSection] = currentContent.join('\n').trim();
+    }
+    return info;
+}
+function extractContextInfo(context) {
+    const info = {};
+    const patterns = {
+        techStack: /技术栈?[:：]\s*(.+)/i,
+        framework: /框架?[:：]\s*(.+)/i,
+        library: /库?[:：]\s*(.+)/i,
+        performance: /性能?[:：]\s*(.+)/i,
+        architecture: /架构?[:：]\s*(.+)/i,
+        constraint: /约束?[:：]\s*(.+)/i,
+        requirement: /要求?[:：]\s*(.+)/i,
+    };
+    for (const [key, pattern] of Object.entries(patterns)) {
+        const match = context.match(pattern);
+        if (match && match[1]) {
+            info[key] = match[1].trim();
+        }
+    }
+    return info;
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('readable', () => {
+            let chunk;
+            while ((chunk = process.stdin.read()) !== null) {
+                chunks.push(chunk);
+            }
+        });
+        process.stdin.on('end', () => {
+            resolve(chunks.join(''));
+        });
+        process.stdin.on('error', (error) => {
+            reject(error);
+        });
+        setTimeout(() => {
+            if (chunks.length === 0) {
+                reject(new Error('Stdin timeout: no data received'));
+            }
+        }, 5000);
+    });
+}
+function checkMissingContext(contextInfo) {
+    const prompts = [];
+    if (!contextInfo.techStack && !contextInfo.framework) {
+        prompts.push('Technology stack preferences (e.g., React, Vue, Node.js)');
+    }
+    if (!contextInfo.architecture) {
+        prompts.push('Architecture constraints (e.g., microservices, monolith)');
+    }
+    if (!contextInfo.performance) {
+        prompts.push('Performance requirements (e.g., response time < 100ms)');
+    }
+    if (!contextInfo.risks) {
+        prompts.push('Known technical risks');
+    }
+    return {
+        needsInfo: prompts.length > 0,
+        prompts,
+        message: prompts.length > 0
+            ? `Missing context information. Please provide via --context or --context-file:\n${prompts.map((p, i) => `  ${i + 1}. ${p}`).join('\n')}`
+            : '',
+    };
+}
+async function promptForMissingInfo() {
+    console.log('\n[DESIGN] No valid context information provided.');
+    console.log('[DESIGN] Please provide additional technical design information:\n');
+    const techStack = await (0, interactive_1.input)({
+        message: 'Technology stack preferences (optional)',
+        default: '',
+    });
+    const architecture = await (0, interactive_1.input)({
+        message: 'Architecture constraints (optional)',
+        default: '',
+    });
+    const performance = await (0, interactive_1.input)({
+        message: 'Performance requirements (optional)',
+        default: '',
+    });
+    const risks = await (0, interactive_1.input)({
+        message: 'Known technical risks (optional)',
+        default: '',
+    });
+    const parts = [];
+    if (techStack) {
+        parts.push(`技术栈: ${techStack}`);
+    }
+    if (architecture) {
+        parts.push(`架构: ${architecture}`);
+    }
+    if (performance) {
+        parts.push(`性能: ${performance}`);
+    }
+    if (risks) {
+        parts.push(`风险: ${risks}`);
+    }
+    return parts.join('\n');
+}
+async function generateDesign(options = {}) {
+    const config = (0, config_1.loadConfig)({ cwd: options.cwd });
+    const changeName = toChangeName(options.change);
+    if (!changeName) {
+        return {
+            success: false,
+            reason: 'missing-change',
+            message: 'Missing required argument: --change <change-name>',
+        };
+    }
+    const configValidation = validateConfig(config);
+    if (!configValidation.valid) {
+        return {
+            success: false,
+            reason: configValidation.reason,
+            message: configValidation.message || 'Unknown config validation error',
+        };
+    }
+    const projectRoot = config.projectRoot || process.cwd();
+    const specRoot = config.specRootAbs || path.resolve(projectRoot, 'spec');
+    const changeDir = path.resolve(specRoot, 'changes', changeName);
+    const prdPath = path.resolve(changeDir, 'product-requirement.md');
+    const designPath = path.resolve(changeDir, 'design.md');
+    if (!fs.existsSync(prdPath)) {
+        return {
+            success: false,
+            reason: 'prd-not-found',
+            message: `product-requirement.md not found. Please create it first at: ${prdPath}`,
+        };
+    }
+    const prdContent = fs.readFileSync(prdPath, 'utf8');
+    const prdInfo = extractPRDInfo(prdContent);
+    let contextData;
+    if (options.contextFile) {
+        try {
+            const contextContent = fs.readFileSync(options.contextFile, 'utf8');
+            contextData = JSON.parse(contextContent);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                success: false,
+                reason: 'invalid-context-file',
+                message: `Failed to parse context file: ${errorMessage}`,
+            };
+        }
+    }
+    let contextInfo = {};
+    let additionalContext = '';
+    let aiInput = options.input;
+    if (!aiInput && !process.stdin.isTTY && require.main === module) {
+        try {
+            const stdinContent = await readStdin();
+            if (stdinContent.trim()) {
+                aiInput = stdinContent;
+                console.log(`[DESIGN] Received ${stdinContent.length} bytes from stdin`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.warn(`[DESIGN] Warning: Failed to read stdin: ${errorMessage}`);
+        }
+    }
+    if (options.context) {
+        contextInfo = extractContextInfo(options.context);
+    }
+    if (contextData?.project.techStack) {
+        const ts = contextData.project.techStack;
+        if (ts.language) {
+            contextInfo.language = ts.language;
+        }
+        if (ts.framework) {
+            contextInfo.framework = ts.framework;
+        }
+        if (ts.runtime) {
+            contextInfo.architecture = ts.runtime;
+        }
+    }
+    if (contextData?.analysis?.architectureSummary) {
+        contextInfo.architecture = contextData.analysis.architectureSummary;
+    }
+    if (contextData?.task?.constraints && contextData.task.constraints.length > 0) {
+        contextInfo.constraint = contextData.task.constraints.join('; ');
+    }
+    const hasValidContext = Object.keys(contextInfo).length > 0;
+    const isTTY = process.stdin.isTTY;
+    const isMainModule = require.main === module;
+    const shouldPrompt = !options.skipPrompt && isMainModule && isTTY;
+    if (!aiInput && !hasValidContext && !options.input) {
+        if (shouldPrompt) {
+            additionalContext = await promptForMissingInfo();
+            if (additionalContext) {
+                contextInfo = extractContextInfo(additionalContext);
+            }
+        }
+        else if (!options.skipPrompt) {
+            const missing = checkMissingContext(contextInfo);
+            return {
+                success: false,
+                reason: 'missing-context',
+                message: missing.message,
+                needsContext: true,
+                contextPrompt: missing.prompts,
+                changeName,
+                changeDir,
+            };
+        }
+    }
+    let designContent;
+    if (aiInput) {
+        designContent = aiInput;
+    }
+    else {
+        designContent = loadTemplate();
+        if (prdInfo.title) {
+            designContent = designContent.replace('- **需求名称**: [待填写]', `- **需求名称**: ${prdInfo.title}`);
+        }
+        if (contextInfo.techStack) {
+            const techSection = `### 核心技术栈\n${contextInfo.techStack}`;
+            designContent = designContent.replace('<!-- 列出本次需求涉及的核心技术及选型理由 -->', `${techSection}\n<!-- 列出本次需求涉及的核心技术及选型理由 -->`);
+        }
+        if (contextInfo.architecture) {
+            const archSection = `### 架构约束\n${contextInfo.architecture}`;
+            designContent = designContent.replace('<!-- 描述模块划分及职责边界 -->', `${archSection}\n<!-- 描述模块划分及职责边界 -->`);
+        }
+        if (contextInfo.performance) {
+            const perfSection = `### 性能要求\n${contextInfo.performance}`;
+            designContent = designContent.replace('<!-- 描述性能指标和优化策略 -->', `${perfSection}\n<!-- 描述性能指标和优化策略 -->`);
+        }
+    }
+    if (fs.existsSync(designPath) && !options.force) {
+        return {
+            success: false,
+            reason: 'already-exists',
+            message: `design.md already exists: ${designPath}. Use --force to overwrite.`,
+        };
+    }
+    try {
+        fs.writeFileSync(designPath, designContent, 'utf8');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            reason: 'file-write-error',
+            message: `Failed to write design.md: ${errorMessage}`,
+        };
+    }
+    return {
+        success: true,
+        changeName,
+        changeDir,
+        designPath,
+        prdInfo,
+    };
+}
+async function main() {
+    const args = parseArgs(process.argv);
+    const result = await generateDesign({
+        cwd: args.cwd,
+        change: args.change,
+        force: args.force === true,
+        input: args.input,
+        context: args.context,
+        contextFile: args['context-file'],
+        skipPrompt: args['skip-prompt'] === true,
+    });
+    if (!result.success) {
+        console.error(`[DESIGN] ${result.message}`);
+        if (result.reason === 'missing-context' && result.contextPrompt) {
+            console.error('\n[DESIGN] To provide context, use one of:');
+            console.error('  --context "技术栈: React, 架构: 微前端"');
+            console.error('  --context-file /path/to/context.json');
+            console.error('  --skip-prompt (generate template without context)');
+        }
+        process.exit(1);
+    }
+    console.log('');
+    console.log('[DESIGN] Technical specification generated successfully!');
+    console.log(`  Change Name: ${result.changeName}`);
+    console.log(`  Directory: ${result.changeDir}`);
+    console.log(`  Design: ${result.designPath}`);
+    console.log('');
+    console.log('Next steps:');
+    console.log('  1. Review and edit design.md');
+    console.log('  2. Run: task-flow tasks --change <change-name>');
+    console.log('');
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}
+exports.default = {
+    generateDesign,
+    extractPRDInfo,
+    main,
+};

package/dist/commands/extract.d.ts

@@ -0,0 +1,31 @@
+/**
+ * commands/extract.ts
+ * Extract project requirements and generate PRD document
+ *
+ * This command is AI-only - use it to summarize existing projects
+ * and generate structured Product Requirement Documents.
+ */
+export interface ExtractOptions {
+    cwd?: string;
+    change?: string;
+    type?: string;
+    priority?: string;
+    force?: boolean;
+    input?: string;
+    contextFile?: string;
+}
+export interface ExtractResult {
+    success: boolean;
+    reason?: string;
+    message?: string;
+    changeName?: string;
+    changeDir?: string;
+    prdPath?: string;
+}
+export declare function extract(options?: ExtractOptions): Promise<ExtractResult>;
+export declare function main(): Promise<void>;
+declare const _default: {
+    extract: typeof extract;
+    main: typeof main;
+};
+export default _default;