@shepai/cli 1.30.0 → 1.31.0

package/dist/packages/core/src/infrastructure/services/git/git-pr.service.js

@@ -0,0 +1,182 @@
+/**
+ * Git PR Service Implementation
+ *
+ * Manages git operations for PR creation, merging, and CI status checks.
+ * Uses constructor dependency injection for the command executor.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'tsyringe';
+import { GitPrError, GitPrErrorCode, } from '../../../application/ports/output/services/git-pr-service.interface.js';
+let GitPrService = class GitPrService {
+    execFile;
+    constructor(execFile) {
+        this.execFile = execFile;
+    }
+    async hasUncommittedChanges(cwd) {
+        const { stdout } = await this.execFile('git', ['status', '--porcelain'], { cwd });
+        return stdout.trim().length > 0;
+    }
+    async commitAll(cwd, message) {
+        try {
+            await this.execFile('git', ['add', '-A'], { cwd });
+            await this.execFile('git', ['commit', '-m', message], { cwd });
+            const { stdout } = await this.execFile('git', ['rev-parse', 'HEAD'], { cwd });
+            return stdout.trim();
+        }
+        catch (error) {
+            throw this.parseGitError(error);
+        }
+    }
+    async push(cwd, branch, setUpstream) {
+        const args = ['push'];
+        if (setUpstream)
+            args.push('--set-upstream');
+        args.push('origin', branch);
+        try {
+            await this.execFile('git', args, { cwd });
+        }
+        catch (error) {
+            throw this.parseGitError(error);
+        }
+    }
+    async createPr(cwd, prYamlPath) {
+        try {
+            const { stdout } = await this.execFile('gh', ['pr', 'create', '--title', prYamlPath, '--body-file', prYamlPath], { cwd });
+            const url = stdout.trim();
+            const number = this.parsePrNumberFromUrl(url);
+            return { url, number };
+        }
+        catch (error) {
+            throw this.parseGhError(error);
+        }
+    }
+    async mergePr(cwd, prNumber, strategy = 'squash') {
+        try {
+            await this.execFile('gh', ['pr', 'merge', String(prNumber), `--${strategy}`], { cwd });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const cause = error instanceof Error ? error : undefined;
+            throw new GitPrError(message, GitPrErrorCode.MERGE_FAILED, cause);
+        }
+    }
+    async mergeBranch(cwd, sourceBranch, targetBranch) {
+        try {
+            await this.execFile('git', ['checkout', targetBranch], { cwd });
+            await this.execFile('git', ['merge', sourceBranch], { cwd });
+            await this.execFile('git', ['push'], { cwd });
+        }
+        catch (error) {
+            throw this.parseGitError(error);
+        }
+    }
+    async getCiStatus(cwd, branch) {
+        const { stdout } = await this.execFile('gh', ['run', 'list', '--branch', branch, '--json', 'conclusion,url', '--limit', '1'], { cwd });
+        const runs = JSON.parse(stdout);
+        if (runs.length === 0 || !runs[0].conclusion) {
+            return { status: 'pending', runUrl: runs[0]?.url };
+        }
+        return {
+            status: runs[0].conclusion === 'success' ? 'success' : 'failure',
+            runUrl: runs[0].url,
+        };
+    }
+    async watchCi(cwd, branch, timeoutMs) {
+        try {
+            const args = ['run', 'watch', '--branch', branch];
+            const { stdout } = await this.execFile('gh', args, {
+                cwd,
+                ...(timeoutMs ? { timeout: timeoutMs } : {}),
+            });
+            const isSuccess = stdout.includes('success') || stdout.includes('completed');
+            return {
+                status: isSuccess ? 'success' : 'failure',
+                logExcerpt: stdout.trim(),
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const cause = error instanceof Error ? error : undefined;
+            if (message.includes('timed out') || message.includes('timeout')) {
+                throw new GitPrError(message, GitPrErrorCode.CI_TIMEOUT, cause);
+            }
+            throw new GitPrError(message, GitPrErrorCode.GIT_ERROR, cause);
+        }
+    }
+    async deleteBranch(cwd, branch, deleteRemote) {
+        try {
+            await this.execFile('git', ['branch', '-d', branch], { cwd });
+            if (deleteRemote) {
+                await this.execFile('git', ['push', 'origin', '--delete', branch], { cwd });
+            }
+        }
+        catch (error) {
+            throw this.parseGitError(error);
+        }
+    }
+    async getPrDiffSummary(cwd, baseBranch) {
+        const { stdout: diffStat } = await this.execFile('git', ['diff', '--stat', `${baseBranch}...HEAD`], { cwd });
+        const { stdout: logOutput } = await this.execFile('git', ['log', '--oneline', `${baseBranch}...HEAD`], { cwd });
+        return this.parseDiffStat(diffStat, logOutput);
+    }
+    parseGitError(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const cause = error instanceof Error ? error : undefined;
+        if (message.includes('rejected') || message.includes('conflict')) {
+            return new GitPrError(message, GitPrErrorCode.MERGE_CONFLICT, cause);
+        }
+        if (message.includes('Authentication') || message.includes('auth') || message.includes('403')) {
+            return new GitPrError(message, GitPrErrorCode.AUTH_FAILURE, cause);
+        }
+        return new GitPrError(message, GitPrErrorCode.GIT_ERROR, cause);
+    }
+    parseGhError(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const cause = error instanceof Error ? error : undefined;
+        const errnoCode = error?.code;
+        if (errnoCode === 'ENOENT' || message.includes('ENOENT')) {
+            return new GitPrError(message, GitPrErrorCode.GH_NOT_FOUND, cause);
+        }
+        if (message.includes('Authentication') || message.includes('auth') || message.includes('403')) {
+            return new GitPrError(message, GitPrErrorCode.AUTH_FAILURE, cause);
+        }
+        return new GitPrError(message, GitPrErrorCode.GIT_ERROR, cause);
+    }
+    parsePrNumberFromUrl(url) {
+        const match = url.match(/\/pull\/(\d+)/);
+        return match ? parseInt(match[1], 10) : 0;
+    }
+    parseDiffStat(diffStat, logOutput) {
+        const summaryLine = diffStat.trim().split('\n').pop() ?? '';
+        const filesMatch = summaryLine.match(/(\d+)\s+files?\s+changed/);
+        const addMatch = summaryLine.match(/(\d+)\s+insertions?\(\+\)/);
+        const delMatch = summaryLine.match(/(\d+)\s+deletions?\(-\)/);
+        const commitCount = logOutput
+            .trim()
+            .split('\n')
+            .filter((l) => l.trim()).length;
+        return {
+            filesChanged: filesMatch ? parseInt(filesMatch[1], 10) : 0,
+            additions: addMatch ? parseInt(addMatch[1], 10) : 0,
+            deletions: delMatch ? parseInt(delMatch[1], 10) : 0,
+            commitCount,
+        };
+    }
+};
+GitPrService = __decorate([
+    injectable(),
+    __param(0, inject('ExecFunction')),
+    __metadata("design:paramtypes", [Function])
+], GitPrService);
+export { GitPrService };

package/dist/src/presentation/cli/commands/feat/new.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"new.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/new.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgBpC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAsE1C"}
+{"version":3,"file":"new.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/new.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkCpC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAsF1C"}

package/dist/src/presentation/cli/commands/feat/new.command.js

@@ -16,6 +16,20 @@ import { container } from '../../../../../packages/core/src/infrastructure/di/co
 import { CreateFeatureUseCase } from '../../../../../packages/core/src/application/use-cases/features/create/create-feature.use-case.js';
 import { colors, messages, spinner } from '../../ui/index.js';
 import { getShepHomeDir } from '../../../../../packages/core/src/infrastructure/services/filesystem/shep-directory.service.js';
+import { getSettings, hasSettings } from '../../../../../packages/core/src/infrastructure/services/settings.service.js';
+/**
+ * Read workflow defaults from settings, falling back to false if settings unavailable.
+ */
+function getWorkflowDefaults() {
+    if (!hasSettings()) {
+        return { openPr: false, autoMerge: false };
+    }
+    const settings = getSettings();
+    return {
+        openPr: settings.workflow.openPrOnImplementationComplete,
+        autoMerge: settings.workflow.autoMergeOnImplementationComplete,
+    };
+}
 /**
  * Create the feat new command
  */
@@ -24,26 +38,43 @@ export function createNewCommand() {
         .description('Create a new feature')
         .argument('<description>', 'Feature description')
         .option('-r, --repo <path>', 'Repository path (defaults to current directory)')
+        .option('--pr', 'Open PR on implementation complete')
+        .option('--no-pr', 'Do not open PR on implementation complete')
+        .option('--auto-merge', 'Auto-merge on implementation complete')
+        .option('--no-auto-merge', 'Do not auto-merge on implementation complete')
         .option('--allow-prd', 'Auto-approve through requirements, pause after')
         .option('--allow-plan', 'Auto-approve through planning, pause at implementation')
+        .option('--allow-merge', 'Auto-approve merge phase')
         .option('--allow-all', 'Run fully autonomous (no approval pauses)')
         .action(async (description, options) => {
         try {
             const useCase = container.resolve(CreateFeatureUseCase);
             const repoPath = options.repo ?? process.cwd();
+            // Resolve openPr and autoMerge from CLI flags or settings defaults
+            const defaults = getWorkflowDefaults();
+            const openPr = options.pr ?? defaults.openPr;
+            const autoMerge = options.autoMerge ?? defaults.autoMerge;
             // Build approval gates from flags (default: pause after every phase)
             let approvalGates = {
                 allowPrd: !!options.allowPrd,
                 allowPlan: !!options.allowPlan,
                 allowMerge: false,
             };
-            if (options.allowAll) {
+            if (options.allowPlan)
+                approvalGates = { allowPrd: true, allowPlan: true, allowMerge: approvalGates.allowMerge };
+            if (options.allowMerge)
+                approvalGates = { ...approvalGates, allowMerge: true };
+            // --auto-merge implies --allow-merge
+            if (autoMerge)
+                approvalGates = { ...approvalGates, allowMerge: true };
+            if (options.allowAll)
                 approvalGates = undefined; // no gates = fully autonomous
-            }
             const result = await spinner('Thinking', () => useCase.execute({
                 userInput: description,
                 repositoryPath: repoPath,
                 approvalGates,
+                openPr,
+                autoMerge,
             }));
             const { feature, warning } = result;
             const repoHash = createHash('sha256').update(repoPath).digest('hex').slice(0, 16);