@lumenflow/core 1.3.0 → 1.3.3

package/dist/arg-parser.d.ts

@@ -21,6 +21,12 @@ interface WUOption {
     isRepeatable?: boolean;
 }
 export declare const WU_OPTIONS: Record<string, WUOption>;
+/**
+ * WU-1062: Additional options for wu:create command
+ *
+ * These options control how wu:create handles external plan storage.
+ */
+export declare const WU_CREATE_OPTIONS: Record<string, WUOption>;
 /**
  * Create a commander-based CLI parser for a WU script.
  *

package/dist/arg-parser.js

@@ -396,6 +396,22 @@ export const WU_OPTIONS = {
         description: 'Skip automatic pnpm install in worktree after creation (faster claims when deps already built)',
     },
 };
+/**
+ * WU-1062: Additional options for wu:create command
+ *
+ * These options control how wu:create handles external plan storage.
+ */
+export const WU_CREATE_OPTIONS = {
+    /**
+     * Create plan template in $LUMENFLOW_HOME/plans/
+     * Stores plans externally for traceability without polluting the repo.
+     */
+    plan: {
+        name: 'plan',
+        flags: '--plan',
+        description: 'Create plan template in $LUMENFLOW_HOME/plans/ (external plan storage)',
+    },
+};
 /**
  * Negated options that commander handles specially.
  * --no-foo creates opts.foo = false. We convert to noFoo = true.

package/dist/core/tool.schemas.d.ts

@@ -140,8 +140,8 @@ export declare const ToolExecutionResultSchema: z.ZodObject<{
     tool: z.ZodString;
     status: z.ZodEnum<{
         cancelled: "cancelled";
-        success: "success";
         timeout: "timeout";
+        success: "success";
         failed: "failed";
         pending: "pending";
         running: "running";

package/dist/coverage-gate.d.ts

@@ -26,6 +26,9 @@ export declare const COVERAGE_GATE_MODES: Readonly<{
  * Glob patterns for hex core files that require ≥90% coverage.
  * These are the critical application layer files.
  *
+ * WU-1068: Changed from @patientpath to @lumenflow for framework reusability.
+ * Project-specific patterns should be configured in .lumenflow.config.yaml.
+ *
  * @constant {string[]}
  */
 export declare const HEX_CORE_PATTERNS: readonly string[];

package/dist/coverage-gate.js

@@ -29,11 +29,14 @@ export const COVERAGE_GATE_MODES = Object.freeze({
  * Glob patterns for hex core files that require ≥90% coverage.
  * These are the critical application layer files.
  *
+ * WU-1068: Changed from @patientpath to @lumenflow for framework reusability.
+ * Project-specific patterns should be configured in .lumenflow.config.yaml.
+ *
  * @constant {string[]}
  */
 export const HEX_CORE_PATTERNS = Object.freeze([
-    'packages/@patientpath/application/',
-    'packages/@patientpath/prompts/',
+    'packages/@lumenflow/core/',
+    'packages/@lumenflow/cli/',
 ]);
 /**
  * Coverage threshold for hex core files (percentage)
@@ -144,7 +147,7 @@ export function formatCoverageDelta(coverageData) {
             const metrics = metricsValue;
             const pct = metrics.lines?.pct ?? 0;
             const status = pct >= COVERAGE_THRESHOLD ? EMOJI.SUCCESS : EMOJI.FAILURE;
-            const shortFile = file.replace('packages/@patientpath/', '');
+            const shortFile = file.replace('packages/@lumenflow/', '');
             lines.push(`  ${status} ${shortFile}: ${pct.toFixed(1)}%`);
         }
     }
@@ -178,7 +181,7 @@ export async function runCoverageGate(options = {}) {
     if (!pass) {
         logger.log(`\n${EMOJI.FAILURE} Coverage below ${COVERAGE_THRESHOLD}% for hex core files:`);
         for (const failure of failures) {
-            const shortFile = failure.file.replace('packages/@patientpath/', '');
+            const shortFile = failure.file.replace('packages/@lumenflow/', '');
             logger.log(`  - ${shortFile}: ${failure.actual.toFixed(1)}% (requires ${failure.threshold}%)`);
         }
         if (mode === COVERAGE_GATE_MODES.BLOCK) {

package/dist/force-bypass-audit.d.ts

@@ -0,0 +1,63 @@
+/**
+ * WU-1070: Force Bypass Audit Logging
+ *
+ * Provides audit logging for LUMENFLOW_FORCE bypass usage.
+ * All hooks log bypass events to .beacon/force-bypasses.log for accountability.
+ *
+ * Key principles:
+ * - FAIL-OPEN: Audit logging must never block the bypass itself
+ * - WARN ON MISSING REASON: stderr warning if LUMENFLOW_FORCE_REASON not set
+ * - GIT-TRACKED: .beacon/force-bypasses.log is version controlled
+ *
+ * Log format:
+ *   ISO_TIMESTAMP | HOOK_NAME | GIT_USER | BRANCH | REASON | CWD
+ *
+ * Example:
+ *   2026-01-23T10:30:00.000Z | pre-commit | tom@hellm.ai | lane/ops/wu-1070 | Emergency hotfix | /project
+ */
+/**
+ * Environment variable names for force bypass
+ */
+export declare const FORCE_ENV_VAR = "LUMENFLOW_FORCE";
+export declare const FORCE_REASON_ENV_VAR = "LUMENFLOW_FORCE_REASON";
+/**
+ * Represents a parsed audit log entry
+ */
+export interface AuditLogEntry {
+    timestamp: string;
+    hook: string;
+    user: string;
+    branch: string;
+    reason: string;
+    cwd: string;
+}
+/**
+ * Check if LUMENFLOW_FORCE bypass is active
+ *
+ * @returns true if LUMENFLOW_FORCE=1
+ */
+export declare function shouldBypass(): boolean;
+/**
+ * Get the audit log file path
+ *
+ * @param projectRoot - Project root directory
+ * @returns Full path to the audit log file
+ */
+export declare function getAuditLogPath(projectRoot: string): string;
+/**
+ * Log a force bypass event to the audit log
+ *
+ * This function is FAIL-OPEN: if logging fails, it warns to stderr
+ * but does NOT throw or block the bypass operation.
+ *
+ * @param hookName - Name of the hook being bypassed (pre-commit, pre-push, etc.)
+ * @param projectRoot - Project root directory
+ */
+export declare function logForceBypass(hookName: string, projectRoot: string): void;
+/**
+ * Parse a single line from the audit log
+ *
+ * @param line - Raw log line
+ * @returns Parsed entry or null if invalid
+ */
+export declare function parseAuditLogLine(line: string): AuditLogEntry | null;

package/dist/force-bypass-audit.js

@@ -0,0 +1,140 @@
+/**
+ * WU-1070: Force Bypass Audit Logging
+ *
+ * Provides audit logging for LUMENFLOW_FORCE bypass usage.
+ * All hooks log bypass events to .beacon/force-bypasses.log for accountability.
+ *
+ * Key principles:
+ * - FAIL-OPEN: Audit logging must never block the bypass itself
+ * - WARN ON MISSING REASON: stderr warning if LUMENFLOW_FORCE_REASON not set
+ * - GIT-TRACKED: .beacon/force-bypasses.log is version controlled
+ *
+ * Log format:
+ *   ISO_TIMESTAMP | HOOK_NAME | GIT_USER | BRANCH | REASON | CWD
+ *
+ * Example:
+ *   2026-01-23T10:30:00.000Z | pre-commit | tom@hellm.ai | lane/ops/wu-1070 | Emergency hotfix | /project
+ */
+import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+/**
+ * Environment variable names for force bypass
+ */
+export const FORCE_ENV_VAR = 'LUMENFLOW_FORCE';
+export const FORCE_REASON_ENV_VAR = 'LUMENFLOW_FORCE_REASON';
+/**
+ * Log file path relative to project root
+ */
+const LOG_FILE_NAME = '.beacon/force-bypasses.log';
+/**
+ * Check if LUMENFLOW_FORCE bypass is active
+ *
+ * @returns true if LUMENFLOW_FORCE=1
+ */
+export function shouldBypass() {
+    return process.env[FORCE_ENV_VAR] === '1';
+}
+/**
+ * Get the audit log file path
+ *
+ * @param projectRoot - Project root directory
+ * @returns Full path to the audit log file
+ */
+export function getAuditLogPath(projectRoot) {
+    return join(projectRoot, LOG_FILE_NAME);
+}
+/**
+ * Get git user.name for audit logging
+ *
+ * @returns Git user name or 'unknown' if not configured
+ */
+function getGitUser() {
+    try {
+        return execSync('git config user.name', { encoding: 'utf8' }).trim();
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Get current git branch name
+ *
+ * @returns Branch name or 'unknown' if not in a git repo
+ */
+function getGitBranch() {
+    try {
+        return execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf8' }).trim();
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Log a force bypass event to the audit log
+ *
+ * This function is FAIL-OPEN: if logging fails, it warns to stderr
+ * but does NOT throw or block the bypass operation.
+ *
+ * @param hookName - Name of the hook being bypassed (pre-commit, pre-push, etc.)
+ * @param projectRoot - Project root directory
+ */
+export function logForceBypass(hookName, projectRoot) {
+    // Only log when bypass is active
+    if (!shouldBypass()) {
+        return;
+    }
+    // Get reason from environment (warn if missing)
+    const reason = process.env[FORCE_REASON_ENV_VAR];
+    if (!reason) {
+        console.warn(`[${hookName}] Warning: ${FORCE_REASON_ENV_VAR} not set. ` +
+            'Consider providing a reason for the bypass: ' +
+            `${FORCE_REASON_ENV_VAR}="reason here" LUMENFLOW_FORCE=1 git ...`);
+    }
+    // Collect audit data
+    const timestamp = new Date().toISOString();
+    const user = getGitUser();
+    const branch = getGitBranch();
+    const cwd = projectRoot;
+    const reasonText = reason || '(no reason provided)';
+    // Format log line: ISO timestamp | hook | user | branch | reason | cwd
+    const logLine = `${timestamp} | ${hookName} | ${user} | ${branch} | ${reasonText} | ${cwd}\n`;
+    // Write to log file (fail-open)
+    try {
+        const logPath = getAuditLogPath(projectRoot);
+        const beaconDir = join(projectRoot, '.beacon');
+        // Ensure .beacon directory exists
+        if (!existsSync(beaconDir)) {
+            mkdirSync(beaconDir, { recursive: true });
+        }
+        appendFileSync(logPath, logLine);
+    }
+    catch (error) {
+        // Fail-open: warn but don't block
+        console.error(`[${hookName}] Warning: Failed to write to audit log: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Parse a single line from the audit log
+ *
+ * @param line - Raw log line
+ * @returns Parsed entry or null if invalid
+ */
+export function parseAuditLogLine(line) {
+    if (!line || line.trim() === '') {
+        return null;
+    }
+    const parts = line.split(' | ');
+    if (parts.length !== 6) {
+        return null;
+    }
+    const [timestamp, hook, user, branch, reason, cwd] = parts;
+    return {
+        timestamp: timestamp.trim(),
+        hook: hook.trim(),
+        user: user.trim(),
+        branch: branch.trim(),
+        reason: reason.trim(),
+        cwd: cwd.trim(),
+    };
+}

package/dist/gates-config.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Gates Configuration
+ *
+ * WU-1067: Config-driven gates execution
+ *
+ * Provides a config-driven gates system that allows users to define
+ * custom format, lint, test commands in .lumenflow.config.yaml instead
+ * of relying on hardcoded language presets.
+ *
+ * @module gates-config
+ */
+import { z } from 'zod';
+/**
+ * Schema for a gate command - either a string or an object with options
+ */
+export declare const GateCommandConfigSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    command: z.ZodString;
+    continueOnError: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>]>;
+/**
+ * Type for parsed gate command configuration
+ */
+export type GateCommandConfig = z.infer<typeof GateCommandConfigSchema>;
+/**
+ * Schema for the gates execution configuration section
+ */
+export declare const GatesExecutionConfigSchema: z.ZodObject<{
+    preset: z.ZodOptional<z.ZodString>;
+    setup: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        continueOnError: z.ZodOptional<z.ZodBoolean>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>;
+    format: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        continueOnError: z.ZodOptional<z.ZodBoolean>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>;
+    lint: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        continueOnError: z.ZodOptional<z.ZodBoolean>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>;
+    typecheck: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        continueOnError: z.ZodOptional<z.ZodBoolean>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>;
+    test: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        continueOnError: z.ZodOptional<z.ZodBoolean>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>;
+    coverage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+/**
+ * Type for gates execution configuration
+ */
+export type GatesExecutionConfig = z.infer<typeof GatesExecutionConfigSchema>;
+/**
+ * Parsed gate command ready for execution
+ */
+export interface ParsedGateCommand {
+    /** The shell command to execute */
+    command: string;
+    /** Whether to continue if this gate fails */
+    continueOnError: boolean;
+    /** Timeout in milliseconds */
+    timeout: number;
+}
+/**
+ * Gate preset definitions
+ *
+ * These provide sensible defaults for common language ecosystems.
+ * Users can override any field via .lumenflow.config.yaml
+ */
+export declare const GATE_PRESETS: Record<string, Partial<GatesExecutionConfig>>;
+/**
+ * Parse a gate command configuration into executable form
+ *
+ * @param config - Gate command configuration (string or object)
+ * @returns Parsed command with defaults applied, or null if undefined
+ */
+export declare function parseGateCommand(config: GateCommandConfig | undefined): ParsedGateCommand | null;
+/**
+ * Expand a preset name into its default gate commands
+ *
+ * @param preset - Preset name (node, python, go, rust, dotnet) or undefined
+ * @returns Partial gates config with preset defaults, or empty object if unknown
+ */
+export declare function expandPreset(preset: string | undefined): Partial<GatesExecutionConfig>;
+/**
+ * Load gates configuration from .lumenflow.config.yaml
+ *
+ * @param projectRoot - Project root directory
+ * @returns Gates execution config, or null if not configured
+ */
+export declare function loadGatesConfig(projectRoot: string): GatesExecutionConfig | null;
+/**
+ * Get default gates configuration for auto-detection fallback
+ *
+ * Used when no gates config is present in .lumenflow.config.yaml.
+ * These are generic commands that work across common setups.
+ *
+ * @returns Default gates configuration
+ */
+export declare function getDefaultGatesConfig(): GatesExecutionConfig;
+/**
+ * Resolve the effective gates configuration
+ *
+ * Priority order:
+ * 1. Explicit config from .lumenflow.config.yaml
+ * 2. Preset defaults (if preset specified)
+ * 3. Auto-detection defaults
+ *
+ * @param projectRoot - Project root directory
+ * @returns Resolved gates configuration
+ */
+export declare function resolveGatesConfig(projectRoot: string): GatesExecutionConfig;
+/**
+ * Check if a specific gate should be skipped
+ *
+ * @param gateName - Name of the gate (format, lint, typecheck, test)
+ * @param config - Gates execution configuration
+ * @param skipFlags - Map of skip flags from CLI/Action inputs
+ * @returns True if the gate should be skipped
+ */
+export declare function shouldSkipGate(gateName: keyof Omit<GatesExecutionConfig, 'preset' | 'coverage'>, config: GatesExecutionConfig, skipFlags: Record<string, boolean>): boolean;

package/dist/gates-config.js

@@ -0,0 +1,229 @@
+/**
+ * Gates Configuration
+ *
+ * WU-1067: Config-driven gates execution
+ *
+ * Provides a config-driven gates system that allows users to define
+ * custom format, lint, test commands in .lumenflow.config.yaml instead
+ * of relying on hardcoded language presets.
+ *
+ * @module gates-config
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as yaml from 'yaml';
+import { z } from 'zod';
+/**
+ * Default timeout for gate commands (2 minutes)
+ */
+const DEFAULT_GATE_TIMEOUT = 120000;
+/**
+ * Schema for a gate command object with options
+ */
+const GateCommandObjectSchema = z.object({
+    /** The shell command to execute */
+    command: z.string(),
+    /** Whether to continue if this gate fails (default: false) */
+    continueOnError: z.boolean().optional(),
+    /** Timeout in milliseconds (default: 120000) */
+    timeout: z.number().int().positive().optional(),
+});
+/**
+ * Schema for a gate command - either a string or an object with options
+ */
+export const GateCommandConfigSchema = z.union([z.string(), GateCommandObjectSchema]);
+/**
+ * Schema for the gates execution configuration section
+ */
+export const GatesExecutionConfigSchema = z.object({
+    /** Preset to use for default commands (node, python, go, rust, dotnet) */
+    preset: z.string().optional(),
+    /** Setup command (e.g., install dependencies) */
+    setup: GateCommandConfigSchema.optional(),
+    /** Format check command */
+    format: GateCommandConfigSchema.optional(),
+    /** Lint command */
+    lint: GateCommandConfigSchema.optional(),
+    /** Type check command */
+    typecheck: GateCommandConfigSchema.optional(),
+    /** Test command */
+    test: GateCommandConfigSchema.optional(),
+    /** Coverage configuration */
+    coverage: z
+        .union([
+        z.string(),
+        z.object({
+            command: z.string(),
+            threshold: z.number().min(0).max(100).optional(),
+        }),
+    ])
+        .optional(),
+});
+/**
+ * Gate preset definitions
+ *
+ * These provide sensible defaults for common language ecosystems.
+ * Users can override any field via .lumenflow.config.yaml
+ */
+export const GATE_PRESETS = {
+    node: {
+        setup: 'npm ci || npm install',
+        format: 'npx prettier --check .',
+        lint: 'npx eslint .',
+        typecheck: 'npx tsc --noEmit',
+        test: 'npm test',
+    },
+    python: {
+        setup: 'pip install -e ".[dev]" || pip install -r requirements.txt',
+        format: 'ruff format --check .',
+        lint: 'ruff check .',
+        typecheck: 'mypy .',
+        test: 'pytest',
+    },
+    go: {
+        format: 'gofmt -l . | grep -v "^$" && exit 1 || exit 0',
+        lint: 'golangci-lint run',
+        typecheck: 'go vet ./...',
+        test: 'go test ./...',
+    },
+    rust: {
+        format: 'cargo fmt --check',
+        lint: 'cargo clippy -- -D warnings',
+        typecheck: 'cargo check',
+        test: 'cargo test',
+    },
+    dotnet: {
+        setup: 'dotnet restore',
+        format: 'dotnet format --verify-no-changes',
+        lint: 'dotnet build --no-restore -warnaserror',
+        test: 'dotnet test --no-restore',
+    },
+};
+/**
+ * Parse a gate command configuration into executable form
+ *
+ * @param config - Gate command configuration (string or object)
+ * @returns Parsed command with defaults applied, or null if undefined
+ */
+export function parseGateCommand(config) {
+    if (config === undefined) {
+        return null;
+    }
+    if (typeof config === 'string') {
+        return {
+            command: config,
+            continueOnError: false,
+            timeout: DEFAULT_GATE_TIMEOUT,
+        };
+    }
+    return {
+        command: config.command,
+        continueOnError: config.continueOnError ?? false,
+        timeout: config.timeout ?? DEFAULT_GATE_TIMEOUT,
+    };
+}
+/**
+ * Expand a preset name into its default gate commands
+ *
+ * @param preset - Preset name (node, python, go, rust, dotnet) or undefined
+ * @returns Partial gates config with preset defaults, or empty object if unknown
+ */
+export function expandPreset(preset) {
+    if (!preset) {
+        return {};
+    }
+    return GATE_PRESETS[preset] ?? {};
+}
+/**
+ * Load gates configuration from .lumenflow.config.yaml
+ *
+ * @param projectRoot - Project root directory
+ * @returns Gates execution config, or null if not configured
+ */
+export function loadGatesConfig(projectRoot) {
+    const configPath = path.join(projectRoot, '.lumenflow.config.yaml');
+    if (!fs.existsSync(configPath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        const data = yaml.parse(content);
+        // Check if gates.execution section exists
+        const executionConfig = data?.gates?.execution;
+        if (!executionConfig) {
+            return null;
+        }
+        // Validate the config
+        const result = GatesExecutionConfigSchema.safeParse(executionConfig);
+        if (!result.success) {
+            console.warn('Warning: Invalid gates.execution config:', result.error.message);
+            return null;
+        }
+        // Expand preset and merge with explicit config (explicit wins)
+        const presetDefaults = expandPreset(result.data.preset);
+        const merged = {
+            ...presetDefaults,
+            ...result.data,
+        };
+        return merged;
+    }
+    catch (error) {
+        console.warn('Warning: Failed to parse .lumenflow.config.yaml:', error instanceof Error ? error.message : String(error));
+        return null;
+    }
+}
+/**
+ * Get default gates configuration for auto-detection fallback
+ *
+ * Used when no gates config is present in .lumenflow.config.yaml.
+ * These are generic commands that work across common setups.
+ *
+ * @returns Default gates configuration
+ */
+export function getDefaultGatesConfig() {
+    return {
+        format: 'npm run format:check 2>/dev/null || npx prettier --check . 2>/dev/null || echo "No formatter configured"',
+        lint: 'npm run lint 2>/dev/null || npx eslint . 2>/dev/null || echo "No linter configured"',
+        typecheck: 'npm run typecheck 2>/dev/null || npx tsc --noEmit 2>/dev/null || echo "No type checker configured"',
+        test: 'npm test 2>/dev/null || echo "No test command configured"',
+    };
+}
+/**
+ * Resolve the effective gates configuration
+ *
+ * Priority order:
+ * 1. Explicit config from .lumenflow.config.yaml
+ * 2. Preset defaults (if preset specified)
+ * 3. Auto-detection defaults
+ *
+ * @param projectRoot - Project root directory
+ * @returns Resolved gates configuration
+ */
+export function resolveGatesConfig(projectRoot) {
+    const config = loadGatesConfig(projectRoot);
+    if (config) {
+        return config;
+    }
+    // Fall back to defaults for auto-detection
+    return getDefaultGatesConfig();
+}
+/**
+ * Check if a specific gate should be skipped
+ *
+ * @param gateName - Name of the gate (format, lint, typecheck, test)
+ * @param config - Gates execution configuration
+ * @param skipFlags - Map of skip flags from CLI/Action inputs
+ * @returns True if the gate should be skipped
+ */
+export function shouldSkipGate(gateName, config, skipFlags) {
+    // Check if skip flag is set
+    const skipFlagName = `skip-${gateName}`;
+    if (skipFlags[skipFlagName] || skipFlags[gateName]) {
+        return true;
+    }
+    // Check if gate is configured (undefined means skip)
+    if (config[gateName] === undefined) {
+        return true;
+    }
+    return false;
+}

package/dist/git-adapter.d.ts

@@ -66,6 +66,13 @@ export declare class GitAdapter {
      * await git.getStatus(); // " M file.txt\n?? untracked.txt"
      */
     getStatus(): Promise<string>;
+    /**
+     * Get unpushed commits (compared to upstream)
+     * @returns {Promise<string>} Oneline log output for unpushed commits
+     * @example
+     * await git.getUnpushedCommits(); // "abc123 fix: ...\n"
+     */
+    getUnpushedCommits(): Promise<string>;
     /**
      * Check if a branch exists
      * @param {string} branch - Branch name