@helmiq/crew-git 0.1.0

package/dist/branch-conventions.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Validate a branch name against a project's configured naming convention.
+ *
+ * If no convention pattern is configured, any branch name is accepted.
+ * The pattern is a regex string from `project.conventions.branch_naming`.
+ */
+export declare function validateBranchName(branchName: string, conventionPattern?: string): void;
+export declare class BranchConventionError extends Error {
+    readonly code: "BRANCH_NAME_INVALID";
+    constructor(message: string);
+}
+//# sourceMappingURL=branch-conventions.d.ts.map

package/dist/branch-conventions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-conventions.d.ts","sourceRoot":"","sources":["../src/branch-conventions.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CASvF;AAED,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,EAAG,qBAAqB,CAAU;gBACnC,OAAO,EAAE,MAAM;CAI5B"}

package/dist/branch-conventions.js

@@ -0,0 +1,21 @@
+/**
+ * Validate a branch name against a project's configured naming convention.
+ *
+ * If no convention pattern is configured, any branch name is accepted.
+ * The pattern is a regex string from `project.conventions.branch_naming`.
+ */
+export function validateBranchName(branchName, conventionPattern) {
+    if (!conventionPattern)
+        return;
+    const regex = new RegExp(conventionPattern);
+    if (!regex.test(branchName)) {
+        throw new BranchConventionError(`Branch name "${branchName}" does not match convention: ${conventionPattern}`);
+    }
+}
+export class BranchConventionError extends Error {
+    code = 'BRANCH_NAME_INVALID';
+    constructor(message) {
+        super(message);
+        this.name = 'BranchConventionError';
+    }
+}

package/dist/git-tools.test.d.ts

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

package/dist/git-tools.test.d.ts.map

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

package/dist/git-tools.test.js

@@ -0,0 +1,177 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtemp, rm, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { simpleGit } from 'simple-git';
+import { validateBranchName, BranchConventionError } from './branch-conventions.js';
+import { gitBranch } from './tool-git-branch.js';
+import { gitCommit } from './tool-git-commit.js';
+import { gitDiff } from './tool-git-diff.js';
+import { gitLog } from './tool-git-log.js';
+import { createGithubPr, GitHubClientError } from './github-client.js';
+describe('Git Tools', () => {
+    let repoDir;
+    beforeEach(async () => {
+        repoDir = await mkdtemp(join(tmpdir(), 'crew-git-tools-'));
+        const g = simpleGit(repoDir);
+        await g.init();
+        await g.addConfig('user.email', 'test@crew.dev');
+        await g.addConfig('user.name', 'Crew Test');
+        await writeFile(join(repoDir, 'README.md'), '# Test repo\n', 'utf-8');
+        await g.add('.');
+        await g.commit('initial commit');
+    });
+    afterEach(async () => {
+        await rm(repoDir, { recursive: true, force: true });
+    });
+    // T-02-003a: branch creation with naming convention
+    describe('branch conventions', () => {
+        it('accepts branch matching convention', () => {
+            expect(() => validateBranchName('feat/CREW-01-001-add-feature', '^(feat|fix|chore)/[A-Z]+-[0-9]+-.+$')).not.toThrow();
+        });
+        it('rejects branch not matching convention', () => {
+            expect(() => validateBranchName('bad-name', '^(feat|fix|chore)/[A-Z]+-[0-9]+-.+$')).toThrow(BranchConventionError);
+        });
+        it('accepts any branch when no convention is set', () => {
+            expect(() => validateBranchName('anything-goes')).not.toThrow();
+        });
+    });
+    describe('tool:git-branch', () => {
+        it('creates and checks out a new branch', async () => {
+            const result = await gitBranch({ branchName: 'feat/CREW-02-003-test' }, repoDir, '^feat/.+$');
+            expect(result.branch).toBe('feat/CREW-02-003-test');
+            expect(result.status).toBe('checked_out');
+            const g = simpleGit(repoDir);
+            const status = await g.status();
+            expect(status.current).toBe('feat/CREW-02-003-test');
+        });
+        it('rejects branch that violates convention', async () => {
+            await expect(gitBranch({ branchName: 'bad-name' }, repoDir, '^feat/.+$')).rejects.toThrow(BranchConventionError);
+        });
+    });
+    // T-02-003b: commit/push flow (commit only; push requires remote)
+    describe('tool:git-commit', () => {
+        it('stages and commits files', async () => {
+            await mkdir(join(repoDir, 'src'), { recursive: true });
+            await writeFile(join(repoDir, 'src/new.ts'), 'export const x = 1;\n', 'utf-8');
+            const result = await gitCommit({ filePaths: ['src/new.ts'], message: 'feat: add new file' }, repoDir);
+            expect(result.status).toBe('committed');
+            expect(result.commitSha).not.toBe('unknown');
+            const g = simpleGit(repoDir);
+            const log = await g.log({ maxCount: 1 });
+            expect(log.latest?.message).toBe('feat: add new file');
+        });
+    });
+    // T-02-003c: diff/log retrieval
+    describe('tool:git-diff', () => {
+        it('returns diff of unstaged changes', async () => {
+            await writeFile(join(repoDir, 'README.md'), '# Updated\n', 'utf-8');
+            const result = await gitDiff({}, repoDir);
+            expect(result.diff).toContain('Updated');
+        });
+    });
+    describe('tool:git-log', () => {
+        it('returns commit log entries', async () => {
+            const result = await gitLog({ maxCount: 5 }, repoDir);
+            expect(result.entries.length).toBeGreaterThanOrEqual(1);
+            expect(result.entries[0].message).toBe('initial commit');
+            expect(result.entries[0].hash).toBeTruthy();
+        });
+    });
+    // T-02-003d: GitHub PR creation payload
+    describe('github-client', () => {
+        afterEach(() => {
+            vi.restoreAllMocks();
+        });
+        it('creates a PR with correct payload', async () => {
+            const mockResponse = {
+                number: 42,
+                url: 'https://api.github.com/repos/test/repo/pulls/42',
+                html_url: 'https://github.com/test/repo/pull/42',
+            };
+            vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve(mockResponse),
+            }));
+            const result = await createGithubPr({
+                owner: 'test',
+                repo: 'repo',
+                title: 'feat: add feature',
+                body: 'Description here',
+                head: 'feat/branch',
+                base: 'main',
+            }, 'ghp_test_token');
+            expect(result.number).toBe(42);
+            expect(result.url).toBe('https://api.github.com/repos/test/repo/pulls/42');
+            expect(result.htmlUrl).toBe('https://github.com/test/repo/pull/42');
+            const fetchCalls = vi.mocked(fetch).mock.calls;
+            expect(fetchCalls.length).toBe(1);
+            const [url, options] = fetchCalls[0];
+            expect(url).toBe('https://api.github.com/repos/test/repo/pulls');
+            expect(options.method).toBe('POST');
+            const body = JSON.parse(options.body);
+            expect(body.title).toBe('feat: add feature');
+            expect(body.head).toBe('feat/branch');
+            expect(body.base).toBe('main');
+        });
+        it('throws GITHUB_TOKEN_MISSING when no token is provided', async () => {
+            const original = process.env['GITHUB_TOKEN'];
+            delete process.env['GITHUB_TOKEN'];
+            await expect(createGithubPr({
+                owner: 'test',
+                repo: 'repo',
+                title: 'test',
+                body: 'test',
+                head: 'branch',
+                base: 'main',
+            })).rejects.toThrow(GitHubClientError);
+            if (original)
+                process.env['GITHUB_TOKEN'] = original;
+        });
+        it('throws PR_CREATION_FAILED on non-ok response', async () => {
+            vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+                ok: false,
+                status: 422,
+                text: () => Promise.resolve('{"message":"Validation Failed"}'),
+            }));
+            await expect(createGithubPr({
+                owner: 'test',
+                repo: 'repo',
+                title: 'test',
+                body: 'test',
+                head: 'branch',
+                base: 'main',
+            }, 'ghp_test_token')).rejects.toThrow(/PR_CREATION_FAILED|422/);
+        });
+        it('sends labels in a separate request when provided', async () => {
+            const prResponse = {
+                number: 10,
+                url: 'https://api.github.com/repos/test/repo/pulls/10',
+                html_url: 'https://github.com/test/repo/pull/10',
+            };
+            vi.stubGlobal('fetch', vi
+                .fn()
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(prResponse),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve([]),
+            }));
+            const result = await createGithubPr({
+                owner: 'test',
+                repo: 'repo',
+                title: 'feat: labeled',
+                body: 'With labels',
+                head: 'branch',
+                base: 'main',
+                labels: ['bug', 'priority'],
+            }, 'ghp_test_token');
+            expect(result.number).toBe(10);
+            const fetchCalls = vi.mocked(fetch).mock.calls;
+            expect(fetchCalls.length).toBe(2);
+            expect(fetchCalls[1][0]).toContain('/issues/10/labels');
+        });
+    });
+});

package/dist/github-client.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Thin GitHub REST client for PR creation and check-run queries.
+ *
+ * Uses Node.js built-in `fetch` per ADR-0012. Zero external dependencies.
+ * Authentication via GITHUB_TOKEN environment variable as Bearer token.
+ */
+export interface CreatePrParams {
+    owner: string;
+    repo: string;
+    title: string;
+    body: string;
+    head: string;
+    base: string;
+    labels?: string[];
+}
+export interface CreatePrResult {
+    number: number;
+    url: string;
+    htmlUrl: string;
+}
+export declare function createGithubPr(params: CreatePrParams, token?: string): Promise<CreatePrResult>;
+export declare class GitHubClientError extends Error {
+    readonly code: string;
+    readonly statusCode?: number;
+    constructor(message: string, code: string, statusCode?: number);
+}
+//# sourceMappingURL=github-client.d.ts.map

package/dist/github-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-client.d.ts","sourceRoot":"","sources":["../src/github-client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,cAAc,CAClC,MAAM,EAAE,cAAc,EACtB,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,cAAc,CAAC,CAoDzB;AAgCD,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;gBAEjB,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;CAM/D"}

package/dist/github-client.js

@@ -0,0 +1,74 @@
+/**
+ * Thin GitHub REST client for PR creation and check-run queries.
+ *
+ * Uses Node.js built-in `fetch` per ADR-0012. Zero external dependencies.
+ * Authentication via GITHUB_TOKEN environment variable as Bearer token.
+ */
+const GITHUB_API = 'https://api.github.com';
+export async function createGithubPr(params, token) {
+    const authToken = token ?? process.env['GITHUB_TOKEN'];
+    if (!authToken) {
+        throw new GitHubClientError('GITHUB_TOKEN environment variable is not set. Required for PR creation.', 'GITHUB_TOKEN_MISSING');
+    }
+    const prResponse = await fetch(`${GITHUB_API}/repos/${params.owner}/${params.repo}/pulls`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${authToken}`,
+            'Content-Type': 'application/json',
+            Accept: 'application/vnd.github+json',
+            'X-GitHub-Api-Version': '2022-11-28',
+        },
+        body: JSON.stringify({
+            title: params.title,
+            body: params.body,
+            head: params.head,
+            base: params.base,
+        }),
+    });
+    if (!prResponse.ok) {
+        const errorBody = await prResponse.text();
+        throw new GitHubClientError(`GitHub PR creation failed (${prResponse.status}): ${errorBody}`, 'PR_CREATION_FAILED', prResponse.status);
+    }
+    const prData = (await prResponse.json());
+    const prNumber = prData['number'];
+    const prUrl = prData['url'];
+    const prHtmlUrl = prData['html_url'];
+    if (params.labels && params.labels.length > 0) {
+        try {
+            await addLabels(params.owner, params.repo, prNumber, params.labels, authToken);
+        }
+        catch {
+            // Labels are best-effort per design; PR was created successfully
+        }
+    }
+    return {
+        number: prNumber,
+        url: prUrl,
+        htmlUrl: prHtmlUrl,
+    };
+}
+async function addLabels(owner, repo, issueNumber, labels, token) {
+    const response = await fetch(`${GITHUB_API}/repos/${owner}/${repo}/issues/${issueNumber}/labels`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+            Accept: 'application/vnd.github+json',
+            'X-GitHub-Api-Version': '2022-11-28',
+        },
+        body: JSON.stringify({ labels }),
+    });
+    if (!response.ok) {
+        throw new GitHubClientError(`Failed to add labels (${response.status})`, 'PR_LABELS_FAILED', response.status);
+    }
+}
+export class GitHubClientError extends Error {
+    code;
+    statusCode;
+    constructor(message, code, statusCode) {
+        super(message);
+        this.name = 'GitHubClientError';
+        this.code = code;
+        this.statusCode = statusCode;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { validateBranchName, BranchConventionError } from './branch-conventions.js';
+export { createGithubPr, GitHubClientError } from './github-client.js';
+export type { CreatePrParams, CreatePrResult } from './github-client.js';
+export { gitBranch, GitToolError } from './tool-git-branch.js';
+export type { GitBranchParams, GitBranchResult } from './tool-git-branch.js';
+export { gitCommit } from './tool-git-commit.js';
+export type { GitCommitParams, GitCommitResult } from './tool-git-commit.js';
+export { gitPush } from './tool-git-push.js';
+export type { GitPushParams, GitPushResult } from './tool-git-push.js';
+export { gitDiff } from './tool-git-diff.js';
+export type { GitDiffParams, GitDiffResult } from './tool-git-diff.js';
+export { gitLog } from './tool-git-log.js';
+export type { GitLogParams, GitLogResult, GitLogEntry } from './tool-git-log.js';
+export { createPr } from './tool-create-pr.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AACpF,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAC/D,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export { validateBranchName, BranchConventionError } from './branch-conventions.js';
+export { createGithubPr, GitHubClientError } from './github-client.js';
+export { gitBranch, GitToolError } from './tool-git-branch.js';
+export { gitCommit } from './tool-git-commit.js';
+export { gitPush } from './tool-git-push.js';
+export { gitDiff } from './tool-git-diff.js';
+export { gitLog } from './tool-git-log.js';
+export { createPr } from './tool-create-pr.js';

package/dist/tool-create-pr.d.ts

@@ -0,0 +1,4 @@
+import type { CreatePrParams, CreatePrResult } from './github-client.js';
+export type { CreatePrParams, CreatePrResult };
+export declare function createPr(params: CreatePrParams, token?: string): Promise<CreatePrResult>;
+//# sourceMappingURL=tool-create-pr.d.ts.map

package/dist/tool-create-pr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-create-pr.d.ts","sourceRoot":"","sources":["../src/tool-create-pr.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC;AAE/C,wBAAsB,QAAQ,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAE9F"}

package/dist/tool-create-pr.js

@@ -0,0 +1,4 @@
+import { createGithubPr } from './github-client.js';
+export async function createPr(params, token) {
+    return createGithubPr(params, token);
+}

package/dist/tool-git-branch.d.ts

@@ -0,0 +1,13 @@
+export interface GitBranchParams {
+    branchName: string;
+}
+export interface GitBranchResult {
+    branch: string;
+    status: 'checked_out';
+}
+export declare function gitBranch(params: GitBranchParams, repoPath: string, branchConvention?: string): Promise<GitBranchResult>;
+export declare class GitToolError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+//# sourceMappingURL=tool-git-branch.d.ts.map

package/dist/tool-git-branch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-git-branch.d.ts","sourceRoot":"","sources":["../src/tool-git-branch.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,aAAa,CAAC;CACvB;AAED,wBAAsB,SAAS,CAC7B,MAAM,EAAE,eAAe,EACvB,QAAQ,EAAE,MAAM,EAChB,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,eAAe,CAAC,CAa1B;AAED,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBACV,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAK1C"}

package/dist/tool-git-branch.js

@@ -0,0 +1,21 @@
+import { simpleGit } from 'simple-git';
+import { validateBranchName } from './branch-conventions.js';
+export async function gitBranch(params, repoPath, branchConvention) {
+    validateBranchName(params.branchName, branchConvention);
+    const g = simpleGit(repoPath);
+    try {
+        await g.checkoutLocalBranch(params.branchName);
+        return { branch: params.branchName, status: 'checked_out' };
+    }
+    catch (err) {
+        throw new GitToolError(`Failed to create branch '${params.branchName}': ${err instanceof Error ? err.message : String(err)}`, 'GIT_BRANCH_FAILED');
+    }
+}
+export class GitToolError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = 'GitToolError';
+        this.code = code;
+    }
+}

package/dist/tool-git-commit.d.ts

@@ -0,0 +1,10 @@
+export interface GitCommitParams {
+    filePaths: string[];
+    message: string;
+}
+export interface GitCommitResult {
+    commitSha: string;
+    status: 'committed';
+}
+export declare function gitCommit(params: GitCommitParams, repoPath: string): Promise<GitCommitResult>;
+//# sourceMappingURL=tool-git-commit.d.ts.map

package/dist/tool-git-commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-git-commit.d.ts","sourceRoot":"","sources":["../src/tool-git-commit.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,wBAAsB,SAAS,CAC7B,MAAM,EAAE,eAAe,EACvB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,eAAe,CAAC,CAc1B"}

package/dist/tool-git-commit.js

@@ -0,0 +1,14 @@
+import { simpleGit } from 'simple-git';
+import { GitToolError } from './tool-git-branch.js';
+export async function gitCommit(params, repoPath) {
+    const g = simpleGit(repoPath);
+    try {
+        await g.add(params.filePaths);
+        const result = await g.commit(params.message, params.filePaths);
+        const sha = result.commit || 'unknown';
+        return { commitSha: sha, status: 'committed' };
+    }
+    catch (err) {
+        throw new GitToolError(`Git commit failed: ${err instanceof Error ? err.message : String(err)}`, 'GIT_COMMIT_FAILED');
+    }
+}

package/dist/tool-git-diff.d.ts

@@ -0,0 +1,10 @@
+export interface GitDiffParams {
+    staged?: boolean;
+    paths?: string[];
+}
+export interface GitDiffResult {
+    diff: string;
+    filesChanged: number;
+}
+export declare function gitDiff(params: GitDiffParams, repoPath: string): Promise<GitDiffResult>;
+//# sourceMappingURL=tool-git-diff.d.ts.map

package/dist/tool-git-diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-git-diff.d.ts","sourceRoot":"","sources":["../src/tool-git-diff.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wBAAsB,OAAO,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CA2B7F"}

package/dist/tool-git-diff.js

@@ -0,0 +1,26 @@
+import { simpleGit } from 'simple-git';
+import { GitToolError } from './tool-git-branch.js';
+export async function gitDiff(params, repoPath) {
+    const g = simpleGit(repoPath);
+    try {
+        const args = [];
+        if (params.staged)
+            args.push('--cached');
+        if (params.paths && params.paths.length > 0) {
+            args.push('--', ...params.paths);
+        }
+        const diffOutput = await g.diff(args);
+        const statArgs = [...args.filter((a) => a !== '--cached'), '--stat'];
+        if (params.staged)
+            statArgs.unshift('--cached');
+        const statOutput = await g.diff(statArgs);
+        const filesChanged = statOutput.match(/\d+ files? changed/)?.[0]?.match(/\d+/)?.[0] ?? '0';
+        return {
+            diff: diffOutput,
+            filesChanged: parseInt(filesChanged, 10),
+        };
+    }
+    catch (err) {
+        throw new GitToolError(`Git diff failed: ${err instanceof Error ? err.message : String(err)}`, 'GIT_DIFF_FAILED');
+    }
+}

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

@@ -0,0 +1,15 @@
+export interface GitLogParams {
+    maxCount?: number;
+    path?: string;
+}
+export interface GitLogEntry {
+    hash: string;
+    date: string;
+    message: string;
+    author: string;
+}
+export interface GitLogResult {
+    entries: GitLogEntry[];
+}
+export declare function gitLog(params: GitLogParams, repoPath: string): Promise<GitLogResult>;
+//# sourceMappingURL=tool-git-log.d.ts.map

package/dist/tool-git-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-git-log.d.ts","sourceRoot":"","sources":["../src/tool-git-log.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,WAAW,EAAE,CAAC;CACxB;AAID,wBAAsB,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA0B1F"}

package/dist/tool-git-log.js

@@ -0,0 +1,24 @@
+import { simpleGit } from 'simple-git';
+import { GitToolError } from './tool-git-branch.js';
+const DEFAULT_MAX_COUNT = 20;
+export async function gitLog(params, repoPath) {
+    const g = simpleGit(repoPath);
+    const maxCount = params.maxCount ?? DEFAULT_MAX_COUNT;
+    try {
+        const options = { maxCount };
+        if (params.path) {
+            options['file'] = params.path;
+        }
+        const log = await g.log(options);
+        const entries = (log.all ?? []).map((entry) => ({
+            hash: entry.hash,
+            date: entry.date,
+            message: entry.message,
+            author: entry.author_name,
+        }));
+        return { entries };
+    }
+    catch (err) {
+        throw new GitToolError(`Git log failed: ${err instanceof Error ? err.message : String(err)}`, 'GIT_LOG_FAILED');
+    }
+}

package/dist/tool-git-push.d.ts

@@ -0,0 +1,9 @@
+export interface GitPushParams {
+    branch?: string;
+}
+export interface GitPushResult {
+    branch: string;
+    status: 'pushed';
+}
+export declare function gitPush(params: GitPushParams, repoPath: string): Promise<GitPushResult>;
+//# sourceMappingURL=tool-git-push.d.ts.map

package/dist/tool-git-push.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-git-push.d.ts","sourceRoot":"","sources":["../src/tool-git-push.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,QAAQ,CAAC;CAClB;AAKD,wBAAsB,OAAO,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAqB7F"}

package/dist/tool-git-push.js

@@ -0,0 +1,28 @@
+import { simpleGit } from 'simple-git';
+import { GitToolError } from './tool-git-branch.js';
+const PUSH_RETRIES = 2;
+const PUSH_DELAY_MS = 2000;
+export async function gitPush(params, repoPath) {
+    const g = simpleGit(repoPath);
+    const branch = params.branch ?? (await getCurrentBranch(g));
+    for (let attempt = 0; attempt <= PUSH_RETRIES; attempt++) {
+        try {
+            await g.push('origin', branch);
+            return { branch, status: 'pushed' };
+        }
+        catch (err) {
+            if (attempt === PUSH_RETRIES) {
+                throw new GitToolError(`Git push failed after ${PUSH_RETRIES + 1} attempts: ${err instanceof Error ? err.message : String(err)}`, 'GIT_PUSH_FAILED');
+            }
+            await sleep(PUSH_DELAY_MS);
+        }
+    }
+    throw new GitToolError('Git push failed: unexpected control flow', 'GIT_PUSH_FAILED');
+}
+async function getCurrentBranch(g) {
+    const status = await g.status();
+    return status.current ?? 'HEAD';
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@helmiq/crew-git",
+  "version": "0.1.0",
+  "description": "Git and GitHub tools for the Crew delivery runtime",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/helmiq/crew",
+    "directory": "packages/crew-git"
+  },
+  "keywords": [
+    "helmiq",
+    "crew",
+    "tools",
+    "git",
+    "github"
+  ],
+  "engines": {
+    "node": ">=20.9.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "simple-git": "^3.33.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2",
+    "@helmiq/typescript-config": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.json",
+    "typecheck": "tsc --noEmit --project tsconfig.json"
+  }
+}