aico-cli 2.0.29 → 2.0.30

package/templates/hooks/utils/execution-utils.ts

@@ -0,0 +1,176 @@
+#!/usr/bin/env tsx
+/**
+ * 执行状态管理工具
+ * 提供任务执行状态跟踪、锁文件管理等功能
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { getHooksDirectory } from './hook-utils';
+
+
+/**
+ * 执行状态接口
+ */
+export interface ExecutionStatus {
+    currentTask?: string;
+    status: string;
+    progress?: string;
+    error?: string;
+    message?: string;
+    totalTasks?: number;
+    completed?: number;
+    failed?: number;
+    successRate?: string;
+    timestamp?: string;
+}
+
+/**
+ * 锁文件数据接口
+ */
+export interface LockFileData {
+    started: string;
+    pid: number;
+    taskFile?: string;
+}
+
+/**
+ * 获取执行状态文件路径
+ */
+function getStatusFilePath(): string {
+    const hooksDir = getHooksDirectory();
+    return path.join(hooksDir, 'execution-status.json');
+}
+
+/**
+ * 获取锁文件路径
+ */
+function getLockFilePath(): string {
+    const hooksDir = getHooksDirectory();
+    return path.join(hooksDir, 'execution-lock');
+}
+
+/**
+ * 创建执行锁
+ */
+export async function createExecutionLock(taskFile?: string): Promise<boolean> {
+    try {
+        const lockFile = getLockFilePath();
+        const lockDir = path.dirname(lockFile);
+        
+        await fs.promises.mkdir(lockDir, { recursive: true });
+        
+        const lockData: LockFileData = {
+            started: new Date().toISOString(),
+            pid: process.pid,
+            taskFile
+        };
+        
+        await fs.promises.writeFile(lockFile, JSON.stringify(lockData, null, 2));
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+ * 移除执行锁
+ */
+export async function removeExecutionLock(): Promise<boolean> {
+    try {
+        const lockFile = getLockFilePath();
+        await fs.promises.unlink(lockFile);
+        return true;
+    } catch (error) {
+        // 锁文件不存在时忽略错误
+        return true;
+    }
+}
+
+/**
+ * 检查是否存在执行锁
+ */
+export async function hasExecutionLock(): Promise<boolean> {
+    try {
+        const lockFile = getLockFilePath();
+        await fs.promises.access(lockFile);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * 读取执行锁信息
+ */
+export async function readExecutionLock(): Promise<LockFileData | null> {
+    try {
+        const lockFile = getLockFilePath();
+        const content = await fs.promises.readFile(lockFile, 'utf-8');
+        return JSON.parse(content) as LockFileData;
+    } catch (error) {
+        return null;
+    }
+}
+
+/**
+ * 保存执行状态
+ */
+export async function saveExecutionStatus(status: ExecutionStatus): Promise<boolean> {
+    try {
+        const statusFile = getStatusFilePath();
+        const statusDir = path.dirname(statusFile);
+        
+        await fs.promises.mkdir(statusDir, { recursive: true });
+        
+        const statusData: ExecutionStatus = {
+            ...status,
+            timestamp: new Date().toISOString()
+        };
+        
+        await fs.promises.writeFile(statusFile, JSON.stringify(statusData, null, 2));
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+ * 读取执行状态
+ */
+export async function readExecutionStatus(): Promise<ExecutionStatus | null> {
+    try {
+        const statusFile = getStatusFilePath();
+        const content = await fs.promises.readFile(statusFile, 'utf-8');
+        return JSON.parse(content) as ExecutionStatus;
+    } catch (error) {
+        return null;
+    }
+}
+
+/**
+ * 清理执行状态
+ */
+export async function clearExecutionStatus(): Promise<boolean> {
+    try {
+        const statusFile = getStatusFilePath();
+        await fs.promises.unlink(statusFile);
+        return true;
+    } catch (error) {
+        return true;
+    }
+}
+
+/**
+ * 格式化执行进度
+ */
+export function formatProgress(completed: number, total: number): string {
+    return `${completed}/${total} (${((completed / total) * 100).toFixed(1)}%)`;
+}
+
+/**
+ * 计算成功率
+ */
+export function calculateSuccessRate(completed: number, total: number): string {
+    return ((completed / total) * 100).toFixed(1);
+}

package/templates/hooks/utils/file-utils.ts

@@ -0,0 +1,256 @@
+#!/usr/bin/env tsx
+/**
+ * 文件操作工具模块
+ * 提供统一的文件读取、解析、glob匹配等功能
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+
+/**
+ * 任务接口定义
+ */
+export interface Task {
+    id: string;
+    title: string;
+    description: string;
+    completed: boolean;
+    lineNumber: number;
+}
+
+/**
+ * 安全读取文件
+ */
+export async function safeReadFile(filePath: string): Promise<string | null> {
+    try {
+        return await fs.promises.readFile(filePath, 'utf-8');
+    } catch (error) {
+        return null;
+    }
+}
+
+/**
+ * 安全写入文件
+ */
+export async function safeWriteFile(filePath: string, content: string): Promise<boolean> {
+    try {
+        await fs.promises.writeFile(filePath, content, 'utf-8');
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+ * 简单的glob模式匹配实现
+ */
+export async function glob(pattern: string): Promise<string[]> {
+    const baseDir = process.cwd();
+    const parts = pattern.split('/');
+    const results: string[] = [];
+    
+    try {
+        // 处理包含通配符的路径
+        if (pattern.includes('*')) {
+            const dirPath = parts.slice(0, -1).join('/');
+            const fileName = parts[parts.length - 1];
+            
+            // 查找包含通配符的目录部分
+            const wildcardIndex = parts.findIndex(part => part.includes('*'));
+            if (wildcardIndex !== -1) {
+                const searchDir = path.join(baseDir, parts.slice(0, wildcardIndex).join('/'));
+                const remainingParts = parts.slice(wildcardIndex);
+                
+                await globRecursive(searchDir, remainingParts, results, baseDir);
+            }
+        } else {
+            // 直接检查文件是否存在
+            const fullPath = path.join(baseDir, pattern);
+            try {
+                await fs.promises.access(fullPath);
+                results.push(pattern);
+            } catch {
+                // 文件不存在
+            }
+        }
+    } catch (error) {
+    }
+    
+    return results;
+}
+
+/**
+ * 递归glob匹配
+ */
+async function globRecursive(
+    currentDir: string,
+    remainingParts: string[],
+    results: string[],
+    baseDir: string
+): Promise<void> {
+    if (remainingParts.length === 0) return;
+    
+    const currentPart = remainingParts[0];
+    const nextParts = remainingParts.slice(1);
+    
+    try {
+        const entries = await fs.promises.readdir(currentDir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+            if (currentPart === '*' && entry.isDirectory()) {
+                // 通配符匹配所有目录
+                const nextDir = path.join(currentDir, entry.name);
+                
+                if (nextParts.length === 0) {
+                    // 最后一个部分
+                    results.push(path.relative(baseDir, nextDir));
+                } else if (nextParts.length === 1 && !nextParts[0].includes('*')) {
+                    // 下一个是具体文件名
+                    const targetFile = path.join(nextDir, nextParts[0]);
+                    try {
+                        await fs.promises.access(targetFile);
+                        results.push(path.relative(baseDir, targetFile));
+                    } catch {
+                        // 文件不存在
+                    }
+                } else {
+                    // 继续递归
+                    await globRecursive(nextDir, nextParts, results, baseDir);
+                }
+            }
+        }
+    } catch (error) {
+        // 目录不存在或无权限
+    }
+}
+
+/**
+ * 查找tasks.md文件
+ */
+export async function findTasksFile(): Promise<string | null> {
+    const searchPaths = [
+        '.claude/specs/*/tasks.md',
+        '.qwen/specs/*/tasks.md',
+        '.kiro/specs/*/tasks.md'
+    ];
+    
+    for (const pattern of searchPaths) {
+        const files = await glob(pattern);
+        if (files.length > 0) {
+            return files[0];
+        }
+    }
+    
+    return null;
+}
+
+/**
+ * 解析tasks.md文件
+ */
+export async function parseTasksFile(filePath: string): Promise<Task[]> {
+    const content = await safeReadFile(filePath);
+    if (!content) return [];
+    
+    const tasks: Task[] = [];
+    const lines = content.split('\n');
+    
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const taskMatch = line.match(/- \[( |x)\] \*\*Task ([\d.]+):\*\*(.+)$/);
+        
+        if (taskMatch) {
+            const completed = taskMatch[1] === 'x';
+            const taskId = taskMatch[2];
+            const taskTitle = taskMatch[3].trim();
+            const description: string[] = [];
+            
+            // 读取任务描述(缩进行)
+            let j = i + 1;
+            while (j < lines.length && lines[j].startsWith('  ')) {
+                description.push(lines[j].trim());
+                j++;
+            }
+            
+            tasks.push({
+                id: taskId,
+                title: taskTitle,
+                description: description.join(' '),
+                completed: completed,
+                lineNumber: i
+            });
+        }
+    }
+    
+    // removed log('INFO', `解析到 ${tasks.length} 个任务`, HOOK_NAME);
+    return tasks;
+}
+
+/**
+ * 标记任务为完成状态
+ */
+export async function markTaskCompleted(filePath: string, taskId: string): Promise<boolean> {
+    const content = await safeReadFile(filePath);
+    if (!content) return false;
+    
+    const lines = content.split('\n');
+    const taskLinePattern = new RegExp(`- \\[ \\] \\*\\*Task ${taskId.replace(/\./g, '\\.')}:\\*\\*`);
+    
+    let updated = false;
+    for (let i = 0; i < lines.length; i++) {
+        if (taskLinePattern.test(lines[i])) {
+            lines[i] = lines[i].replace('- [ ]', '- [x]');
+            updated = true;
+            break;
+        }
+    }
+    
+    if (updated) {
+        const success = await safeWriteFile(filePath, lines.join('\n'));
+        if (success) {
+        }
+        return success;
+    }
+    
+    return false;
+}
+
+/**
+ * 重置所有任务为未完成状态
+ */
+export async function resetAllTasks(filePath: string): Promise<boolean> {
+    const content = await safeReadFile(filePath);
+    if (!content) return false;
+    
+    const updatedContent = content.replace(/- \[x\] \*\*Task/g, '- [ ] **Task');
+    const success = await safeWriteFile(filePath, updatedContent);
+    
+    if (success) {
+    }
+    
+    return success;
+}
+
+/**
+ * 确保目录存在
+ */
+export async function ensureDir(dirPath: string): Promise<boolean> {
+    try {
+        await fs.promises.mkdir(dirPath, { recursive: true });
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+ * 检查文件是否存在
+ */
+export async function fileExists(filePath: string): Promise<boolean> {
+    try {
+        await fs.promises.access(filePath);
+        return true;
+    } catch {
+        return false;
+    }
+}

package/templates/hooks/utils/hook-utils.ts

@@ -0,0 +1,86 @@
+#!/usr/bin/env tsx
+/**
+ * UserPromptSubmit Hook - Input Notifier
+ * 当用户提交输入时发送通知
+ * 跨平台 TypeScript 实现
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { execSync } from 'child_process';
+
+// 类型定义
+type Platform = 'win32' | 'darwin' | 'linux' | 'aix' | 'freebsd' | 'openbsd' | 'sunos';
+
+// 检测操作系统
+const platform = os.platform() as Platform;
+
+// 获取 hooks 目录路径
+function getHooksDirectory(): string {
+    const homeDir = os.homedir();
+    return path.join(homeDir, '.claude', 'hooks');
+}
+
+// 获取项目目录路径
+function getProjectDirectory(): string {
+    if (process.env.CLAUDE_PROJECT_DIR) {
+        return process.env.CLAUDE_PROJECT_DIR;
+    } else {
+        return process.cwd();
+    }
+}
+
+
+
+// 检查命令是否存在
+function commandExists(command: string): boolean {
+    try {
+        if (platform === 'win32') {
+            execSync(`where ${command}`, { stdio: 'ignore' });
+        } else {
+            execSync(`command -v ${command}`, { stdio: 'ignore' });
+        }
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+// 安全的JSON解析
+function safeJsonParse<T = any>(jsonInput: string): T | null {
+    try {
+        return JSON.parse(jsonInput) as T;
+    } catch (err) {
+        return null;
+    }
+}
+
+// 显示系统信息（用于测试）
+function showSystemInfo(): void {
+    // System info display removed
+}
+
+// 主执行函数
+function main(): void {
+    try {
+        showSystemInfo();
+    } catch (err) {
+        // 即使失败也返回成功状态码，避免影响主流程
+        process.exit(0);
+    }
+}
+
+// 导出函数供其他模块使用
+export {
+    getHooksDirectory,
+    getProjectDirectory,
+    commandExists,
+    safeJsonParse,
+    showSystemInfo
+};
+
+// 执行主函数（仅当直接运行时）
+if (require.main === module) {
+    main();
+}

package/templates/hooks/utils/index.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env tsx
+/**
+ * Hooks工具统一导出
+ */
+
+// 导出hook-utils
+export {
+    getHooksDirectory,
+    getProjectDirectory,
+    commandExists,
+    safeJsonParse,
+    showSystemInfo
+} from './hook-utils';
+
+// 导出file-utils
+export {
+    Task,
+    safeReadFile,
+    safeWriteFile,
+    glob,
+    findTasksFile,
+    parseTasksFile,
+    markTaskCompleted,
+    resetAllTasks,
+    ensureDir,
+    fileExists
+} from './file-utils';
+
+// 导出execution-utils
+export {
+    ExecutionStatus,
+    LockFileData,
+    createExecutionLock,
+    removeExecutionLock,
+    hasExecutionLock,
+    readExecutionLock,
+    saveExecutionStatus,
+    readExecutionStatus,
+    clearExecutionStatus,
+    formatProgress,
+    calculateSuccessRate
+} from './execution-utils';

package/templates/personality.md

@@ -73,28 +73,29 @@ description: 架构师级软件工程师，以工程卓越为信仰，为追求
 ### 3. 系统化分析流程
 
 **TODO清单标准流程：**
+
 1. **需求分析**
-   - 充分搜索与用户输入内容相关的资源
-   - 明确用户的核心问题、隐含需求和最终目标
-   - 围绕问题，快速构建一个知识框架。确定回答应包含的关键概念、上下文、正反论点和潜在的延伸领域
-   - 根据充分了解到的信息，清晰完整的复述用户需求，并给出一个高度浓缩的、结论性的核心观点
+   - 搜索相关资源，明确核心问题、隐含需求和最终目标
+   - 构建知识框架：关键概念、上下文、正反论点、延伸领域
+   - 复述需求并给出结论性核心观点
 
 2. **场景识别**
-   - 基于需求分析的内容，找出主要矛盾点，定位核心问题节点
-   - 从系统层面拆解为可执行子任务，确保逻辑链条清晰，上下文信息充足
+   - 定位主要矛盾点和核心问题节点
+   - 拆解为可执行子任务，确保逻辑清晰、上下文充足
 
 3. **方案设计**
-   - 方案设计优先复用现有方案，组件，工具方法等，能复用的尽可能复用
-   - 扫描项目中使用的测试框架和脚本，生成本次需求的测试脚本，如果不存在测试脚本，则编写测试脚本到.aico/tests下面
+   - 优先复用现有方案、组件、工具方法
+   - 扫描测试框架，生成测试脚本或编写测试用例
 
 4. **执行验证**
-   - 按方案设计的结果输出代码
-   - 如果有测试脚本，运行测试脚本并修正直到测试脚本全部通过
+   - **对齐规范**：扫描现有模块的结构、命名、风格，确保一致性
+   - **渐进实现**：按优先级逐个完成子任务，每完成一个立即自检
+   - **测试验证**：执行测试脚本并修正至通过；无脚本则基于用例手动验证
+   - **集成检查**：确认兼容性，排查依赖冲突和副作用
 
 5. **总结反馈**
-   - 输出最终执行的方案
-   - 更新TODO清单
-   - 根据情况提供一些前瞻性的思考或建议
+   - 输出最终方案并更新TODO清单
+   - 提供前瞻性思考或建议
 
 **执行原则：**
 - 创建并持续更新TODO清单
@@ -134,4 +135,8 @@ description: 架构师级软件工程师，以工程卓越为信仰，为追求
 测试策略：[如何验证方案有效性]
 潜在风险：[可能遇到的问题]
 优化空间：[未来改进方向]
-```
+```
+
+### 输出要求
+- 在完成所有任务后，禁止生成使用，说明等md文档，只输出一个精简的总结内容即可
+- 对于代码中的注释只输出方法相关的注释，符合注释规则，不要输出与方法无关的提示信息。

package/templates/settings.json

@@ -32,12 +32,47 @@
     "deny": []
   },
   "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command":  "node -e \"require('child_process').execSync('npx tsx ' + require('path').join(require('os').homedir(), '.claude/hooks/scripts/PreToolUse/pre-tool-use.ts'), {stdio: 'inherit'})\"",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PostToolUse":[
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command":  "node -e \"require('child_process').execSync('npx tsx ' + require('path').join(require('os').homedir(), '.claude/hooks/scripts/PostToolUse/post-tool-use.ts'), {stdio: 'inherit'})\"",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
     "UserPromptSubmit": [
       {
         "hooks": [
           {
             "type": "command",
-            "command": "if [ \"$OS\" = \"Windows_NT\" ]; then powershell -File \"$env:USERPROFILE/.claude/hooks/notify.ps1\" input; else ~/.claude/hooks/notify.sh input; fi",
+            "command": "node -e \"require('child_process').execSync('npx tsx ' + require('path').join(require('os').homedir(), '.claude/hooks/scripts/UserPromptSubmit/user-prompt-submit.ts'), {stdio: 'inherit'})\"",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "Notification": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"require('child_process').execSync('npx tsx ' + require('path').join(require('os').homedir(), '.claude/hooks/scripts/Notification/notification.ts'), {stdio: 'inherit'})\"",
             "timeout": 10
           }
         ]
@@ -48,7 +83,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ \"$OS\" = \"Windows_NT\" ]; then powershell -File \"$env:USERPROFILE/.claude/hooks/notify.ps1\" complete; else ~/.claude/hooks/notify.sh complete; fi",
+            "command": "node -e \"require('child_process').execSync('npx tsx ' + require('path').join(require('os').homedir(), '.claude/hooks/scripts/Stop/stop.ts'), {stdio: 'inherit'})\"",
             "timeout": 10
           }
         ]