@ticatec/omniflow-core 0.1.0

package/README.md

@@ -0,0 +1,264 @@
+# @omniflow/core
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D20.0.0-brightgreen.svg)](https://nodejs.org/)
+
+[中文文档](./README_CN.md)
+
+**@omniflow/core** is the foundational core package for the OmniFlow CI/CD orchestrator. It provides execution context management, standard operational primitives (`shell`, `ssh`, `git`, `docker`), sensitive credential masking, and an extensible Toolchain SPI.
+
+---
+
+## Highlights
+
+- **Static Decoupled Primitives**: Import `shell`, `ssh`, `git`, and `docker` directly. No cumbersome `ctx.commands` or object passing required.
+- **Transparent Context Injection (`AsyncLocalStorage`)**: Primitives automatically resolve `cwd`, environment variables `env`, and `logger` from the active async call context.
+- **Automatic `--dry-run` Interception**: When running in simulation mode, destructive operations are intercepted by the core layer automatically, logged safely, and mocked without extra boilerplate in plugins.
+- **Automatic Secret Masking**: Credentials and sensitive tokens in logs and commands are automatically masked (`***`).
+- **Extensible Toolchain SPI**: Built-in support for Maven, Gradle, and Node.js (pnpm / yarn / npm / bun), with priority-based override and registration for custom language toolchains (e.g. Go, Rust, Python).
+
+---
+
+## Architecture Overview
+
+```
+┌────────────────────────────────────────────────────────┐
+│             Plugin / Pipeline Command                  │
+│  import { shell, ssh, git, docker } from '@omniflow/core'│
+└─────────────────────────┬──────────────────────────────┘
+                          │ calls primitives
+                          ▼
+┌────────────────────────────────────────────────────────┐
+│                   @omniflow/core                       │
+│  ┌──────────────────────────────────────────────────┐  │
+│  │ AsyncLocalStorage Context (cwd, env, dryRun, log)│  │
+│  └──────────────────────┬───────────────────────────┘  │
+│                         ▼                              │
+│       [Dry-Run Check] ──► [Credential Masker]          │
+│                         ▼                              │
+│  ┌───────────────┬──────────────┬───────────────────┐  │
+│  │ shell.run/sh  │ ssh.exec/cp  │ git & docker ops  │  │
+│  └───────────────┴──────────────┴───────────────────┘  │
+│                         ▼                              │
+│  ┌──────────────────────────────────────────────────┐  │
+│  │ Toolchain SPI (Maven, Gradle, Node, Custom...)   │  │
+│  └──────────────────────────────────────────────────┘  │
+└────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Installation
+
+```bash
+pnpm add @omniflow/core
+# or
+npm install @omniflow/core
+```
+
+Requires **Node.js >= 20.0.0**.
+
+---
+
+## Core Primitives
+
+### 1. `shell`
+Executes local shell commands using safe tagged template literals or string execution.
+
+```typescript
+import { shell } from '@omniflow/core'
+
+// Tagged template execution (safely splits arguments without shell injection vulnerabilities)
+await shell.run`mvn clean package -DskipTests`
+
+// Explicit cwd or options
+await shell.run({ cwd: '/workspace/service-a' })`npm run build`
+
+// Shell execution for compound commands (pipes, redirections, &&, ||)
+await shell.sh('cat coverage/lcov.info | grep -v "test" > coverage/filtered.info')
+
+// Capture output without throwing on non-zero exit
+const res = await shell.output('git status --porcelain')
+console.log(res.stdout, res.exitCode)
+```
+
+**Dry-Run & Context Awareness**:
+Inside a `runWithContext` scope with `dryRun: true`, `shell.run` and `shell.sh` will print the planned command to the context logger and return mock results (`{ stdout: '[dry-run] ...', exitCode: 0 }`) without executing.
+
+---
+
+### 2. `ssh`
+Executes remote commands and securely copies files via SSH/SCP with built-in connection pooling.
+
+```typescript
+import { ssh } from '@omniflow/core'
+
+const target = {
+  host: 'prod-app-01.internal',
+  user: 'deploy',
+  port: 22,
+  privateKey: process.env.SSH_PRIVATE_KEY
+}
+
+// Remote command execution
+await ssh.exec(target, 'systemctl restart my-app.service')
+
+// File transfer (SCP)
+await ssh.cp(target, 'dist/app.tar.gz', '/opt/deploy/app.tar.gz')
+```
+
+---
+
+### 3. `git`
+Provides essential Git repository inspection and workspace lifecycle management.
+
+```typescript
+import { git } from '@omniflow/core'
+
+const branch = await git.currentBranch()
+const commit = await git.currentCommit()
+const dirty = await git.isDirty()
+
+// Workspace promotion and synchronization
+await git.fetch({ remote: 'origin', branch: 'main' })
+await git.resetHard('origin/main')
+await git.clean()
+await git.checkout('release/v1.0')
+```
+
+---
+
+### 4. `docker`
+Encapsulates common container build, tag, push, and compose orchestration.
+
+```typescript
+import { docker } from '@omniflow/core'
+
+// Build and tag
+await docker.build({
+  image: 'registry.internal/api',
+  tag: 'v1.2.0',
+  dockerfile: 'Dockerfile.prod',
+  buildArgs: { NODE_ENV: 'production' }
+})
+
+// Push to registry
+await docker.push('registry.internal/api:v1.2.0')
+
+// Docker Compose management
+await docker.composeUp({ file: 'docker-compose.prod.yml', detached: true })
+await docker.composeDown({ file: 'docker-compose.prod.yml' })
+```
+
+---
+
+## Execution Context & AsyncLocalStorage
+
+The execution context manages runtime configuration, logging, and environment variables across asynchronous chains.
+
+### Runner / Orchestrator Example:
+```typescript
+import { runWithContext, createMockContext } from '@omniflow/core'
+
+const ctx = {
+  runId: 'run-20260912-001',
+  project: 'order-service',
+  env: 'staging',
+  dryRun: false,
+  workspace: '/workspaces/order-service',
+  variables: { REGISTRY: 'harbor.company.com' },
+  secrets: { DOCKER_TOKEN: 'secret-token-value' },
+  logger: {
+    info: (msg) => console.log(`[INFO] ${msg}`),
+    warn: (msg) => console.warn(`[WARN] ${msg}`),
+    error: (msg) => console.error(`[ERROR] ${msg}`),
+    debug: (msg) => console.debug(`[DEBUG] ${msg}`)
+  }
+}
+
+await runWithContext(ctx, async () => {
+  // Any function called here (directly or deeply nested) can call getContext()
+  // and primitives automatically use ctx.workspace, ctx.env, ctx.dryRun, and ctx.logger
+  await executePipelineSteps()
+})
+```
+
+### Plugin / Step Example:
+```typescript
+import { getContext, tryGetContext, shell } from '@omniflow/core'
+
+export async function myPluginTask() {
+  const ctx = getContext() // Throws if outside runWithContext
+  ctx.logger.info(`Building in ${ctx.workspace} for ${ctx.env}`)
+
+  await shell.run`npm test`
+}
+```
+
+---
+
+## Toolchain SPI
+
+OmniFlow Core abstracts language build systems using a clean Service Provider Interface (SPI).
+
+### Built-in Toolchains
+1. **Maven** (`MavenToolchain`): Detects `pom.xml`, parses groupId/artifactId/version, runs `./mvnw` or `mvn`.
+2. **Gradle** (`GradleToolchain`): Detects `build.gradle` / `build.gradle.kts`, resolves Gradle Wrapper `./gradlew`, generates build commands.
+3. **Node** (`NodeToolchain`): Detects `package.json`, auto-selects `pnpm`, `yarn`, `npm`, or `bun` from lockfiles, parses package coordinates.
+
+### Detecting and Using Toolchains:
+```typescript
+import { resolveToolchain } from '@omniflow/core'
+
+const { provider, detection } = await resolveToolchain('/path/to/project')
+console.log(`Detected toolchain ${provider.name} because: ${detection.reason}`)
+
+const info = await provider.projectInfo('/path/to/project')
+console.log(`Project: ${info.name}@${info.version}`)
+
+// Execute dependency install and build
+await provider.install('/path/to/project')
+await provider.build('/path/to/project', ['-DskipTests'])
+```
+
+### Registering Custom / Overriding Toolchains:
+```typescript
+import { registerToolchain, type ToolchainProvider } from '@omniflow/core'
+
+const goToolchain: ToolchainProvider = {
+  name: 'go',
+  priority: 20, // Higher priority takes precedence over lower priority providers
+  detect: async (cwd) => {
+    // Check if go.mod exists
+    return { detected: true, confidence: 0.95 }
+  },
+  getProjectInfo: async (cwd) => ({
+    name: 'user-service',
+    version: '1.0.0'
+  }),
+  getBuildCommand: (cwd, options) => 'go build -v -o dist/app ./cmd/main.go'
+}
+
+registerToolchain(goToolchain)
+```
+
+> For a complete step-by-step guide on creating custom toolchains (Go, Rust) and enterprise overrides, see [Toolchain Extension Guide](./docs/toolchain-extension.md).
+
+---
+
+## Subpath Exports
+
+`@omniflow/core` supports clean subpath imports in accordance with modern ESM standards:
+
+| Export Path | Description |
+|:---|:---|
+| `@omniflow/core` | Full bundle: context, primitives, toolchain SPI, and utils |
+| `@omniflow/core/context` | Execution context, `AsyncLocalStorage`, and mocking utilities |
+| `@omniflow/core/primitives` | Core commands (`shell`, `ssh`, `git`, `docker`) |
+| `@omniflow/core/toolchain` | Toolchain SPI, registry, and built-in providers |
+
+---
+
+## License
+
+MIT © [Ticatec](https://github.com/ticatec)

package/README_CN.md

@@ -0,0 +1,265 @@
+# @omniflow/core
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D20.0.0-brightgreen.svg)](https://nodejs.org/)
+
+[English](./README.md)
+
+**@omniflow/core** 是 OmniFlow CI/CD 统一编排器的基础核心库。它提供了运行时执行上下文管理、标准化命令原语（`shell`、`ssh`、`git`、`docker`）、敏感凭据脱敏以及可扩展的构建工具链 SPI（Toolchain SPI）。
+
+---
+
+## 核心特性
+
+- **原语与上下文解耦**：开发者与插件作者可直接通过静态 `import { shell, ssh, git, docker } from '@omniflow/core'` 导入命令，无需在函数间层层显式传递 `ctx`，移除原有的 `ctx.commands` 耦合。
+- **透明上下文注入 (`AsyncLocalStorage`)**：底层基于 Node.js 原生 `AsyncLocalStorage`，基础原语在被调用时，会自动从当前的异步执行链路中解析 `cwd`（工作目录）、`env`（环境变量）、`dryRun`（模拟模式）与 `logger`。
+- **开箱即用的 `--dry-run` 拦截保护**：在模拟运行模式下，破坏性操作（执行脚本、远程 SSH、推送镜像等）均由 Core 层底层自动拦截，安全记录日志并返回模拟结果，插件层无需编写冗余的 `if (ctx.dryRun)` 逻辑。
+- **敏感信息自动脱敏 (Masking)**：命令参数与环境变量中包含的敏感词（如 `token`、`secret`、`password`、`key`）在格式化及输出至日志时自动替换为 `***`，杜绝日志泄露。
+- **统一可扩展的 Toolchain SPI**：内置对 Maven、Gradle、Node.js（自动识别 pnpm / yarn / npm / bun）的识别与命令生成，同时支持第三方插件按优先级注册与覆盖扩展（如 Go、Rust、Python 等）。
+
+---
+
+## 架构概览
+
+```
+┌────────────────────────────────────────────────────────┐
+│                   插件 / 流水线命令                      │
+│  import { shell, ssh, git, docker } from '@omniflow/core'│
+└─────────────────────────┬──────────────────────────────┘
+                          │ 直接调用底层原语
+                          ▼
+┌────────────────────────────────────────────────────────┐
+│                   @omniflow/core                       │
+│  ┌──────────────────────────────────────────────────┐  │
+│  │ AsyncLocalStorage 上下文 (cwd, env, dryRun, log)  │  │
+│  └──────────────────────┬───────────────────────────┘  │
+│                         ▼                              │
+│       [Dry-Run 模式拦截] ──► [敏感凭据自动脱敏]        │
+│                         ▼                              │
+│  ┌───────────────┬──────────────┬───────────────────┐  │
+│  │ shell.run/sh  │ ssh.exec/cp  │ git & docker 操作 │  │
+│  └───────────────┴──────────────┴───────────────────┘  │
+│                         ▼                              │
+│  ┌──────────────────────────────────────────────────┐  │
+│  │ Toolchain SPI (Maven, Gradle, Node, 自定义工具链) │  │
+│  └──────────────────────────────────────────────────┘  │
+└────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 安装
+
+```bash
+pnpm add @omniflow/core
+# 或
+npm install @omniflow/core
+```
+
+运行环境要求：**Node.js >= 20.0.0**。
+
+---
+
+## 核心原语说明
+
+### 1. `shell`
+用于执行本地 Shell 命令，推荐使用标签模板字符串（Tagged Template Literals）方式执行，原生防止命令行注入。
+
+```typescript
+import { shell } from '@omniflow/core'
+
+// 标签模板安全执行（自动拆分参数，防止参数注入）
+await shell.run`mvn clean package -DskipTests`
+
+// 支持显式指定工作目录或执行选项
+await shell.run({ cwd: '/workspace/service-a' })`npm run build`
+
+// Shell 复合命令（支持管道、重定向、&&、|| 等复合语法）
+await shell.sh('cat coverage/lcov.info | grep -v "test" > coverage/filtered.info')
+
+// 静默执行并捕获输出（非零退出码不主动抛出异常）
+const res = await shell.output('git status --porcelain')
+console.log(res.stdout, res.exitCode)
+```
+
+**Dry-Run 机制**：
+在包含 `dryRun: true` 的 `runWithContext` 环境中，`shell.run` 和 `shell.sh` 会自动将待执行命令格式化并打入当前日志，同时返回 `{ stdout: '[dry-run] ...', exitCode: 0 }`，不会在系统上实际派生子进程。
+
+---
+
+### 2. `ssh`
+提供跨节点远程命令执行与基于 SCP 的文件安全传输，内置连接池复用机制。
+
+```typescript
+import { ssh } from '@omniflow/core'
+
+const target = {
+  host: 'prod-app-01.internal',
+  user: 'deploy',
+  port: 22,
+  privateKey: process.env.SSH_PRIVATE_KEY
+}
+
+// 远程执行命令
+await ssh.exec(target, 'systemctl restart my-app.service')
+
+// 文件安全分发 (SCP)
+await ssh.cp(target, 'dist/app.tar.gz', '/opt/deploy/app.tar.gz')
+```
+
+---
+
+### 3. `git`
+提供仓库状态感知、分支切换、远端同步与工作区重置原语。
+
+```typescript
+import { git } from '@omniflow/core'
+
+const branch = await git.currentBranch()
+const commit = await git.currentCommit()
+const dirty = await git.isDirty()
+
+// 晋升与工作区同步
+await git.fetch({ remote: 'origin', branch: 'main' })
+await git.resetHard('origin/main')
+await git.clean()
+await git.checkout('release/v1.0')
+```
+
+---
+
+### 4. `docker`
+封装常见的容器构建、打标签、推送与 Compose 编排生命周期。
+
+```typescript
+import { docker } from '@omniflow/core'
+
+// 镜像构建
+await docker.build({
+  image: 'registry.internal/api',
+  tag: 'v1.2.0',
+  dockerfile: 'Dockerfile.prod',
+  buildArgs: { NODE_ENV: 'production' }
+})
+
+// 推送到远程仓库
+await docker.push('registry.internal/api:v1.2.0')
+
+// Docker Compose 服务生命周期管理
+await docker.composeUp({ file: 'docker-compose.prod.yml', detached: true })
+await docker.composeDown({ file: 'docker-compose.prod.yml' })
+```
+
+---
+
+## 执行上下文与 AsyncLocalStorage
+
+执行上下文管理整个生命周期的项目元数据、环境变量、日志通道及模拟开关。
+
+### 运行器 (Runner) 示例：
+```typescript
+import { runWithContext, createMockContext } from '@omniflow/core'
+
+const ctx = {
+  runId: 'run-20260912-001',
+  project: 'order-service',
+  env: 'staging',
+  dryRun: false,
+  workspace: '/workspaces/order-service',
+  variables: { REGISTRY: 'harbor.company.com' },
+  secrets: { DOCKER_TOKEN: 'secret-token-value' },
+  logger: {
+    info: (msg) => console.log(`[INFO] ${msg}`),
+    warn: (msg) => console.warn(`[WARN] ${msg}`),
+    error: (msg) => console.error(`[ERROR] ${msg}`),
+    debug: (msg) => console.debug(`[DEBUG] ${msg}`)
+  }
+}
+
+await runWithContext(ctx, async () => {
+  // 在此处调用链中的任何深层异步函数，均可安全访问上下文
+  await executePipelineSteps()
+})
+```
+
+### 插件 (Plugin) 内部调用示例：
+```typescript
+import { getContext, tryGetContext, shell } from '@omniflow/core'
+
+export async function myPluginTask() {
+  const ctx = getContext() // 若不在 runWithContext 环境中则抛出明确错误
+  ctx.logger.info(`正在构建工作区 ${ctx.workspace}，目标环境：${ctx.env}`)
+
+  // 底层 shell 自动采用 ctx.workspace 作为 cwd，自动继承环境变量
+  await shell.run`npm test`
+}
+```
+
+---
+
+## 工具链 SPI (Toolchain SPI)
+
+OmniFlow Core 将不同编程语言的构建体系抽象为统一的 Service Provider Interface (SPI)。
+
+### 内置工具链
+1. **Maven** (`MavenToolchain`)：检测 `pom.xml`，解析 groupId/artifactId/version 坐标，优先调用 `./mvnw` 或 `mvn`。
+2. **Gradle** (`GradleToolchain`)：检测 `build.gradle` / `build.gradle.kts`，优先使用 Gradle Wrapper `./gradlew`，支持多项目构建。
+3. **Node** (`NodeToolchain`)：检测 `package.json`，根据 lock 文件自动选择 `pnpm`、`yarn`、`npm` 或 `bun`，提取包名与版本。
+
+### 使用与解析工具链：
+```typescript
+import { resolveToolchain } from '@omniflow/core'
+
+const { provider, detection } = await resolveToolchain('/path/to/project')
+console.log(`检测到工具链 ${provider.name}，原因: ${detection.reason}`)
+
+const info = await provider.projectInfo('/path/to/project')
+console.log(`工程信息: ${info.name}@${info.version}`)
+
+// 执行依赖安装与构建
+await provider.install('/path/to/project')
+await provider.build('/path/to/project', ['-DskipTests'])
+```
+
+### 注册自定义工具链或覆盖默认行为：
+```typescript
+import { registerToolchain, type ToolchainProvider } from '@omniflow/core'
+
+const goToolchain: ToolchainProvider = {
+  name: 'go',
+  priority: 20, // 优先级高于内置默认 Provider (10)
+  detect: async (cwd) => {
+    // 检测是否包含 go.mod
+    return { detected: true, confidence: 0.95 }
+  },
+  getProjectInfo: async (cwd) => ({
+    name: 'user-service',
+    version: '1.0.0'
+  }),
+  getBuildCommand: (cwd, options) => 'go build -v -o dist/app ./cmd/main.go'
+}
+
+// 注册至全局注册表
+registerToolchain(goToolchain)
+```
+
+> 关于创建自定义工具链（如 Go、Rust）及企业定制覆写的完整教程，详见 [Toolchain SPI 扩展指南](./docs/toolchain-extension_CN.md)。
+
+---
+
+## 模块子路径导出
+
+`@omniflow/core` 遵循现代 ESM 规范，支持精细化的子路径导入：
+
+| 导出子路径 | 包含功能说明 |
+|:---|:---|
+| `@omniflow/core` | 全量包入口：包含上下文、原语、工具链 SPI 以及工具函数 |
+| `@omniflow/core/context` | 执行上下文、`AsyncLocalStorage` 封装、Mock 测试辅助工具 |
+| `@omniflow/core/primitives` | 命令原语（`shell`、`ssh`、`git`、`docker`） |
+| `@omniflow/core/toolchain` | Toolchain SPI 接口、注册表与内置 Provider |
+
+---
+
+## 开源协议
+
+MIT © [Ticatec](https://github.com/ticatec)

package/dist/context/index.d.ts

@@ -0,0 +1,27 @@
+import type { ExecutionContext } from './types.js';
+export * from './types.js';
+export { executionLocalStorage } from './storage.js';
+/**
+ * Return the active ExecutionContext for the current asynchronous call stack.
+ *
+ * @throws Error if called outside an active execution scope (i.e., not inside runWithContext).
+ */
+export declare function getContext(): ExecutionContext;
+/**
+ * Return the active ExecutionContext if available, or undefined.
+ */
+export declare function tryGetContext(): ExecutionContext | undefined;
+/**
+ * Check whether an active ExecutionContext is available in the current scope.
+ */
+export declare function hasContext(): boolean;
+/**
+ * Run a function within an ExecutionContext scope. All asynchronous calls
+ * initiated within `fn` will have access to `ctx` via `getContext()`.
+ */
+export declare function runWithContext<T>(ctx: ExecutionContext, fn: () => Promise<T> | T): Promise<T>;
+/**
+ * Helper to build a fallback or testing ExecutionContext.
+ */
+export declare function createMockContext(overrides?: Partial<ExecutionContext>): ExecutionContext;
+//# sourceMappingURL=index.d.ts.map

package/dist/context/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/context/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAU,MAAM,YAAY,CAAA;AAE1D,cAAc,YAAY,CAAA;AAC1B,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAEpD;;;;GAIG;AACH,wBAAgB,UAAU,IAAI,gBAAgB,CAS7C;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,gBAAgB,GAAG,SAAS,CAE5D;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,OAAO,CAEpC;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAAC,CAAC,EACpC,GAAG,EAAE,gBAAgB,EACrB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GACvB,OAAO,CAAC,CAAC,CAAC,CAEZ;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,GAAE,OAAO,CAAC,gBAAgB,CAAM,GAAG,gBAAgB,CAuB7F"}

package/dist/context/index.js

@@ -0,0 +1,62 @@
+import { executionLocalStorage } from './storage.js';
+export * from './types.js';
+export { executionLocalStorage } from './storage.js';
+/**
+ * Return the active ExecutionContext for the current asynchronous call stack.
+ *
+ * @throws Error if called outside an active execution scope (i.e., not inside runWithContext).
+ */
+export function getContext() {
+    const ctx = executionLocalStorage.getStore();
+    if (!ctx) {
+        throw new Error('No active OmniFlow ExecutionContext found in this asynchronous scope. ' +
+            'Ensure this function is executed within runWithContext(ctx, fn).');
+    }
+    return ctx;
+}
+/**
+ * Return the active ExecutionContext if available, or undefined.
+ */
+export function tryGetContext() {
+    return executionLocalStorage.getStore();
+}
+/**
+ * Check whether an active ExecutionContext is available in the current scope.
+ */
+export function hasContext() {
+    return executionLocalStorage.getStore() !== undefined;
+}
+/**
+ * Run a function within an ExecutionContext scope. All asynchronous calls
+ * initiated within `fn` will have access to `ctx` via `getContext()`.
+ */
+export async function runWithContext(ctx, fn) {
+    return executionLocalStorage.run(ctx, fn);
+}
+/**
+ * Helper to build a fallback or testing ExecutionContext.
+ */
+export function createMockContext(overrides = {}) {
+    const defaultLogger = {
+        info: (msg) => console.log(`[INFO] ${msg}`),
+        warn: (msg) => console.warn(`[WARN] ${msg}`),
+        error: (msg) => console.error(`[ERROR] ${msg}`),
+        debug: (msg) => console.debug(`[DEBUG] ${msg}`)
+    };
+    return {
+        runId: overrides.runId ?? `test-run-${Date.now()}`,
+        workspace: overrides.workspace ?? process.cwd(),
+        projectRoot: overrides.projectRoot ?? process.cwd(),
+        project: overrides.project ?? 'test-project',
+        module: overrides.module,
+        moduleFolder: overrides.moduleFolder,
+        environment: overrides.environment ?? 'test',
+        git: overrides.git ?? { branch: 'main', commit: '0000000', dirty: false },
+        env: overrides.env ?? {},
+        logger: overrides.logger ?? defaultLogger,
+        dryRun: overrides.dryRun ?? false,
+        sourceMode: overrides.sourceMode ?? 'local',
+        logFile: overrides.logFile
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/context/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/context/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAGpD,cAAc,YAAY,CAAA;AAC1B,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAEpD;;;;GAIG;AACH,MAAM,UAAU,UAAU;IACxB,MAAM,GAAG,GAAG,qBAAqB,CAAC,QAAQ,EAAE,CAAA;IAC5C,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CACb,wEAAwE;YACxE,kEAAkE,CACnE,CAAA;IACH,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa;IAC3B,OAAO,qBAAqB,CAAC,QAAQ,EAAE,CAAA;AACzC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,UAAU;IACxB,OAAO,qBAAqB,CAAC,QAAQ,EAAE,KAAK,SAAS,CAAA;AACvD,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,GAAqB,EACrB,EAAwB;IAExB,OAAO,qBAAqB,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;AAC3C,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAAC,YAAuC,EAAE;IACzE,MAAM,aAAa,GAAW;QAC5B,IAAI,EAAE,CAAC,GAAW,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,GAAG,EAAE,CAAC;QACnD,IAAI,EAAE,CAAC,GAAW,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;QACpD,KAAK,EAAE,CAAC,GAAW,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,GAAG,EAAE,CAAC;QACvD,KAAK,EAAE,CAAC,GAAW,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,GAAG,EAAE,CAAC;KACxD,CAAA;IAED,OAAO;QACL,KAAK,EAAE,SAAS,CAAC,KAAK,IAAI,YAAY,IAAI,CAAC,GAAG,EAAE,EAAE;QAClD,SAAS,EAAE,SAAS,CAAC,SAAS,IAAI,OAAO,CAAC,GAAG,EAAE;QAC/C,WAAW,EAAE,SAAS,CAAC,WAAW,IAAI,OAAO,CAAC,GAAG,EAAE;QACnD,OAAO,EAAE,SAAS,CAAC,OAAO,IAAI,cAAc;QAC5C,MAAM,EAAE,SAAS,CAAC,MAAM;QACxB,YAAY,EAAE,SAAS,CAAC,YAAY;QACpC,WAAW,EAAE,SAAS,CAAC,WAAW,IAAI,MAAM;QAC5C,GAAG,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE;QACzE,GAAG,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE;QACxB,MAAM,EAAE,SAAS,CAAC,MAAM,IAAI,aAAa;QACzC,MAAM,EAAE,SAAS,CAAC,MAAM,IAAI,KAAK;QACjC,UAAU,EAAE,SAAS,CAAC,UAAU,IAAI,OAAO;QAC3C,OAAO,EAAE,SAAS,CAAC,OAAO;KAC3B,CAAA;AACH,CAAC"}

package/dist/context/storage.d.ts

@@ -0,0 +1,8 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { ExecutionContext } from './types.js';
+/**
+ * Node.js AsyncLocalStorage instance managing the active ExecutionContext
+ * across asynchronous function calls.
+ */
+export declare const executionLocalStorage: AsyncLocalStorage<ExecutionContext>;
+//# sourceMappingURL=storage.d.ts.map

package/dist/context/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/context/storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD;;;GAGG;AACH,eAAO,MAAM,qBAAqB,qCAA4C,CAAA"}

package/dist/context/storage.js

@@ -0,0 +1,7 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/**
+ * Node.js AsyncLocalStorage instance managing the active ExecutionContext
+ * across asynchronous function calls.
+ */
+export const executionLocalStorage = new AsyncLocalStorage();
+//# sourceMappingURL=storage.js.map

package/dist/context/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/context/storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAGpD;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,IAAI,iBAAiB,EAAoB,CAAA"}