edsger 0.51.0 → 0.53.0

package/dist/phases/pr-execution/context.js

@@ -1,10 +1,10 @@
-import { execFileSync, execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { getGitHubConfig } from '../../api/github.js';
 import { getIssue } from '../../api/issues/index.js';
 import { getPullRequests, } from '../../services/pull-requests.js';
 import { branchExists, remoteBranchExists, } from '../../utils/git-branch-manager.js';
 import { buildCredentialArgs } from '../../utils/git-push.js';
-import { getRepoForkInfo, } from '../../utils/github-repo-info.js';
+import { getRepoForkInfo, resolveDefaultBranch, } from '../../utils/github-repo-info.js';
 import { logError, logInfo } from '../../utils/logger.js';
 /**
  * Get the dev branch name for an issue
@@ -16,14 +16,16 @@ function getDevBranchName(issueId) {
  * Get the HEAD SHA of a branch
  */
 function getBranchHeadSha(branchName) {
-    return execSync(`git rev-parse ${branchName}`, { encoding: 'utf-8' }).trim();
+    return execFileSync('git', ['rev-parse', branchName], {
+        encoding: 'utf-8',
+    }).trim();
 }
 /**
  * Get diff stat between two refs
  */
 function getDiffStat(baseRef, headRef) {
     try {
-        return execSync(`git diff --stat ${baseRef}...${headRef}`, {
+        return execFileSync('git', ['diff', '--stat', `${baseRef}...${headRef}`], {
             encoding: 'utf-8',
         }).trim();
     }
@@ -51,9 +53,7 @@ function parseGitStatus(status) {
  */
 function getChangedFiles(baseRef, headRef) {
     try {
-        const output = execSync(`git diff --name-status ${baseRef}...${headRef}`, {
-            encoding: 'utf-8',
-        }).trim();
+        const output = execFileSync('git', ['diff', '--name-status', `${baseRef}...${headRef}`], { encoding: 'utf-8' }).trim();
         if (!output) {
             return [];
         }
@@ -77,7 +77,7 @@ function getChangedFiles(baseRef, headRef) {
  */
 function isAncestor(commitSha, ref) {
     try {
-        execSync(`git merge-base --is-ancestor ${commitSha} ${ref}`, {
+        execFileSync('git', ['merge-base', '--is-ancestor', commitSha, ref], {
             encoding: 'utf-8',
             stdio: 'pipe',
         });
@@ -121,25 +121,50 @@ export async function fetchPRExecutionContext(issueId, verbose) {
             getPullRequests({ issueId, verbose }),
             getGitHubConfig(issueId, verbose),
         ]);
-        // Fetch latest remote refs and fast-forward local main
+        // Detect fork status + default branch (used by the fast-forward step below)
+        let forkInfo = { isFork: false };
+        if (githubConfig.token && githubConfig.owner && githubConfig.repo) {
+            try {
+                forkInfo = await getRepoForkInfo(githubConfig.token, githubConfig.owner, githubConfig.repo);
+                if (verbose) {
+                    logInfo(forkInfo.isFork
+                        ? `📌 Repository is a fork of ${forkInfo.upstream?.owner}/${forkInfo.upstream?.repo}`
+                        : `📌 Repository is not a fork`);
+                }
+            }
+            catch (error) {
+                if (verbose) {
+                    logError(`Failed to detect fork status: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        // Resolve the repo's default branch (e.g. main, master, develop). Falls back
+        // through GitHub API → local symbolic-ref → literal 'main'.
+        const defaultBranch = resolveDefaultBranch(forkInfo.defaultBranch);
+        // Fetch latest remote refs and fast-forward the local default branch.
+        // Use execFileSync (not execSync) so defaultBranch — which can flow in from
+        // the GitHub API's default_branch field — is never passed through a shell.
         try {
             const credArgs = buildCredentialArgs(githubConfig.token);
             execFileSync('git', [...credArgs, 'fetch', 'origin'], {
                 encoding: 'utf-8',
                 stdio: 'pipe',
             });
-            execSync('git checkout main', { encoding: 'utf-8', stdio: 'pipe' });
-            execSync('git merge --ff-only origin/main', {
+            execFileSync('git', ['checkout', defaultBranch], {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+            execFileSync('git', ['merge', '--ff-only', `origin/${defaultBranch}`], {
                 encoding: 'utf-8',
                 stdio: 'pipe',
             });
             if (verbose) {
-                logInfo('✅ Local main synced with origin/main');
+                logInfo(`✅ Local ${defaultBranch} synced with origin/${defaultBranch}`);
             }
         }
         catch (error) {
             if (verbose) {
-                logInfo(`⚠️  Could not sync main with origin: ${error instanceof Error ? error.message : String(error)}`);
+                logInfo(`⚠️  Could not sync ${defaultBranch} with origin: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
         // Verify dev branch exists
@@ -168,23 +193,6 @@ export async function fetchPRExecutionContext(issueId, verbose) {
         if (!githubConfig.configured) {
             throw new Error(`GitHub is not configured. ${githubConfig.message || 'Please configure GitHub integration.'}`);
         }
-        // Detect fork status
-        let forkInfo = { isFork: false };
-        if (githubConfig.token && githubConfig.owner && githubConfig.repo) {
-            try {
-                forkInfo = await getRepoForkInfo(githubConfig.token, githubConfig.owner, githubConfig.repo);
-                if (verbose) {
-                    logInfo(forkInfo.isFork
-                        ? `📌 Repository is a fork of ${forkInfo.upstream?.owner}/${forkInfo.upstream?.repo}`
-                        : `📌 Repository is not a fork`);
-                }
-            }
-            catch (error) {
-                if (verbose) {
-                    logError(`Failed to detect fork status: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
         // Determine sync mode
         const devRef = localExists ? devBranchName : `origin/${devBranchName}`;
         const devBranchHeadSha = getBranchHeadSha(devRef);
@@ -202,8 +210,8 @@ export async function fetchPRExecutionContext(issueId, verbose) {
             lastSyncedCommit = null;
             isIncrementalSync = false;
         }
-        // Get diff info: for incremental, diff from last sync; for first run, diff from main
-        const diffBase = isIncrementalSync && lastSyncedCommit ? lastSyncedCommit : 'main';
+        // Get diff info: for incremental, diff from last sync; for first run, diff from default branch
+        const diffBase = isIncrementalSync && lastSyncedCommit ? lastSyncedCommit : defaultBranch;
         const diffStat = getDiffStat(diffBase, devRef);
         const changedFiles = getChangedFiles(diffBase, devRef);
         if (verbose) {

package/dist/phases/pr-splitting/context.js

@@ -1,4 +1,4 @@
-import { execFileSync, execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { getGitHubConfig } from '../../api/github.js';
 import { getIssue } from '../../api/issues/index.js';
 import { getProduct } from '../../api/products.js';
@@ -6,7 +6,7 @@ import { getBranches } from '../../services/branches.js';
 import { getPullRequests, } from '../../services/pull-requests.js';
 import { branchExists, remoteBranchExists, } from '../../utils/git-branch-manager.js';
 import { buildCredentialArgs } from '../../utils/git-push.js';
-import { getRepoForkInfo, } from '../../utils/github-repo-info.js';
+import { getRepoForkInfo, resolveDefaultBranch, } from '../../utils/github-repo-info.js';
 import { logError, logInfo } from '../../utils/logger.js';
 /**
  * Get the dev branch name for an issue
@@ -18,14 +18,16 @@ function getDevBranchName(issueId) {
  * Get the HEAD SHA of a branch
  */
 function getBranchHeadSha(branchName) {
-    return execSync(`git rev-parse ${branchName}`, { encoding: 'utf-8' }).trim();
+    return execFileSync('git', ['rev-parse', branchName], {
+        encoding: 'utf-8',
+    }).trim();
 }
 /**
  * Get diff stat between two refs
  */
 function getDiffStat(baseRef, headRef) {
     try {
-        return execSync(`git diff --stat ${baseRef}...${headRef}`, {
+        return execFileSync('git', ['diff', '--stat', `${baseRef}...${headRef}`], {
             encoding: 'utf-8',
         }).trim();
     }
@@ -38,9 +40,7 @@ function getDiffStat(baseRef, headRef) {
  */
 function getChangedFiles(baseRef, headRef) {
     try {
-        const output = execSync(`git diff --name-only ${baseRef}...${headRef}`, {
-            encoding: 'utf-8',
-        }).trim();
+        const output = execFileSync('git', ['diff', '--name-only', `${baseRef}...${headRef}`], { encoding: 'utf-8' }).trim();
         if (!output) {
             return [];
         }
@@ -53,18 +53,18 @@ function getChangedFiles(baseRef, headRef) {
 /**
  * Determine the diff base ref for incremental re-runs
  * If existing PRs have last_synced_commit, use the earliest one
- * Otherwise use origin/main (remote-tracking ref, always up-to-date after fetch)
+ * Otherwise use origin/<defaultBranch> (remote-tracking ref, always up-to-date after fetch)
  */
-function determineDiffBaseRef(existingPRs, replaceExisting) {
+function determineDiffBaseRef(existingPRs, defaultBranchRef, replaceExisting) {
     if (replaceExisting || existingPRs.length === 0) {
-        return 'origin/main';
+        return defaultBranchRef;
     }
     // Find the minimum last_synced_commit (earliest sync point)
     const syncedCommits = existingPRs
         .map((pr) => pr.last_synced_commit)
         .filter((c) => c !== null);
     if (syncedCommits.length === 0) {
-        return 'origin/main';
+        return defaultBranchRef;
     }
     // All PRs should have been synced to the same commit
     // Use the first one (they should all be equal after a successful sync)
@@ -131,12 +131,17 @@ export async function fetchPRSplittingContext(issueId, verbose, replaceExisting)
                 }
             }
         }
+        // Resolve the repo's default branch (handles non-main defaults and forks).
+        // Prefer the GitHub API value (already fetched in forkInfo above); fall back
+        // to the local symbolic-ref, then to literal 'main'.
+        const defaultBranch = resolveDefaultBranch(forkInfo.defaultBranch);
+        const defaultBranchRef = `origin/${defaultBranch}`;
         // Determine diff range
         const devRef = localExists ? devBranchName : `origin/${devBranchName}`;
-        const baseRef = determineDiffBaseRef(existingPullRequests, replaceExisting);
+        const baseRef = determineDiffBaseRef(existingPullRequests, defaultBranchRef, replaceExisting);
         const devBranchHeadSha = getBranchHeadSha(devRef);
         // Check if there are new changes since last sync
-        if (baseRef !== 'origin/main' && baseRef === devBranchHeadSha) {
+        if (baseRef !== defaultBranchRef && baseRef === devBranchHeadSha) {
             if (verbose) {
                 logInfo(`No new changes since last sync (HEAD: ${devBranchHeadSha})`);
             }

package/dist/utils/github-repo-info.d.ts

@@ -7,8 +7,20 @@ export interface RepoForkInfo {
         owner: string;
         repo: string;
     };
+    defaultBranch?: string;
 }
 /**
- * Detect if a repository is a fork and get upstream info
+ * Detect if a repository is a fork and get upstream + default branch info
  */
 export declare function getRepoForkInfo(token: string, owner: string, repo: string): Promise<RepoForkInfo>;
+/**
+ * Resolve the repo's default branch with a multi-tier fallback:
+ *   1. `apiValue` from GitHub API (most authoritative)
+ *   2. local `git symbolic-ref refs/remotes/origin/HEAD`
+ *   3. literal `'main'`
+ *
+ * Use this anywhere we need to diff/merge against the upstream default branch.
+ * The hardcoded `origin/main` assumption breaks for repos whose default is
+ * `master`, `develop`, etc., or for forks that inherited a non-`main` default.
+ */
+export declare function resolveDefaultBranch(apiValue?: string): string;

package/dist/utils/github-repo-info.js

@@ -2,18 +2,44 @@
  * GitHub repository information utilities
  */
 import { Octokit } from '@octokit/rest';
+import { execFileSync } from 'child_process';
 /**
- * Detect if a repository is a fork and get upstream info
+ * Detect if a repository is a fork and get upstream + default branch info
  */
 export async function getRepoForkInfo(token, owner, repo) {
     const octokit = new Octokit({ auth: token });
     const { data } = await octokit.repos.get({ owner, repo });
+    const result = {
+        isFork: false,
+        defaultBranch: data.default_branch,
+    };
     if (data.fork && data.parent) {
         const [upstreamOwner, upstreamRepo] = data.parent.full_name.split('/');
-        return {
-            isFork: true,
-            upstream: { owner: upstreamOwner, repo: upstreamRepo },
-        };
+        result.isFork = true;
+        result.upstream = { owner: upstreamOwner, repo: upstreamRepo };
+    }
+    return result;
+}
+/**
+ * Resolve the repo's default branch with a multi-tier fallback:
+ *   1. `apiValue` from GitHub API (most authoritative)
+ *   2. local `git symbolic-ref refs/remotes/origin/HEAD`
+ *   3. literal `'main'`
+ *
+ * Use this anywhere we need to diff/merge against the upstream default branch.
+ * The hardcoded `origin/main` assumption breaks for repos whose default is
+ * `master`, `develop`, etc., or for forks that inherited a non-`main` default.
+ */
+export function resolveDefaultBranch(apiValue) {
+    if (apiValue) {
+        return apiValue;
+    }
+    try {
+        const ref = execFileSync('git', ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        const stripped = ref.replace(/^origin\//, '');
+        return stripped || 'main';
+    }
+    catch {
+        return 'main';
     }
-    return { isFork: false };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.51.0",
+  "version": "0.53.0",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"

package/vitest.config.ts

@@ -11,6 +11,8 @@ export default defineConfig({
       'src/phases/code-refine-verification/__tests__/**/*.test.ts',
       'src/phases/find-bugs/__tests__/**/*.test.ts',
       'src/phases/find-features/__tests__/**/*.test.ts',
+      'src/phases/find-smells/__tests__/**/*.test.ts',
+      'src/commands/find-smells/__tests__/**/*.test.ts',
     ],
     exclude: ['dist/**', 'node_modules/**'],
     environment: 'node',

package/dist/api/__tests__/app-store.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * Unit tests for app-store API helpers.
- *
- * Tests the parsing/extraction logic that getAppStorePrimaryLocale uses
- * to parse MCP response data.
- */
-export {};

package/dist/api/__tests__/app-store.test.js

@@ -1,60 +0,0 @@
-/**
- * Unit tests for app-store API helpers.
- *
- * Tests the parsing/extraction logic that getAppStorePrimaryLocale uses
- * to parse MCP response data.
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-/**
- * Extracts locale from an MCP response — mirrors the parsing logic
- * inside getAppStorePrimaryLocale without requiring network mocks.
- */
-function parseLocaleFromMcpResponse(result) {
-    const text = result?.content?.[0]?.text || '{}';
-    const parsed = JSON.parse(text);
-    return parsed.locale || null;
-}
-void describe('parseLocaleFromMcpResponse', () => {
-    void it('should return locale string when present', () => {
-        const result = { content: [{ text: '{"locale":"en-US"}' }] };
-        assert.strictEqual(parseLocaleFromMcpResponse(result), 'en-US');
-    });
-    void it('should return locale for non-English locales', () => {
-        assert.strictEqual(parseLocaleFromMcpResponse({ content: [{ text: '{"locale":"ja"}' }] }), 'ja');
-        assert.strictEqual(parseLocaleFromMcpResponse({
-            content: [{ text: '{"locale":"zh-Hans"}' }],
-        }), 'zh-Hans');
-        assert.strictEqual(parseLocaleFromMcpResponse({ content: [{ text: '{"locale":"fr-FR"}' }] }), 'fr-FR');
-    });
-    void it('should return null when locale is null', () => {
-        const result = { content: [{ text: '{"locale":null}' }] };
-        assert.strictEqual(parseLocaleFromMcpResponse(result), null);
-    });
-    void it('should return null when locale is empty string', () => {
-        const result = { content: [{ text: '{"locale":""}' }] };
-        assert.strictEqual(parseLocaleFromMcpResponse(result), null);
-    });
-    void it('should return null when content array is empty', () => {
-        const result = { content: [] };
-        assert.strictEqual(parseLocaleFromMcpResponse(result), null);
-    });
-    void it('should return null when content field is missing', () => {
-        assert.strictEqual(parseLocaleFromMcpResponse({}), null);
-    });
-    void it('should return null when result is null', () => {
-        assert.strictEqual(parseLocaleFromMcpResponse(null), null);
-    });
-    void it('should return null when result is undefined', () => {
-        assert.strictEqual(parseLocaleFromMcpResponse(undefined), null);
-    });
-    void it('should throw when text is not valid JSON', () => {
-        assert.throws(() => {
-            parseLocaleFromMcpResponse({ content: [{ text: 'not json' }] });
-        });
-    });
-    void it('should return null when text field is missing', () => {
-        const result = { content: [{}] };
-        assert.strictEqual(parseLocaleFromMcpResponse(result), null);
-    });
-});

package/dist/api/__tests__/intelligence.test.d.ts

@@ -1,11 +0,0 @@
-/**
- * Tests for the MCP handler logic used in intelligence.ts.
- *
- * Since the actual MCP handlers run in Deno (supabase edge functions),
- * we test the equivalent logic at the API wrapper level by mocking
- * callMcpEndpoint responses. This verifies:
- * - Response parsing for all entity types
- * - Error handling for failed/empty responses
- * - Correct parameter formatting
- */
-export {};