aws-runtime-bridge 1.0.0

package/dist/utils/yaml-utils.js

@@ -0,0 +1,309 @@
+/**
+ * YAML 处理工具函数
+ *
+ * 提供 YAML 配置文件的读取、解析、生成和路径匹配功能
+ */
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import * as yaml from 'js-yaml';
+import { createLogger } from './logger.js';
+const log = createLogger('yaml-utils');
+/**
+ * 检查 YAML 配置中是否有 agent 的 path 匹配目标路径
+ * path 字段格式支持：modules\x 或 modules/x
+ *
+ * @param yamlContent - YAML 内容
+ * @param targetRelativePath - 目标相对路径
+ * @returns 匹配的 agent path，无匹配则返回 null
+ */
+export function hasMatchingAgentPath(yamlContent, targetRelativePath) {
+    try {
+        const parsed = yaml.load(yamlContent);
+        if (!parsed || typeof parsed !== 'object') {
+            return null;
+        }
+        const agents = parsed['agent'];
+        if (!Array.isArray(agents)) {
+            return null;
+        }
+        // 标准化目标路径（统一使用 / 分隔符）
+        const normalizedTarget = targetRelativePath.replace(/\\/g, '/');
+        for (const agent of agents) {
+            if (!agent || typeof agent !== 'object') {
+                continue;
+            }
+            const agentPath = agent['path'];
+            if (typeof agentPath !== 'string') {
+                continue;
+            }
+            // 标准化配置中的 path
+            const normalizedAgentPath = agentPath.replace(/\\/g, '/');
+            // 匹配逻辑：
+            // 1. 精确匹配
+            // 2. 如果目标是 "."（当前目录），配置中 path 为 "." 或空字符串也算匹配
+            if (normalizedAgentPath === normalizedTarget) {
+                return agentPath;
+            }
+            // 特殊处理：当前目录匹配
+            if (normalizedTarget === '.' && (normalizedAgentPath === '.' || normalizedAgentPath === '')) {
+                return agentPath;
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 从 YAML 配置中提取匹配的 agent 配置，或生成模板
+ *
+ * @param yamlContent - YAML 内容
+ * @param targetRelativePath - 目标相对路径
+ * @returns 提取结果
+ */
+export function extractAgentConfigOrTemplate(yamlContent, targetRelativePath) {
+    try {
+        const parsed = yaml.load(yamlContent);
+        if (!parsed || typeof parsed !== 'object') {
+            return { content: yamlContent, isTemplate: false, projectFromSibling: null };
+        }
+        const agents = parsed['agent'];
+        if (!Array.isArray(agents)) {
+            return { content: yamlContent, isTemplate: false, projectFromSibling: null };
+        }
+        // 标准化目标路径（统一使用 "/" 分隔符）
+        const normalizedTarget = targetRelativePath.replace(/\\/g, '/');
+        // 查找匹配的 agent
+        for (const agent of agents) {
+            if (!agent || typeof agent !== 'object') {
+                continue;
+            }
+            const agentObj = agent;
+            const agentPath = agentObj['path'];
+            if (typeof agentPath !== 'string') {
+                continue;
+            }
+            const normalizedAgentPath = agentPath.replace(/\\/g, '/');
+            // 匹配逻辑：
+            // 1. 精确匹配
+            // 2. 如果目标是 "."（当前目录），配置中 path 为 "." 或空字符串也算匹配
+            const isMatch = normalizedAgentPath === normalizedTarget ||
+                (normalizedTarget === '.' && (normalizedAgentPath === '.' || normalizedAgentPath === ''));
+            if (isMatch) {
+                // 找到匹配的 agent，只返回这一项（确保 path 使用 "/" 分隔符）
+                const normalizedAgentObj = { ...agentObj, path: normalizedAgentPath };
+                const singleAgentYaml = yaml.dump({ agent: [normalizedAgentObj] }, {
+                    indent: 2,
+                    lineWidth: -1,
+                    quotingType: '"',
+                    forceQuotes: false,
+                });
+                return { content: singleAgentYaml, isTemplate: false, projectFromSibling: null };
+            }
+        }
+        // 没有匹配的 agent，生成模板
+        // 先尝试从兄弟项获取 project 值
+        let projectValue = null;
+        for (const agent of agents) {
+            if (!agent || typeof agent !== 'object') {
+                continue;
+            }
+            const agentObj = agent;
+            if (typeof agentObj['project'] === 'string') {
+                projectValue = agentObj['project'];
+                break;
+            }
+        }
+        // 生成模板（path 使用 "/" 分隔符）
+        const template = {
+            agent: [
+                {
+                    name: '',
+                    path: normalizedTarget,
+                    project: projectValue || '',
+                    description: '',
+                    prompt: '',
+                },
+            ],
+        };
+        const templateYaml = yaml.dump(template, {
+            indent: 2,
+            lineWidth: -1,
+            quotingType: '"',
+            forceQuotes: false,
+        });
+        return { content: templateYaml, isTemplate: true, projectFromSibling: projectValue };
+    }
+    catch {
+        return { content: yamlContent, isTemplate: false, projectFromSibling: null };
+    }
+}
+/**
+ * 生成空模板
+ * 注意：path 字段留空，在写入时根据工作目录自动计算
+ *
+ * @param _targetRelativePath - 目标相对路径（未使用）
+ * @returns 空模板 YAML 内容
+ */
+export function generateEmptyTemplate(_targetRelativePath) {
+    const template = {
+        agent: [
+            {
+                name: '',
+                path: '', // 留空，写入时自动计算
+                project: '',
+                description: '',
+                prompt: '',
+            },
+        ],
+    };
+    return yaml.dump(template, {
+        indent: 2,
+        lineWidth: -1,
+        quotingType: '"',
+        forceQuotes: false,
+    });
+}
+/**
+ * 自动填充 YAML 配置中的 path 字段
+ * 如果 path 为空、未填写或只有空白字符，则使用工作目录相对于项目根目录的路径
+ *
+ * @param ymlContent - YAML 配置内容
+ * @param workspaceRelativePath - 工作目录相对于项目根目录的路径
+ * @returns 处理后的 YAML 内容
+ */
+export function autoFillPathInYml(ymlContent, workspaceRelativePath) {
+    try {
+        const parsed = yaml.load(ymlContent);
+        if (!parsed || typeof parsed !== 'object') {
+            return ymlContent;
+        }
+        const config = parsed;
+        if (!config.agent || !Array.isArray(config.agent)) {
+            return ymlContent;
+        }
+        let modified = false;
+        for (const agent of config.agent) {
+            if (agent) {
+                // 检查 path 是否为空、未定义或只有空白字符
+                const pathValue = agent.path;
+                const isPathEmpty = pathValue === undefined ||
+                    pathValue === null ||
+                    String(pathValue).trim() === '';
+                if (isPathEmpty) {
+                    agent.path = workspaceRelativePath;
+                    modified = true;
+                }
+            }
+        }
+        if (modified) {
+            return yaml.dump(config, {
+                indent: 2,
+                lineWidth: -1,
+                quotingType: '"',
+                forceQuotes: false,
+            });
+        }
+        return ymlContent;
+    }
+    catch {
+        // 解析失败，返回原内容
+        return ymlContent;
+    }
+}
+/**
+ * 向上查找并加载 YAML 配置文件
+ *
+ * 查找逻辑：
+ * 1. 先检查工作目录下是否有配置文件，检查 path 是否匹配
+ * 2. 如果不匹配，向上查找父目录的配置文件，检查 path 是否匹配
+ * 3. 找到匹配的配置 → 使用该配置
+ * 4. 所有层级都没有匹配的配置 → 使用最后一个找到的配置（或在工作目录创建）
+ *
+ * 例如：工作目录 D:\a\b\c\d，相对路径 vibe-coding/my.yml
+ * 第1次查找：D:\a\b\c\d\vibe-coding\my.yml，匹配 path="."
+ * 第2次查找：D:\a\b\c\vibe-coding\my.yml，匹配 path="d"
+ * 第3次查找：D:\a\b\vibe-coding\my.yml，匹配 path="c/d"
+ * ...
+ */
+export async function loadYmlWithUpwardSearch(workspacePath, relativePath) {
+    const normalizedWorkspace = path.resolve(workspacePath);
+    const normalizedRelative = relativePath.replace(/\//g, path.sep);
+    const absoluteInitialPath = path.resolve(normalizedWorkspace, normalizedRelative);
+    // 记录最后一次找到的配置文件（用于所有层级都不匹配时回退）
+    let lastFoundConfig = null;
+    // 首先尝试从工作目录读取
+    try {
+        const content = await fs.readFile(absoluteInitialPath, 'utf-8');
+        log.debug(`工作目录下找到配置: ${absoluteInitialPath}`);
+        // 当前目录的配置文件，工作目录相对于自己的相对路径是 "."
+        const workspaceRelativeToSelf = '.';
+        const matchedPath = hasMatchingAgentPath(content, workspaceRelativeToSelf);
+        if (matchedPath) {
+            // 找到匹配的 path，直接使用
+            log.debug(`当前目录配置匹配 path: ${matchedPath}`);
+            return { content, resolvedPath: absoluteInitialPath, foundInParent: false, matchedAgentPath: matchedPath };
+        }
+        // 当前目录配置不匹配，记录下来继续向上查找
+        log.debug(`当前目录配置不匹配，继续向上查找`);
+        lastFoundConfig = { content, resolvedPath: absoluteInitialPath };
+    }
+    catch (err) {
+        const error = err;
+        if (error?.code !== 'ENOENT') {
+            throw err;
+        }
+    }
+    // 从工作目录的父目录开始向上查找
+    let currentDir = normalizedWorkspace;
+    const root = path.parse(currentDir).root;
+    while (currentDir && currentDir !== root) {
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break; // 已到达根目录
+        }
+        // 计算工作目录相对于父目录的相对路径（即 agent 的 path 字段值）
+        const workspaceRelativeToParent = path.relative(parentDir, normalizedWorkspace);
+        const candidatePath = path.join(parentDir, normalizedRelative);
+        try {
+            const content = await fs.readFile(candidatePath, 'utf-8');
+            log.debug(`上层找到配置文件: ${candidatePath}`);
+            // 检查是否有匹配的 agent path
+            const matchedPath = hasMatchingAgentPath(content, workspaceRelativeToParent);
+            log.debug(`相对路径: ${workspaceRelativeToParent}, 匹配的agent path: ${matchedPath || '无'}`);
+            if (matchedPath) {
+                // 找到匹配的配置，返回
+                return {
+                    content,
+                    resolvedPath: candidatePath,
+                    foundInParent: true,
+                    matchedAgentPath: matchedPath,
+                };
+            }
+            // 不匹配，记录下来继续向上查找
+            lastFoundConfig = { content, resolvedPath: candidatePath };
+        }
+        catch (err) {
+            const error = err;
+            if (error?.code !== 'ENOENT') {
+                throw err;
+            }
+        }
+        currentDir = parentDir;
+    }
+    // 所有层级都没有找到匹配的配置
+    if (lastFoundConfig) {
+        // 使用最后一个找到的配置文件（需要入驻）
+        log.debug(`所有层级都不匹配，使用最后找到的配置: ${lastFoundConfig.resolvedPath}`);
+        return {
+            content: lastFoundConfig.content,
+            resolvedPath: lastFoundConfig.resolvedPath,
+            foundInParent: lastFoundConfig.resolvedPath !== absoluteInitialPath,
+            matchedAgentPath: null,
+        };
+    }
+    // 完全没有配置文件，将在工作目录下创建
+    log.debug(`未找到配置，将在工作目录创建: ${absoluteInitialPath}`);
+    return { content: null, resolvedPath: absoluteInitialPath, foundInParent: false, matchedAgentPath: null };
+}

package/dist/utils/yaml-utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=yaml-utils.test.d.ts.map

package/dist/utils/yaml-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml-utils.test.d.ts","sourceRoot":"","sources":["../../src/utils/yaml-utils.test.ts"],"names":[],"mappings":""}

package/dist/utils/yaml-utils.test.js

@@ -0,0 +1,363 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import { hasMatchingAgentPath, extractAgentConfigOrTemplate, generateEmptyTemplate, autoFillPathInYml, loadYmlWithUpwardSearch, } from './yaml-utils.js';
+describe('yaml-utils', () => {
+    describe('hasMatchingAgentPath', () => {
+        it('should return null for invalid YAML content', () => {
+            expect(hasMatchingAgentPath('invalid yaml [[', 'test')).toBeNull();
+        });
+        it('should return null for empty content', () => {
+            expect(hasMatchingAgentPath('', 'test')).toBeNull();
+        });
+        it('should return null when no agent key exists', () => {
+            const yaml = `
+other:
+  - name: test
+`;
+            expect(hasMatchingAgentPath(yaml, 'test')).toBeNull();
+        });
+        it('should return null when agent is not an array', () => {
+            const yaml = `
+agent:
+  name: single
+`;
+            expect(hasMatchingAgentPath(yaml, 'test')).toBeNull();
+        });
+        it('should return null when agent has no path', () => {
+            const yaml = `
+agent:
+  - name: test
+    description: no path
+`;
+            expect(hasMatchingAgentPath(yaml, 'test')).toBeNull();
+        });
+        it('should match exact path', () => {
+            const yaml = `
+agent:
+  - name: test
+    path: src/modules
+`;
+            expect(hasMatchingAgentPath(yaml, 'src/modules')).toBe('src/modules');
+        });
+        it('should match path with different separators (backslash)', () => {
+            const yaml = `
+agent:
+  - name: test
+    path: src/modules
+`;
+            expect(hasMatchingAgentPath(yaml, 'src\\modules')).toBe('src/modules');
+        });
+        it('should match path with forward slash when yaml has backslash', () => {
+            const yaml = `
+agent:
+  - name: test
+    path: src\\modules
+`;
+            expect(hasMatchingAgentPath(yaml, 'src/modules')).toBe('src\\modules');
+        });
+        it('should match current directory "." path', () => {
+            const yaml = `
+agent:
+  - name: test
+    path: .
+`;
+            expect(hasMatchingAgentPath(yaml, '.')).toBe('.');
+        });
+        it('should match empty path when target is "."', () => {
+            const yaml = `
+agent:
+  - name: test
+    path: ''
+`;
+            expect(hasMatchingAgentPath(yaml, '.')).toBe('');
+        });
+        it('should return null when no matching path found', () => {
+            const yaml = `
+agent:
+  - name: test
+    path: other/path
+`;
+            expect(hasMatchingAgentPath(yaml, 'different/path')).toBeNull();
+        });
+        it('should return first matching path from multiple agents', () => {
+            const yaml = `
+agent:
+  - name: first
+    path: first/path
+  - name: second
+    path: second/path
+`;
+            expect(hasMatchingAgentPath(yaml, 'first/path')).toBe('first/path');
+            expect(hasMatchingAgentPath(yaml, 'second/path')).toBe('second/path');
+        });
+        it('should handle complex YAML with nested objects', () => {
+            const yaml = `
+agent:
+  - name: complex
+    path: complex/path
+    project: my-project
+    prompt: |
+      This is a multi-line
+      prompt
+`;
+            expect(hasMatchingAgentPath(yaml, 'complex/path')).toBe('complex/path');
+        });
+    });
+    describe('extractAgentConfigOrTemplate', () => {
+        it('should return original content for invalid YAML', () => {
+            const invalidYaml = 'invalid: [[[';
+            const result = extractAgentConfigOrTemplate(invalidYaml, 'test');
+            expect(result.content).toBe(invalidYaml);
+            expect(result.isTemplate).toBe(false);
+        });
+        it('should return matching agent config', () => {
+            const yaml = `
+agent:
+  - name: my-agent
+    path: src/modules
+    project: my-project
+    prompt: test prompt
+`;
+            const result = extractAgentConfigOrTemplate(yaml, 'src/modules');
+            expect(result.isTemplate).toBe(false);
+            expect(result.content).toContain('my-agent');
+            expect(result.content).toContain('src/modules');
+            expect(result.content).toContain('my-project');
+        });
+        it('should generate template when no matching agent found', () => {
+            const yaml = `
+agent:
+  - name: other-agent
+    path: other/path
+    project: existing-project
+`;
+            const result = extractAgentConfigOrTemplate(yaml, 'new/path');
+            expect(result.isTemplate).toBe(true);
+            expect(result.projectFromSibling).toBe('existing-project');
+            expect(result.content).toContain('new/path');
+        });
+        it('should generate template with empty project when no agents have project', () => {
+            const yaml = `
+agent:
+  - name: agent1
+    path: path1
+`;
+            const result = extractAgentConfigOrTemplate(yaml, 'new/path');
+            expect(result.isTemplate).toBe(true);
+            expect(result.projectFromSibling).toBeNull();
+            expect(result.content).toContain('project: ""');
+        });
+        it('should match current directory "." path', () => {
+            const yaml = `
+agent:
+  - name: root-agent
+    path: .
+    project: root-project
+`;
+            const result = extractAgentConfigOrTemplate(yaml, '.');
+            expect(result.isTemplate).toBe(false);
+            expect(result.content).toContain('root-agent');
+        });
+        it('should normalize path separators in output', () => {
+            const yaml = `
+agent:
+  - name: test
+    path: src\\modules
+`;
+            const result = extractAgentConfigOrTemplate(yaml, 'src/modules');
+            expect(result.isTemplate).toBe(false);
+            expect(result.content).toContain('src/modules');
+        });
+    });
+    describe('generateEmptyTemplate', () => {
+        it('should generate valid YAML with empty agent', () => {
+            const template = generateEmptyTemplate('any/path');
+            expect(template).toContain('agent:');
+            expect(template).toContain('name: ""');
+            expect(template).toContain('path: ""'); // path is intentionally empty
+            expect(template).toContain('project: ""');
+        });
+        it('should generate consistent output regardless of input path', () => {
+            const template1 = generateEmptyTemplate('path1');
+            const template2 = generateEmptyTemplate('path2');
+            // path is always empty in generated template
+            expect(template1).toBe(template2);
+        });
+    });
+    describe('autoFillPathInYml', () => {
+        it('should return original content for invalid YAML', () => {
+            const invalidYaml = 'invalid: [[[';
+            expect(autoFillPathInYml(invalidYaml, 'test/path')).toBe(invalidYaml);
+        });
+        it('should return original content when no agent key', () => {
+            const yaml = `
+other:
+  - name: test
+`;
+            expect(autoFillPathInYml(yaml, 'test/path')).toBe(yaml);
+        });
+        it('should fill empty path', () => {
+            const yaml = `
+agent:
+  - name: test
+    path: ''
+    project: my-project
+`;
+            const result = autoFillPathInYml(yaml, 'new/path');
+            expect(result).toContain('new/path');
+            expect(result).not.toContain("path: ''");
+        });
+        it('should fill undefined path', () => {
+            const yaml = `
+agent:
+  - name: test
+    project: my-project
+`;
+            const result = autoFillPathInYml(yaml, 'new/path');
+            expect(result).toContain('new/path');
+        });
+        it('should fill null path', () => {
+            const yaml = `
+agent:
+  - name: test
+    path: null
+`;
+            const result = autoFillPathInYml(yaml, 'new/path');
+            expect(result).toContain('new/path');
+        });
+        it('should fill whitespace-only path', () => {
+            const yaml = `
+agent:
+  - name: test
+    path: '   '
+`;
+            const result = autoFillPathInYml(yaml, 'new/path');
+            expect(result).toContain('new/path');
+        });
+        it('should not modify existing non-empty path', () => {
+            const yaml = `
+agent:
+  - name: test
+    path: existing/path
+`;
+            const result = autoFillPathInYml(yaml, 'new/path');
+            expect(result).toContain('existing/path');
+            expect(result).not.toContain('new/path');
+        });
+        it('should handle multiple agents', () => {
+            const yaml = `
+agent:
+  - name: agent1
+    path: ''
+  - name: agent2
+    path: existing/path
+  - name: agent3
+`;
+            const result = autoFillPathInYml(yaml, 'new/path');
+            // agent1 should have path filled
+            expect(result).toContain('new/path');
+        });
+        it('should return original content when no modification needed', () => {
+            const yaml = `
+agent:
+  - name: test
+    path: existing/path
+`;
+            const result = autoFillPathInYml(yaml, 'new/path');
+            expect(result).toBe(yaml);
+        });
+    });
+    describe('loadYmlWithUpwardSearch', () => {
+        const tempRoot = path.join(os.tmpdir(), `aws-yaml-test-${Date.now()}`);
+        const workspacePath = path.join(tempRoot, 'project', 'module', 'src');
+        const relativePath = 'vibe-coding/my.yml';
+        beforeEach(async () => {
+            // 创建目录结构
+            await fs.mkdir(workspacePath, { recursive: true });
+            await fs.mkdir(path.join(tempRoot, 'project', 'module', relativePath.split('/')[0]), {
+                recursive: true,
+            });
+            await fs.mkdir(path.join(tempRoot, 'project', relativePath.split('/')[0]), {
+                recursive: true,
+            });
+            await fs.mkdir(path.join(tempRoot, relativePath.split('/')[0]), { recursive: true });
+        });
+        afterEach(async () => {
+            await fs.rm(tempRoot, { recursive: true, force: true });
+        });
+        it('should return null content when no config file exists', async () => {
+            const result = await loadYmlWithUpwardSearch(workspacePath, relativePath);
+            expect(result.content).toBeNull();
+            expect(result.foundInParent).toBe(false);
+            expect(result.matchedAgentPath).toBeNull();
+        });
+        it('should load config from workspace directory with matching path "."', async () => {
+            const configPath = path.join(workspacePath, relativePath);
+            await fs.mkdir(path.dirname(configPath), { recursive: true });
+            await fs.writeFile(configPath, `
+agent:
+  - name: local-agent
+    path: .
+    project: local-project
+`, 'utf-8');
+            const result = await loadYmlWithUpwardSearch(workspacePath, relativePath);
+            expect(result.content).not.toBeNull();
+            expect(result.content).toContain('local-agent');
+            expect(result.foundInParent).toBe(false);
+            expect(result.matchedAgentPath).toBe('.');
+        });
+        it('should find matching config in parent directory', async () => {
+            // 在 project/module 目录创建配置，匹配 src 路径
+            const parentConfigPath = path.join(tempRoot, 'project', 'module', relativePath);
+            await fs.mkdir(path.dirname(parentConfigPath), { recursive: true });
+            await fs.writeFile(parentConfigPath, `
+agent:
+  - name: module-agent
+    path: src
+    project: module-project
+`, 'utf-8');
+            const result = await loadYmlWithUpwardSearch(workspacePath, relativePath);
+            expect(result.content).not.toBeNull();
+            expect(result.content).toContain('module-agent');
+            expect(result.foundInParent).toBe(true);
+            expect(result.matchedAgentPath).toBe('src');
+        });
+        it('should use last found config when no matching path', async () => {
+            // 在 project/module 目录创建配置，但不匹配 src 路径
+            const parentConfigPath = path.join(tempRoot, 'project', 'module', relativePath);
+            await fs.mkdir(path.dirname(parentConfigPath), { recursive: true });
+            await fs.writeFile(parentConfigPath, `
+agent:
+  - name: other-agent
+    path: other/path
+`, 'utf-8');
+            const result = await loadYmlWithUpwardSearch(workspacePath, relativePath);
+            expect(result.content).not.toBeNull();
+            expect(result.content).toContain('other-agent');
+            expect(result.matchedAgentPath).toBeNull();
+        });
+        it('should prioritize closer matching config', async () => {
+            // 在 workspace 目录创建匹配的配置
+            const localConfigPath = path.join(workspacePath, relativePath);
+            await fs.mkdir(path.dirname(localConfigPath), { recursive: true });
+            await fs.writeFile(localConfigPath, `
+agent:
+  - name: local-agent
+    path: .
+`, 'utf-8');
+            // 在 parent 目录也创建配置
+            const parentConfigPath = path.join(tempRoot, 'project', 'module', relativePath);
+            await fs.writeFile(parentConfigPath, `
+agent:
+  - name: parent-agent
+    path: src
+`, 'utf-8');
+            const result = await loadYmlWithUpwardSearch(workspacePath, relativePath);
+            // 应该使用 local 的配置，因为更近且匹配
+            expect(result.content).toContain('local-agent');
+            expect(result.foundInParent).toBe(false);
+        });
+    });
+});