@cjhyy/code-shell-core 0.7.1 → 0.8.1

package/dist/cc-orchestrator/session-history.d.ts

@@ -1,54 +0,0 @@
-export interface HistoryMessage {
-    role: "user" | "assistant";
-    text: string;
-    /** `summary` is a lossy one-field preview; `args` is the full tool_use input
-     *  (e.g. a sub-agent's `prompt`) so a replayed tool card can show the real
-     *  parameters, not just the whitelisted field. */
-    tools?: {
-        name: string;
-        summary: string;
-        args?: Record<string, unknown>;
-    }[];
-    ts?: number;
-}
-/** One render-relevant event parsed from an appended external-CLI transcript
- * line. Kept CLI-neutral so the desktop room follower can feed Claude Code and
- * Codex through the same RoomManager push path. */
-export type SessionTailEvent = {
-    type: "user";
-    text: string;
-} | {
-    type: "assistant";
-    text: string;
-} | {
-    type: "tool";
-    id?: string;
-    name: string;
-    summary: string;
-    args?: Record<string, unknown>;
-} | {
-    type: "tool_result";
-    id?: string;
-    result: string;
-    isError: boolean;
-} | {
-    type: "turn_end";
-    reason: string;
-};
-/** Parse a bounded/raw Claude Code transcript snapshot. Exported so a live
- * follower can take its initial snapshot and EOF cursor from the same read,
- * eliminating the snapshot→subscribe race. */
-export declare function parseRecentHistory(raw: string, limit: number): {
-    messages: HistoryMessage[];
-    hasMore: boolean;
-    totalCount: number;
-};
-/** Parse one newly-appended Claude Code transcript JSONL line into the compact
- * event vocabulary consumed by the desktop room follower. */
-export declare function parseClaudeTranscriptLine(line: string): SessionTailEvent[];
-/** Read the last `limit` user/assistant messages from a claude session jsonl. */
-export declare function readRecentHistory(cwd: string, sessionId: string, limit: number, claudeHome?: string): {
-    messages: HistoryMessage[];
-    hasMore: boolean;
-    totalCount: number;
-};

package/dist/cc-orchestrator/session-history.js

@@ -1,150 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import { encodeCwd } from "./session-discovery.js";
-const NOISE = ["<local-command-caveat>", "<command-name>"];
-function textOf(content) {
-    if (typeof content === "string")
-        return content;
-    if (Array.isArray(content))
-        return content.map((p) => (typeof p?.text === "string" ? p.text : "")).join("");
-    return "";
-}
-function toolsOf(content) {
-    if (!Array.isArray(content))
-        return [];
-    const out = [];
-    for (const p of content) {
-        if (p?.type === "tool_use") {
-            const inp = p.input ?? {};
-            const summary = inp.command ?? inp.file_path ?? inp.path ?? inp.url ?? inp.pattern ?? inp.query ?? "";
-            const args = inp && typeof inp === "object" && Object.keys(inp).length > 0 ? inp : undefined;
-            out.push({
-                name: typeof p.name === "string" ? p.name : "tool",
-                summary: String(summary).slice(0, 120),
-                args,
-            });
-        }
-    }
-    return out;
-}
-function toolResultText(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content
-        .map((part) => typeof part === "string" ? part : typeof part?.text === "string" ? part.text : "")
-        .join("");
-}
-/** Parse a bounded/raw Claude Code transcript snapshot. Exported so a live
- * follower can take its initial snapshot and EOF cursor from the same read,
- * eliminating the snapshot→subscribe race. */
-export function parseRecentHistory(raw, limit) {
-    const all = [];
-    for (const line of raw.split("\n")) {
-        if (!line.trim())
-            continue;
-        let d;
-        try {
-            d = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        if (d.type === "user") {
-            const t = textOf(d.message?.content).trim();
-            if (!t || NOISE.some((n) => t.startsWith(n)))
-                continue;
-            all.push({ role: "user", text: t });
-        }
-        else if (d.type === "assistant") {
-            const t = textOf(d.message?.content).trim();
-            const tools = toolsOf(d.message?.content);
-            if (!t && tools.length === 0)
-                continue;
-            all.push({ role: "assistant", text: t, tools: tools.length ? tools : undefined });
-        }
-    }
-    const lim = limit > 0 ? limit : 20;
-    const start = Math.max(0, all.length - lim);
-    return { messages: all.slice(start), hasMore: start > 0, totalCount: all.length };
-}
-/** Parse one newly-appended Claude Code transcript JSONL line into the compact
- * event vocabulary consumed by the desktop room follower. */
-export function parseClaudeTranscriptLine(line) {
-    let d;
-    try {
-        d = JSON.parse(line);
-    }
-    catch {
-        return [];
-    }
-    const out = [];
-    if (d.type === "user") {
-        const content = d.message?.content;
-        if (Array.isArray(content)) {
-            for (const part of content) {
-                if (part?.type !== "tool_result")
-                    continue;
-                out.push({
-                    type: "tool_result",
-                    id: typeof part.tool_use_id === "string" ? part.tool_use_id : undefined,
-                    result: toolResultText(part.content).slice(0, 4000),
-                    isError: Boolean(part.is_error),
-                });
-            }
-        }
-        const text = textOf(content).trim();
-        if (text && !NOISE.some((noise) => text.startsWith(noise))) {
-            out.unshift({ type: "user", text });
-        }
-        return out;
-    }
-    if (d.type === "assistant" && Array.isArray(d.message?.content)) {
-        for (const part of d.message.content) {
-            if (part?.type === "text" && typeof part.text === "string" && part.text) {
-                out.push({ type: "assistant", text: part.text });
-            }
-            else if (part?.type === "tool_use") {
-                const input = part.input && typeof part.input === "object"
-                    ? part.input
-                    : undefined;
-                out.push({
-                    type: "tool",
-                    id: typeof part.id === "string" ? part.id : undefined,
-                    name: typeof part.name === "string" ? part.name : "tool",
-                    summary: toolsOf([part])[0]?.summary ?? "",
-                    args: input,
-                });
-            }
-        }
-        if (d.message.stop_reason === "end_turn") {
-            out.push({ type: "turn_end", reason: "completed" });
-        }
-        return out;
-    }
-    if (d.type === "result") {
-        return [
-            {
-                type: "turn_end",
-                reason: typeof d.subtype === "string" ? d.subtype : "completed",
-            },
-        ];
-    }
-    return [];
-}
-/** Read the last `limit` user/assistant messages from a claude session jsonl. */
-export function readRecentHistory(cwd, sessionId, limit, claudeHome = join(homedir(), ".claude")) {
-    const file = join(claudeHome, "projects", encodeCwd(cwd), `${sessionId}.jsonl`);
-    if (!existsSync(file))
-        return { messages: [], hasMore: false, totalCount: 0 };
-    let raw;
-    try {
-        raw = readFileSync(file, "utf-8");
-    }
-    catch {
-        return { messages: [], hasMore: false, totalCount: 0 };
-    }
-    return parseRecentHistory(raw, limit);
-}

package/dist/cron/cron-runtime.d.ts

@@ -1,2 +0,0 @@
-/** Back-compat shim — moved to `automation/runner.ts`. */
-export * from "../automation/runner.js";

package/dist/cron/cron-runtime.js

@@ -1,2 +0,0 @@
-/** Back-compat shim — moved to `automation/runner.ts`. */
-export * from "../automation/runner.js";

package/dist/cron/cron-store.d.ts

@@ -1,2 +0,0 @@
-/** Back-compat shim — moved to `automation/store.ts`. */
-export * from "../automation/store.js";

package/dist/cron/cron-store.js

@@ -1,2 +0,0 @@
-/** Back-compat shim — moved to `automation/store.ts`. */
-export * from "../automation/store.js";

package/dist/cron/scheduler.d.ts

@@ -1,7 +0,0 @@
-/**
- * Back-compat shim. The cron scheduler moved to `automation/scheduler.ts`
- * (see docs/automation-plan-2026-05-31.md). This re-export keeps existing
- * `../cron/scheduler.js` importers working. New code should import from
- * `../automation/scheduler.js`.
- */
-export * from "../automation/scheduler.js";

package/dist/cron/scheduler.js

@@ -1,7 +0,0 @@
-/**
- * Back-compat shim. The cron scheduler moved to `automation/scheduler.ts`
- * (see docs/automation-plan-2026-05-31.md). This re-export keeps existing
- * `../cron/scheduler.js` importers working. New code should import from
- * `../automation/scheduler.js`.
- */
-export * from "../automation/scheduler.js";

package/dist/engine/goal.js

@@ -1,206 +0,0 @@
-/**
- * Goal mode P0 — run-scoped budget guardrails.
- *
- * `GoalConfig` is the normalized internal shape. Public entry points
- * (protocol/server, engine run) accept `string | GoalConfig` for
- * back-compat and call `normalizeGoal()` once at the boundary; everything
- * inward uses `GoalConfig`.
- *
- * The budget tracker is RUN-scoped (not per-turn like token-budget.ts):
- * it accumulates total tokens across turns and stamps a wall-clock start,
- * so an unattended goal run can't burn tokens or wall time without bound.
- */
-/** True only when both values identify the same concrete goal instance. */
-export function isSameGoalInstance(left, right) {
-    return !!left && !!right && left.objective === right.objective && left.setAtMs === right.setAtMs;
-}
-/**
- * Default consecutive-stop-block cap for goal runs. The real safety net for an
- * unattended goal is the token/time budget + maxTurns; this cap only stops a
- * goal that the judge keeps re-blocking with NO progress between blocks. 8 was
- * too tight — a complex goal can legitimately get "not yet" several times while
- * advancing — so we allow a generous streak before declaring it stuck.
- */
-export const GOAL_DEFAULT_MAX_STOP_BLOCKS = 25;
-/**
- * Consecutive-stop-block cap for NON-goal (interactive) runs. The 25-block goal
- * default is far too loose for a plain interactive session: a plugin `on_stop`
- * hook that keeps returning continueSession would loop 25× before the backstop
- * bites (~3× the model calls). Non-goal runs fall back to this tighter cap —
- * the historical value before the goal feature raised the goal-mode default.
- */
-export const INTERACTIVE_DEFAULT_MAX_STOP_BLOCKS = 8;
-/**
- * Resolve the consecutive-stop-block cap for a run. Precedence:
- *   1. explicit `configMaxStopBlocks` (engine/caller override)
- *   2. `goal.maxStopBlocks`
- *   3. GOAL_DEFAULT_MAX_STOP_BLOCKS when a goal is active,
- *      INTERACTIVE_DEFAULT_MAX_STOP_BLOCKS otherwise (don't leak the loose goal
- *      cap onto plain interactive runs — see B3 in the redesign doc).
- * Pure + injectable so engine and tests agree.
- */
-export function resolveMaxStopBlocks(configMaxStopBlocks, goal) {
-    if (typeof configMaxStopBlocks === "number" && configMaxStopBlocks > 0) {
-        return Math.floor(configMaxStopBlocks);
-    }
-    if (goal?.maxStopBlocks && goal.maxStopBlocks > 0)
-        return goal.maxStopBlocks;
-    return goal ? GOAL_DEFAULT_MAX_STOP_BLOCKS : INTERACTIVE_DEFAULT_MAX_STOP_BLOCKS;
-}
-/**
- * Turn ceiling applied when a goal is active and neither the GoalConfig nor
- * the engine config set an explicit maxTurns. Higher than the interactive
- * default (100) because goal runs are unattended and the stop-hook keeps the
- * loop going until the objective is met — the real safety backstops are the
- * token/time budgets and maxStopBlocks, not this ceiling. A round 300 gives
- * long goals room while still bounding a pathological loop.
- */
-export const GOAL_DEFAULT_MAX_TURNS = 300;
-/**
- * Coerce a raw goal input into a normalized GoalConfig, or undefined when
- * there is effectively no goal (empty objective). Drops non-positive
- * budgets (0 / negative → "no limit", same as absent).
- */
-export function normalizeGoal(raw) {
-    if (raw == null)
-        return undefined;
-    const obj = typeof raw === "string" ? { objective: raw } : { ...raw };
-    const objective = (obj.objective ?? "").trim();
-    if (!objective)
-        return undefined;
-    const out = { objective };
-    if (typeof obj.tokenBudget === "number" && obj.tokenBudget > 0)
-        out.tokenBudget = obj.tokenBudget;
-    if (typeof obj.timeBudgetMs === "number" && obj.timeBudgetMs > 0)
-        out.timeBudgetMs = obj.timeBudgetMs;
-    if (typeof obj.maxTurns === "number" && obj.maxTurns > 0)
-        out.maxTurns = Math.floor(obj.maxTurns);
-    if (typeof obj.maxStopBlocks === "number" && obj.maxStopBlocks > 0) {
-        out.maxStopBlocks = Math.floor(obj.maxStopBlocks);
-    }
-    // Preserve a positive goal-set timestamp so a resumed/inherited goal keeps
-    // the anchor for relative deadlines. Non-positive/junk is dropped, matching
-    // the budget fields (a bogus anchor is worse than none).
-    if (typeof obj.setAtMs === "number" && obj.setAtMs > 0)
-        out.setAtMs = obj.setAtMs;
-    return out;
-}
-/**
- * Decide the goal-set timestamp (setAtMs) to persist when a send supplies an
- * explicit goal. Pure so the engine and tests agree on the anchor rule:
- *   - A NEW or CHANGED objective → stamp `nowMs` (the user just expressed a
- *     fresh goal; any relative deadline in it is anchored to now).
- *   - The SAME objective continuing (bare re-send inheriting the stored goal) →
- *     keep the stored anchor, so a re-send doesn't silently move the deadline.
- *     Falls back to `nowMs` if the stored goal predates this field.
- * `stored` is the previously-persisted active goal (or undefined for the first
- * goal on a session).
- */
-export function resolveGoalSetAt(explicitObjective, stored, nowMs) {
-    const sameGoalContinues = !!stored && stored.objective === explicitObjective;
-    return sameGoalContinues ? (stored.setAtMs ?? nowMs) : nowMs;
-}
-/** Interactive (no-goal) turn ceiling — a single prompt rarely needs more. */
-export const INTERACTIVE_DEFAULT_MAX_TURNS = 100;
-/**
- * Resolve the turn ceiling for a run, honoring goal mode.
- *
- * Precedence (first defined wins):
- *   1. `configMaxTurns` — an explicit engine/caller override (always wins).
- *   2. `goal.maxTurns`  — a per-goal cap from the GoalConfig.
- *   3. `GOAL_DEFAULT_MAX_TURNS` when a goal is active (raise the unattended
- *      ceiling above the interactive default).
- *   4. `INTERACTIVE_DEFAULT_MAX_TURNS` otherwise.
- *
- * Pure + injectable so the engine and tests agree on the rule.
- */
-export function resolveMaxTurns(configMaxTurns, goal) {
-    if (typeof configMaxTurns === "number" && configMaxTurns > 0)
-        return configMaxTurns;
-    if (goal)
-        return goal.maxTurns ?? GOAL_DEFAULT_MAX_TURNS;
-    return INTERACTIVE_DEFAULT_MAX_TURNS;
-}
-/** Warn when this many turns (or fewer) remain before maxTurns. */
-export const APPROACH_TURNS = 5;
-/** Warn when this many consecutive blocks (or fewer) remain before the cap. */
-export const APPROACH_STOP_BLOCKS = 3;
-/**
- * Compute proximity to the two stop ceilings. Pure so turn-loop and tests
- * agree. `nearest` favors stopBlocks when both are near, because the stop-block
- * cap (default 25) is reached far sooner than maxTurns (default 300) for a
- * goal the judge keeps re-blocking — it's the limit that actually bites.
- */
-export function limitProximity(turnCount, maxTurns, stopBlockCount, maxStopBlocks) {
-    const turnsRemaining = maxTurns - turnCount;
-    const stopBlocksRemaining = maxStopBlocks - stopBlockCount;
-    const turnsNear = turnsRemaining <= APPROACH_TURNS;
-    const blocksNear = stopBlocksRemaining <= APPROACH_STOP_BLOCKS;
-    return {
-        turnsRemaining,
-        stopBlocksRemaining,
-        approaching: turnsNear || blocksNear,
-        nearest: blocksNear ? "stopBlocks" : "turns",
-    };
-}
-/**
- * Compute the new turn ceiling + goal budgets after a mid-run extension
- * (TODO 3.1). Pure so the TurnLoop and tests agree on the arithmetic:
- *   - addTurns bumps the maxTurns ceiling (floored, positive only).
- *   - addTokenBudget/addTimeBudgetMs raise the goal's caps. When a cap was
- *     previously unset ("unlimited"), we seed it from CURRENT USAGE before
- *     adding — `tokensUsed` for tokens, `elapsedMs` for time — so extending an
- *     unbounded run sets a fresh cap ABOVE current usage rather than below it.
- *     (Seeding time from 0 was bug B1: a long-running unbounded goal would get
- *     a cap below its elapsed time and force-stop immediately on extend.)
- *   - addStopBlocks is handled by the caller (TurnLoop.extend) against the live
- *     config, not here, since it isn't part of the goal budget shape.
- * `tokensUsed`/`elapsedMs` are the tracker's running totals (used only to seed
- * unset caps). Returns the resulting limits; never mutates its inputs.
- */
-export function applyGoalExtension(currentMaxTurns, goal, tokensUsed, elapsedMs, ext) {
-    let maxTurns = currentMaxTurns;
-    if (typeof ext.addTurns === "number" && ext.addTurns > 0) {
-        maxTurns += Math.floor(ext.addTurns);
-    }
-    let tokenBudget = goal?.tokenBudget;
-    let timeBudgetMs = goal?.timeBudgetMs;
-    if (goal) {
-        if (typeof ext.addTokenBudget === "number" && ext.addTokenBudget > 0) {
-            tokenBudget = (tokenBudget ?? tokensUsed) + Math.floor(ext.addTokenBudget);
-        }
-        if (typeof ext.addTimeBudgetMs === "number" && ext.addTimeBudgetMs > 0) {
-            // Seed an unset cap from elapsed time (not 0), mirroring the token branch,
-            // so the new cap lands above current usage. Fixes B1.
-            timeBudgetMs = (timeBudgetMs ?? elapsedMs) + Math.floor(ext.addTimeBudgetMs);
-        }
-    }
-    return { maxTurns, tokenBudget, timeBudgetMs };
-}
-/** Create a run-scoped tracker. `nowMs` is injected for testability. */
-export function createGoalBudgetTracker(goal, nowMs) {
-    return { goal, startedAtMs: nowMs, tokensUsed: 0 };
-}
-/** Add this turn's token usage to the running total. */
-export function recordGoalUsage(tracker, turnTokens) {
-    if (turnTokens > 0)
-        tracker.tokensUsed += turnTokens;
-}
-/**
- * Has the run exceeded any configured budget? `nowMs` is injected so callers
- * pass the current clock (and tests pass a fixed value).
- */
-export function goalBudgetExceeded(tracker, nowMs) {
-    return goalBudgetTerminationReason(tracker, nowMs) !== undefined;
-}
-/** Identify which goal budget forced termination, preserving token-first precedence. */
-export function goalBudgetTerminationReason(tracker, nowMs) {
-    const { tokenBudget, timeBudgetMs } = tracker.goal;
-    if (typeof tokenBudget === "number" && tracker.tokensUsed > tokenBudget) {
-        return "token_budget_exhausted";
-    }
-    if (typeof timeBudgetMs === "number" && nowMs - tracker.startedAtMs > timeBudgetMs) {
-        return "time_budget_exhausted";
-    }
-    return undefined;
-}

package/dist/external-agents/config.d.ts

@@ -1,2 +0,0 @@
-import type { ExternalAgentsSettings, ResolvedExternalAgentsConfig } from "./types.js";
-export declare function resolveExternalAgentConfig(settings: ExternalAgentsSettings | undefined): ResolvedExternalAgentsConfig;

package/dist/external-agents/config.js

@@ -1,15 +0,0 @@
-export function resolveExternalAgentConfig(settings) {
-    return {
-        claudeCode: {
-            command: settings?.claudeCode?.command ?? "claude",
-            defaultMode: settings?.claudeCode?.defaultMode ?? "safe",
-            dangerousArgs: settings?.claudeCode?.dangerousArgs ?? [],
-            trustedWorkspaces: settings?.claudeCode?.trustedWorkspaces ?? [],
-            autoStartInTrustedWorkspaces: settings?.claudeCode?.autoStartInTrustedWorkspaces ?? false,
-        },
-        codex: {
-            command: settings?.codex?.command ?? "codex",
-            args: settings?.codex?.args ?? [],
-        },
-    };
-}

package/dist/external-agents/types.d.ts

@@ -1,31 +0,0 @@
-export type ExternalAgentMode = "safe" | "dangerous";
-export interface ClaudeCodeSettings {
-    command?: string;
-    defaultMode?: ExternalAgentMode;
-    dangerousArgs?: string[];
-    trustedWorkspaces?: string[];
-    autoStartInTrustedWorkspaces?: boolean;
-}
-export interface CodexSettings {
-    command?: string;
-    args?: string[];
-}
-export interface ExternalAgentsSettings {
-    claudeCode?: ClaudeCodeSettings;
-    codex?: CodexSettings;
-}
-export interface ResolvedClaudeCodeSettings {
-    command: string;
-    defaultMode: ExternalAgentMode;
-    dangerousArgs: string[];
-    trustedWorkspaces: string[];
-    autoStartInTrustedWorkspaces: boolean;
-}
-export interface ResolvedCodexSettings {
-    command: string;
-    args: string[];
-}
-export interface ResolvedExternalAgentsConfig {
-    claudeCode: ResolvedClaudeCodeSettings;
-    codex: ResolvedCodexSettings;
-}

package/dist/git/parse-log.d.ts

@@ -1,13 +0,0 @@
-export interface GitLogEntry {
-    hash: string;
-    message: string;
-    author: string;
-    date: string;
-}
-/**
- * Parse `git log --format=%H|%s|%an|%ci` output into entries. Tolerates
- * malformed/short lines (missing `|` separators) by defaulting absent fields
- * to "" rather than destructuring `undefined` and crashing on `.slice`
- * (review-2026-05-30). Blank lines are skipped.
- */
-export declare function parseGitLog(raw: string): GitLogEntry[];

package/dist/git/parse-log.js

@@ -1,21 +0,0 @@
-/**
- * Parse `git log --format=%H|%s|%an|%ci` output into entries. Tolerates
- * malformed/short lines (missing `|` separators) by defaulting absent fields
- * to "" rather than destructuring `undefined` and crashing on `.slice`
- * (review-2026-05-30). Blank lines are skipped.
- */
-export function parseGitLog(raw) {
-    return raw
-        .split("\n")
-        .filter((line) => line.trim() !== "")
-        .map((line) => {
-        const parts = line.split("|");
-        const hash = parts[0] ?? "";
-        return {
-            hash: hash.slice(0, 8),
-            message: parts[1] ?? "",
-            author: parts[2] ?? "",
-            date: parts[3] ?? "",
-        };
-    });
-}

package/dist/git/utils.d.ts

@@ -1,49 +0,0 @@
-/**
- * Git utility functions for the git workflow commands.
- *
- * Every call goes through execFileSync with an argv array — no command
- * strings, no shell interpolation. Even arguments that look "safe" (already
- * quoted, hard-coded) are passed as separate argv tokens so a future caller
- * can't accidentally widen the attack surface by interpolating user input
- * into the string form.
- */
-import { type GitLogEntry } from "./parse-log.js";
-export interface GitStatusEntry {
-    status: string;
-    path: string;
-}
-export type { GitLogEntry };
-export declare function isGitRepo(cwd: string): boolean;
-/**
- * Resolve a directory to its PROJECT ROOT: the enclosing git repository's
- * top-level dir if `cwd` is inside a git repo, otherwise `cwd` unchanged.
- *
- * This is the project-boundary rule the desktop uses when adding/identifying a
- * project: picking a SUBDIRECTORY of a git repo should belong to that one repo
- * (its root), not spawn a separate project per subdir — mirrors how editors
- * (and Claude Code) treat a repo as one workspace. A non-git folder is its own
- * project (returned as-is). Never throws; on any git failure falls back to cwd.
- * Returns the git-reported toplevel (already absolute, forward-slashed on win).
- */
-export declare function resolveProjectRoot(cwd: string): string;
-export declare function getCurrentBranch(cwd: string): string;
-export declare function getGitStatus(cwd: string): GitStatusEntry[];
-export declare function getGitDiff(cwd: string, opts?: {
-    staged?: boolean;
-    file?: string;
-}): string;
-export declare function getGitDiffStat(cwd: string, opts?: {
-    staged?: boolean;
-    file?: string;
-}): string;
-export declare function getGitLog(cwd: string, n?: number): GitLogEntry[];
-export declare function getRemoteUrl(cwd: string): string | undefined;
-export declare function gitAdd(cwd: string, files?: string[]): void;
-export declare function gitCommit(cwd: string, message: string): string;
-export declare function gitListBranches(cwd: string): {
-    name: string;
-    current: boolean;
-}[];
-export declare function gitCheckout(cwd: string, branch: string, create?: boolean): void;
-export declare function ghAvailable(): boolean;
-export declare function ghPrComments(cwd: string, prUrl: string): string;