hyacinth-ai 0.9.6

package/dist/dependency/index.js

@@ -0,0 +1,20 @@
+export { DependencyAnalyzer } from './analyzer.js';
+export { DependencyParser } from './parser.js';
+export { FunctionParser } from './function-parser.js';
+export { DataFlowTracker } from './data-flow-tracker.js';
+import { DependencyAnalyzer } from './analyzer.js';
+/**
+ * 初始化依赖图谱分析器（共享函数，供 CLI/TUI 调用）
+ * 优先加载缓存，缓存无效时全量构建
+ */
+export async function initDependencyAnalyzer(rootDir) {
+    try {
+        const analyzer = new DependencyAnalyzer();
+        await analyzer.analyze(rootDir);
+        return analyzer;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/dependency/parser.d.ts

@@ -0,0 +1,10 @@
+import type { FileDependency } from './types.js';
+export declare class DependencyParser {
+    /** 解析单个文件的依赖 */
+    parseFile(filePath: string, rootDir: string): Promise<FileDependency[]>;
+    /** 解析模块路径为绝对路径 */
+    private resolveModule;
+    /** 递归扫描目录中的所有 .ts/.js/.tsx/.jsx 文件 */
+    scanFiles(dir: string): Promise<string[]>;
+}
+//# sourceMappingURL=parser.d.ts.map

package/dist/dependency/parser.js

@@ -0,0 +1,93 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const IMPORT_REGEX = /import\s+(?:type\s+)?(?:\{([^}]*)\}|\*\s+as\s+\w+|(\w+))\s+from\s+['"]([^'"]+)['"]/g;
+const REQUIRE_REGEX = /(?:const|let|var)\s+(?:\{([^}]*)\}|(\w+))\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+const DYNAMIC_IMPORT_REGEX = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+export class DependencyParser {
+    /** 解析单个文件的依赖 */
+    async parseFile(filePath, rootDir) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const deps = [];
+            // 静态 import
+            for (const match of content.matchAll(IMPORT_REGEX)) {
+                const symbolsStr = match[1] || match[2] || '';
+                const modulePath = match[3];
+                const symbols = symbolsStr ? symbolsStr.split(',').map(s => s.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean) : [];
+                const resolved = await this.resolveModule(modulePath, filePath, rootDir);
+                if (resolved) {
+                    deps.push({ from: filePath, to: resolved, importType: 'static', symbols });
+                }
+            }
+            // require
+            for (const match of content.matchAll(REQUIRE_REGEX)) {
+                const symbolsStr = match[1] || match[2] || '';
+                const modulePath = match[3];
+                const symbols = symbolsStr ? symbolsStr.split(',').map(s => s.trim().split(/\s*:\s*/)[0].trim()).filter(Boolean) : [];
+                const resolved = await this.resolveModule(modulePath, filePath, rootDir);
+                if (resolved) {
+                    deps.push({ from: filePath, to: resolved, importType: 'require', symbols });
+                }
+            }
+            // dynamic import
+            for (const match of content.matchAll(DYNAMIC_IMPORT_REGEX)) {
+                const modulePath = match[1];
+                const resolved = await this.resolveModule(modulePath, filePath, rootDir);
+                if (resolved) {
+                    deps.push({ from: filePath, to: resolved, importType: 'dynamic', symbols: [] });
+                }
+            }
+            return deps;
+        }
+        catch {
+            return [];
+        }
+    }
+    /** 解析模块路径为绝对路径 */
+    async resolveModule(modulePath, fromFile, rootDir) {
+        // 只处理相对路径（./ 或 ../）
+        if (!modulePath.startsWith('.'))
+            return null;
+        const dir = path.dirname(fromFile);
+        const resolved = path.resolve(dir, modulePath);
+        // 尝试添加扩展名
+        const extensions = ['.ts', '.tsx', '.js', '.jsx'];
+        for (const ext of extensions) {
+            const withExt = resolved + ext;
+            try {
+                await fs.access(withExt);
+                return withExt;
+            }
+            catch { }
+        }
+        // 尝试 index 文件
+        for (const ext of extensions) {
+            const indexPath = path.join(resolved, `index${ext}`);
+            try {
+                await fs.access(indexPath);
+                return indexPath;
+            }
+            catch { }
+        }
+        return null;
+    }
+    /** 递归扫描目录中的所有 .ts/.js/.tsx/.jsx 文件 */
+    async scanFiles(dir) {
+        const files = [];
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // 跳过 node_modules, dist, .git, coverage
+                if (['node_modules', 'dist', '.git', 'coverage'].includes(entry.name))
+                    continue;
+                files.push(...await this.scanFiles(fullPath));
+            }
+            else if (/\.(ts|tsx|js|jsx)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
+                files.push(fullPath);
+            }
+        }
+        return files;
+    }
+}
+//# sourceMappingURL=parser.js.map

package/dist/dependency/types.d.ts

@@ -0,0 +1,57 @@
+/** 文件级依赖边 */
+export interface FileDependency {
+    /** 源文件（绝对路径） */
+    from: string;
+    /** 目标文件（绝对路径） */
+    to: string;
+    /** 导入类型 */
+    importType: 'static' | 'dynamic' | 'require';
+    /** 导入的符号列表（如果可解析） */
+    symbols: string[];
+}
+/** 依赖图（内存结构，含 Map/Set） */
+export interface DependencyGraph {
+    /** 项目根目录 */
+    rootDir: string;
+    /** 所有已解析的文件（绝对路径集合） */
+    files: Set<string>;
+    /** 文件级依赖边列表 */
+    dependencies: FileDependency[];
+    /** 正向索引：文件 → 它依赖的文件列表 */
+    dependents: Map<string, string[]>;
+    /** 反向索引：文件 → 依赖它的文件列表 */
+    dependees: Map<string, string[]>;
+}
+/** 依赖图的可序列化形式（用于持久化） */
+export interface SerializedDependencyGraph {
+    /** 缓存格式版本 */
+    version: number;
+    /** 项目根目录 */
+    rootDir: string;
+    /** 构建时间戳（ISO 8601） */
+    builtAt: string;
+    /** 所有已解析的文件 */
+    files: string[];
+    /** 文件级依赖边列表 */
+    dependencies: FileDependency[];
+    /** 正向索引 */
+    dependents: Record<string, string[]>;
+    /** 反向索引 */
+    dependees: Record<string, string[]>;
+    /** 文件哈希映射（相对路径 → content hash，用于增量更新检测） */
+    fileHashes: Record<string, string>;
+}
+/** 影响面分析结果 */
+export interface ImpactResult {
+    /** 被修改的文件 */
+    sourceFile: string;
+    /** 可选：被修改的符号 */
+    symbol?: string;
+    /** 直接依赖（深度 1） */
+    directImpacts: string[];
+    /** 间接依赖（深度 2+） */
+    indirectImpacts: string[];
+    /** 所有受影响文件（直接+间接，按深度排序） */
+    allImpacts: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/dependency/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/env/env-collector.d.ts

@@ -0,0 +1,45 @@
+export interface SystemEnvInfo {
+    os: string;
+    arch: string;
+    cpuModel: string;
+    cpuCores: number;
+    totalMemoryGB: string;
+    gpu: string;
+    python: string;
+    nodeVersion: string;
+    shell: string;
+}
+export declare function collectSystemInfo(): SystemEnvInfo;
+export declare function getSystemInfo(): SystemEnvInfo | null;
+/** 渠道信息（会注入到 System Prompt 的 environment section） */
+export interface ChannelsInfo {
+    /** 渠道名称（如 'feishu'） */
+    name: string;
+    /** 渠道显示名称（如 '飞书'） */
+    displayName: string;
+    /** 连接模式 */
+    connectionMode: string;
+    /** DM 策略 */
+    dmPolicy: string;
+    /** 群组策略 */
+    groupPolicy: string;
+    /** 群聊是否需要 @提及 */
+    requireMention: boolean;
+    /** 当前连接的 sessionId */
+    sessionId?: string;
+    /** 是否群聊 */
+    isGroup?: boolean;
+}
+export declare function formatEnvInfo(info: SystemEnvInfo, channels?: ChannelsInfo[]): string;
+/**
+ * 构建 environment section 内容。
+ * 拼接顺序：静态模板文件 → 动态系统信息 → 渠道信息。
+ *
+ * 静态模板文件位于 prompts/environment/*.md，
+ * 外部覆盖路径：.agent/prompts/environment/*.md。
+ * 支持 {{cwd}} 模板变量。
+ */
+export declare function buildEnvironmentSection(info: SystemEnvInfo, channels?: ChannelsInfo[], options?: {
+    cwd?: string;
+}): string;
+//# sourceMappingURL=env-collector.d.ts.map

package/dist/env/env-collector.js

@@ -0,0 +1,221 @@
+import os from 'node:os';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { createLogger } from '../logging/logger.js';
+import { loadPrompt, renderPrompt } from '../prompts/loader.js';
+const logger = createLogger('env-collector');
+let cachedInfo = null;
+function safeExec(cmd, fallback = '(未检测到)') {
+    try {
+        const result = execSync(cmd, { encoding: 'utf-8', timeout: 5000 }).trim();
+        return result || fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+function detectGPU() {
+    if (process.platform === 'win32') {
+        // ── 方案1: nvidia-smi — N 卡优先，VRAM 准确不溢出（Win32_VideoController.AdapterRAM 是 uint32，>4GB 截断）──
+        const nvidiaOutput = safeExec('nvidia-smi --query-gpu=name,memory.total --format=csv,noheader', '');
+        if (nvidiaOutput && nvidiaOutput !== '(未检测到)') {
+            const firstLine = nvidiaOutput.split('\n')[0].trim();
+            const parts = firstLine.split(',').map(s => s.trim());
+            if (parts.length >= 2) {
+                const vramMatch = parts[1].match(/(\d+)/);
+                const vramMB = vramMatch ? parseInt(vramMatch[1], 10) : 0;
+                if (vramMB > 0) {
+                    const vramGB = (vramMB / 1024).toFixed(1);
+                    return `${parts[0]} (VRAM ${vramGB} GB)`;
+                }
+            }
+            return firstLine;
+        }
+        // ── 方案2: Get-CimInstance（没 N 卡驱动时回退，如 AMD/Intel 独显）──
+        const psCmd = 'Get-CimInstance Win32_VideoController | ForEach-Object { "$($_.Name)||$($_.AdapterRAM)" }';
+        const output = safeExec(`powershell -Command "${psCmd}"`, '');
+        if (output && output !== '(未检测到)') {
+            const lines = output.split('\n').map(l => l.trim()).filter(Boolean);
+            const realCards = lines.filter(l => !l.includes('Microsoft Basic') &&
+                !l.includes('Microsoft Remote') &&
+                !l.includes('Microsoft Hyper-V') &&
+                !l.includes('Remote Display'));
+            for (const line of [...realCards, ...lines]) {
+                const sepIdx = line.indexOf('||');
+                const name = sepIdx >= 0 ? line.substring(0, sepIdx).trim() : line.trim();
+                const vramStr = sepIdx >= 0 ? line.substring(sepIdx + 2).trim() : '';
+                const vramBytes = parseInt(vramStr, 10);
+                if (vramBytes && !isNaN(vramBytes) && vramBytes > 0 && vramBytes < 1_000_000_000_000) {
+                    const vramGB = (vramBytes / 1024 / 1024 / 1024).toFixed(1);
+                    return `${name} (VRAM ${vramGB} GB)`;
+                }
+                if (name && name !== '(未检测到)') {
+                    return name;
+                }
+            }
+        }
+    }
+    if (process.platform === 'linux') {
+        const output = safeExec('lspci | grep -i vga', '');
+        if (output) {
+            const nameMatch = output.match(/:\s*(.+)/);
+            return nameMatch ? nameMatch[1].trim() : output;
+        }
+        const nvidiaOutput = safeExec('nvidia-smi --query-gpu=name,memory.total --format=csv,noheader', '');
+        if (nvidiaOutput && nvidiaOutput !== '(未检测到)') {
+            return nvidiaOutput.split('\n')[0].trim().replace(',', ' (VRAM') + ')';
+        }
+    }
+    if (process.platform === 'darwin') {
+        return safeExec('system_profiler SPDisplaysDataType 2>/dev/null | grep "Chipset Model" | head -1 | sed "s/.*: //"');
+    }
+    return '(未检测到)';
+}
+function detectPython() {
+    for (const cmd of ['python3 --version', 'python --version']) {
+        const result = safeExec(cmd, '');
+        if (result && result !== '(未检测到)') {
+            return result.replace(/^Python\s+/i, '').trim();
+        }
+    }
+    return '(未安装)';
+}
+function detectShell() {
+    if (process.platform === 'win32') {
+        const psVersion = safeExec('powershell -Command "$PSVersionTable.PSVersion.ToString()"', '');
+        if (psVersion && psVersion !== '(未检测到)') {
+            return `PowerShell ${psVersion}`;
+        }
+        return 'Command Prompt';
+    }
+    return process.env.SHELL || '/bin/sh';
+}
+function detectCPUModel() {
+    if (process.platform === 'win32') {
+        const name = safeExec('powershell -Command "(Get-CimInstance Win32_Processor).Name"', '').replace(/[\r\n]+/g, '').trim();
+        if (name && name !== '(未检测到)')
+            return name;
+    }
+    // Linux/macOS fallback: Node.js 的 os.cpus()[0].model 已够用
+    const firstCpu = os.cpus()[0];
+    return firstCpu?.model?.trim() || os.arch();
+}
+export function collectSystemInfo() {
+    if (cachedInfo)
+        return cachedInfo;
+    const totalMemBytes = os.totalmem();
+    const totalMemGB = (totalMemBytes / 1024 / 1024 / 1024).toFixed(1);
+    const osName = process.platform === 'win32'
+        ? safeExec('powershell -Command "(Get-CimInstance Win32_OperatingSystem).Caption"', os.type()).replace(/[\r\n]+/g, '').trim()
+        : `${os.type()} ${os.release()}`;
+    cachedInfo = {
+        os: osName,
+        arch: os.arch(),
+        cpuModel: detectCPUModel(),
+        cpuCores: os.cpus().length,
+        totalMemoryGB: totalMemGB,
+        gpu: detectGPU(),
+        python: detectPython(),
+        nodeVersion: process.version,
+        shell: detectShell(),
+    };
+    logger.info('System environment collected', { ...cachedInfo });
+    return cachedInfo;
+}
+export function getSystemInfo() {
+    return cachedInfo;
+}
+export function formatEnvInfo(info, channels) {
+    return buildEnvironmentSection(info, channels);
+}
+// ── 拼接式 environment 构建 ─────────────────────────────────────────
+/**
+ * 构建 environment section 内容。
+ * 拼接顺序：静态模板文件 → 动态系统信息 → 渠道信息。
+ *
+ * 静态模板文件位于 prompts/environment/*.md，
+ * 外部覆盖路径：.agent/prompts/environment/*.md。
+ * 支持 {{cwd}} 模板变量。
+ */
+export function buildEnvironmentSection(info, channels, options) {
+    const parts = [];
+    // 1. 静态模板文件
+    const staticContent = loadEnvironmentStaticFiles(options?.cwd);
+    if (staticContent) {
+        parts.push(staticContent);
+    }
+    // 2. 动态系统信息
+    parts.push(formatDynamicEnvInfo(info));
+    // 3. 渠道信息
+    if (channels && channels.length > 0) {
+        parts.push(formatChannelsInfo(channels));
+    }
+    return parts.filter(Boolean).join('\n\n');
+}
+// ── 动态系统信息 ──
+function formatDynamicEnvInfo(info) {
+    const lines = [
+        `运行环境:`,
+        `- 操作系统: ${info.os}`,
+        `- 架构: ${info.arch}`,
+        `- CPU: ${info.cpuModel} (${info.cpuCores} 核)`,
+        `- 内存: ${info.totalMemoryGB} GB`,
+        `- 显卡: ${info.gpu}`,
+        `- Python: ${info.python}`,
+        `- Node.js: ${info.nodeVersion}`,
+        `- Shell: ${info.shell}`,
+    ];
+    return lines.join('\n');
+}
+// ── 渠道信息 ──
+function formatChannelsInfo(channels) {
+    const lines = ['已连接的渠道:'];
+    for (const ch of channels) {
+        const connInfo = ch.isGroup ? '群聊' : '私聊';
+        lines.push(`- ${ch.displayName} (${ch.name}) [${connInfo}]:`);
+        lines.push(`  连接模式: ${ch.connectionMode}`);
+        lines.push(`  DM策略: ${ch.dmPolicy} | 群组策略: ${ch.groupPolicy}`);
+        lines.push(`  群聊需@提及: ${ch.requireMention ? '是' : '否'}`);
+        if (ch.sessionId) {
+            lines.push(`  当前会话: ${ch.sessionId}`);
+        }
+        lines.push(`  回复规则: 通过该渠道的 reply() 方法回复用户，每轮对话必须回复`);
+    }
+    return lines.join('\n');
+}
+// ── 静态模板文件加载 ──
+/**
+ * 通过统一的 loadPrompt 系统加载 prompts/environment/ 下的静态内容。
+ * 使用 skipCache: true 实现热加载 —— 编辑 .agent/prompts/environment/*.md 后无需重启、无需编译。
+ *
+ * 查找顺序（由 loadPrompt 统一管理）：
+ * 1. .agent/prompts/environment/{name}.md（用户覆盖，热编辑）
+ * 2. dist/prompts/environment/{name}.md（内置默认）
+ *
+ * 支持 {{cwd}} 模板变量（此处手动渲染）。
+ */
+function loadEnvironmentStaticFiles(cwd) {
+    // 环境和渠道相关的提示文件，按需扩展此列表
+    const envFiles = ['environment'];
+    const contents = [];
+    for (const name of envFiles) {
+        try {
+            let content = loadPrompt(`environment/${name}`, { skipCache: true });
+            // 手动渲染 {{cwd}} 和 {{globalConfigDir}}（runtime:env 不走 resolveTemplate，需要自行处理）
+            const renderVars = {};
+            if (cwd)
+                renderVars.cwd = cwd;
+            renderVars.globalConfigDir = path.join(os.homedir(), '.agent').replace(/\\/g, '/');
+            content = renderPrompt(content, renderVars);
+            content = content.trim();
+            if (content) {
+                contents.push(content);
+            }
+        }
+        catch {
+            // 文件不存在则跳过
+        }
+    }
+    return contents.length > 0 ? contents.join('\n\n') : null;
+}
+//# sourceMappingURL=env-collector.js.map

package/dist/env/index.d.ts

@@ -0,0 +1,3 @@
+export { collectSystemInfo, getSystemInfo, formatEnvInfo, buildEnvironmentSection, } from './env-collector.js';
+export type { SystemEnvInfo, ChannelsInfo } from './env-collector.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/env/index.js

@@ -0,0 +1,2 @@
+export { collectSystemInfo, getSystemInfo, formatEnvInfo, buildEnvironmentSection, } from './env-collector.js';
+//# sourceMappingURL=index.js.map

package/dist/event-store.d.ts

@@ -0,0 +1,27 @@
+export interface ConversationEvent {
+    type: 'user_input' | 'text' | 'thinking' | 'tool_call' | 'tool_result' | 'error' | 'stop' | 'usage';
+    content?: string;
+    name?: string;
+    id?: string;
+    input?: Record<string, unknown>;
+    tool_use_id?: string;
+    message?: string;
+    reason?: string;
+    input_tokens?: number;
+    output_tokens?: number;
+    timestamp: string;
+}
+/**
+ * Append a single event to the session's events.jsonl file.
+ */
+export declare function appendEvent(sessionDir: string, event: ConversationEvent): Promise<void>;
+/**
+ * Read the most recent N events from the session's events.jsonl.
+ * Returns events sorted from oldest to newest.
+ */
+export declare function readRecentEvents(sessionDir: string, limit?: number): Promise<ConversationEvent[]>;
+/**
+ * Get the total number of events in the session.
+ */
+export declare function getEventCount(sessionDir: string): Promise<number>;
+//# sourceMappingURL=event-store.d.ts.map

package/dist/event-store.js

@@ -0,0 +1,71 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createReadStream } from 'node:fs';
+import readline from 'node:readline';
+/**
+ * Append a single event to the session's events.jsonl file.
+ */
+export async function appendEvent(sessionDir, event) {
+    const filePath = path.join(sessionDir, 'events.jsonl');
+    const line = JSON.stringify(event) + '\n';
+    await fs.appendFile(filePath, line, 'utf-8');
+}
+/**
+ * Read the most recent N events from the session's events.jsonl.
+ * Returns events sorted from oldest to newest.
+ */
+export async function readRecentEvents(sessionDir, limit = 50) {
+    const filePath = path.join(sessionDir, 'events.jsonl');
+    try {
+        await fs.access(filePath);
+    }
+    catch {
+        return []; // No events file yet
+    }
+    // Read all lines, take the last N
+    const lines = [];
+    const rl = readline.createInterface({
+        input: createReadStream(filePath, { encoding: 'utf-8' }),
+        crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+        if (line.trim()) {
+            lines.push(line.trim());
+        }
+    }
+    // Take last N lines
+    const recent = lines.slice(-limit);
+    return recent
+        .map(line => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((e) => e !== null);
+}
+/**
+ * Get the total number of events in the session.
+ */
+export async function getEventCount(sessionDir) {
+    const filePath = path.join(sessionDir, 'events.jsonl');
+    try {
+        await fs.access(filePath);
+    }
+    catch {
+        return 0;
+    }
+    let count = 0;
+    const rl = readline.createInterface({
+        input: createReadStream(filePath, { encoding: 'utf-8' }),
+        crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+        if (line.trim())
+            count++;
+    }
+    return count;
+}
+//# sourceMappingURL=event-store.js.map

package/dist/evolution/git-manager.d.ts

@@ -0,0 +1,46 @@
+export interface CommitInfo {
+    hash: string;
+    message: string;
+    date: string;
+    branch?: string;
+}
+export interface GitContextEntry {
+    hash: string;
+    message: string;
+    date: string;
+    branch: string;
+    files: string[];
+}
+export declare class GitManager {
+    private repoPath;
+    constructor(repoPath: string);
+    /** Run a raw git command in repoPath. Public for use by TurnRecorder etc. */
+    git(args: string[]): Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    isRepo(): Promise<boolean>;
+    init(): Promise<void>;
+    commit(message: string): Promise<string>;
+    createBranch(name: string): Promise<void>;
+    checkout(ref: string): Promise<void>;
+    merge(branch: string): Promise<void>;
+    abortMerge(): Promise<void>;
+    diff(ref?: string): Promise<string>;
+    log(limit?: number): Promise<CommitInfo[]>;
+    resetHard(ref: string): Promise<void>;
+    getCurrentBranch(): Promise<string>;
+    hasUncommittedChanges(): Promise<boolean>;
+    deleteBranch(name: string): Promise<void>;
+    getRepoPath(): string;
+    logGrep(pattern: string, limit?: number): Promise<CommitInfo[]>;
+    diffNames(ref?: string): Promise<string[]>;
+    diffStat(ref?: string): Promise<string>;
+    logFile(file: string, limit?: number): Promise<CommitInfo[]>;
+    revertCommit(hash: string): Promise<string>;
+    stash(): Promise<void>;
+    stashPop(): Promise<void>;
+    private gitSafe;
+    searchContext(keywords: string[], currentBranch: string, limit?: number): Promise<GitContextEntry[]>;
+}
+//# sourceMappingURL=git-manager.d.ts.map