@atlaspack/inspector 0.0.19-canary.3998

package/lib/backend/services/buildTreemapBundle.test.js

@@ -0,0 +1,298 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const sinon = __importStar(require("sinon"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const buildTreemap_1 = require("./buildTreemap");
+jest.mock('../config/logger');
+describe('buildTreemapBundle', function () {
+    let sandbox;
+    let mockBundleGraph;
+    let mockNode;
+    let mockWriteBundleRequestsByBundleId;
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+        // Mock fs.statSync
+        sandbox.stub(fs_1.default, 'statSync').returns({ size: 1024 });
+        // Mock path.join
+        sandbox
+            .stub(path_1.default, 'join')
+            .callsFake((...paths) => paths.join('/'));
+        // Mock bundle node
+        mockNode = {
+            id: 'bundle123',
+            type: 'bundle',
+            value: {
+                displayName: 'main.js',
+            },
+        };
+        // Mock bundle graph with traverseAssets method
+        mockBundleGraph = {
+            traverseAssets: sandbox.stub(),
+        };
+        // Mock write bundle requests map
+        mockWriteBundleRequestsByBundleId = new Map([
+            [
+                'bundle123',
+                {
+                    result: {
+                        bundleId: 'bundle123',
+                        filePath: 'dist/main.js',
+                    },
+                },
+            ],
+        ]);
+    });
+    afterEach(() => {
+        sandbox.restore();
+    });
+    it('should build treemap bundle with correct basic properties', function () {
+        // Setup mock assets
+        const mockAssets = [
+            {
+                filePath: '/src/index.js',
+                stats: { size: 100 },
+            },
+            {
+                filePath: '/src/utils.js',
+                stats: { size: 50 },
+            },
+        ];
+        // Mock traverseAssets to call callback with each asset
+        mockBundleGraph.traverseAssets.callsFake((bundleValue, callback) => {
+            mockAssets.forEach(callback);
+        });
+        const result = (0, buildTreemap_1.buildTreemapBundle)({
+            writeBundleRequestsByBundleId: mockWriteBundleRequestsByBundleId,
+            node: mockNode,
+            projectRoot: '/project',
+            repositoryRoot: '/project',
+            bundleGraph: mockBundleGraph,
+        });
+        assert_1.default.equal(result.id, 'bundle123');
+        assert_1.default.equal(result.displayName, 'main.js');
+        assert_1.default.equal(result.bundle, mockNode);
+        assert_1.default.equal(result.size, 1024); // from mocked fs.statSync
+        assert_1.default.equal(result.filePath, 'dist/main.js');
+        (0, assert_1.default)(result.assetTree);
+    });
+    it('should handle missing write bundle request', function () {
+        const emptyMap = new Map();
+        mockBundleGraph.traverseAssets.callsFake((_bundleValue, _callback) => {
+            // No assets
+        });
+        const result = (0, buildTreemap_1.buildTreemapBundle)({
+            writeBundleRequestsByBundleId: emptyMap,
+            node: mockNode,
+            projectRoot: '/project',
+            repositoryRoot: '/project',
+            bundleGraph: mockBundleGraph,
+        });
+        assert_1.default.equal(result.size, 0);
+        assert_1.default.equal(result.filePath, '');
+    });
+    it('should build correct asset tree structure', function () {
+        const mockAssets = [
+            {
+                filePath: 'src/components/Button.js',
+                stats: { size: 100 },
+            },
+            {
+                filePath: 'src/utils/helpers.js',
+                stats: { size: 50 },
+            },
+        ];
+        mockBundleGraph.traverseAssets.callsFake((bundleValue, callback) => {
+            mockAssets.forEach(callback);
+        });
+        const result = (0, buildTreemap_1.buildTreemapBundle)({
+            writeBundleRequestsByBundleId: mockWriteBundleRequestsByBundleId,
+            node: mockNode,
+            projectRoot: '/project',
+            repositoryRoot: '/project',
+            bundleGraph: mockBundleGraph,
+        });
+        // Check that tree structure exists
+        (0, assert_1.default)(result.assetTree.children.src);
+        assert_1.default.equal(result.assetTree.path, '');
+        assert_1.default.equal(result.assetTree.children.src.path, '/src');
+        // Check components subdirectory exists
+        (0, assert_1.default)(result.assetTree.children.src.children.components);
+        assert_1.default.equal(result.assetTree.children.src.children.components.path, '/src/components');
+        // Check utils subdirectory exists
+        (0, assert_1.default)(result.assetTree.children.src.children.utils);
+        assert_1.default.equal(result.assetTree.children.src.children.utils.path, '/src/utils');
+        assert_1.default.equal(result.assetTree.size, 150);
+        assert_1.default.equal(result.assetTree.children.src.size, 150);
+        assert_1.default.equal(result.assetTree.children.src.children.components.size, 100);
+        assert_1.default.equal(result.assetTree.children.src.children.utils.size, 50);
+    });
+    it('should handle assets with same directory correctly', function () {
+        const mockAssets = [
+            {
+                filePath: 'lib/module1.js',
+                stats: { size: 100 },
+            },
+            {
+                filePath: 'lib/module2.js',
+                stats: { size: 200 },
+            },
+        ];
+        mockBundleGraph.traverseAssets.callsFake((bundleValue, callback) => {
+            mockAssets.forEach(callback);
+        });
+        const result = (0, buildTreemap_1.buildTreemapBundle)({
+            writeBundleRequestsByBundleId: mockWriteBundleRequestsByBundleId,
+            node: mockNode,
+            projectRoot: '/project',
+            repositoryRoot: '/project',
+            bundleGraph: mockBundleGraph,
+        });
+        // lib directory should contain total of all files under it
+        assert_1.default.equal(result.assetTree.children.lib.size, 300); // 100 + 200
+        assert_1.default.equal(result.assetTree.children.lib.children['module1.js'].size, 100);
+        assert_1.default.equal(result.assetTree.children.lib.children['module2.js'].size, 200);
+    });
+    it('should handle empty assets array', function () {
+        mockBundleGraph.traverseAssets.callsFake((_bundleValue, _callback) => {
+            // No assets
+        });
+        const result = (0, buildTreemap_1.buildTreemapBundle)({
+            writeBundleRequestsByBundleId: mockWriteBundleRequestsByBundleId,
+            node: mockNode,
+            projectRoot: '/project',
+            repositoryRoot: '/project',
+            bundleGraph: mockBundleGraph,
+        });
+        assert_1.default.equal(result.assetTree.size, 0);
+        assert_1.default.deepEqual(result.assetTree.children, {});
+    });
+    it('should handle file path without extension', function () {
+        const mockAssets = [
+            {
+                filePath: 'src/config',
+                stats: { size: 25 },
+            },
+        ];
+        mockBundleGraph.traverseAssets.callsFake((_bundleValue, callback) => {
+            mockAssets.forEach(callback);
+        });
+        const result = (0, buildTreemap_1.buildTreemapBundle)({
+            writeBundleRequestsByBundleId: mockWriteBundleRequestsByBundleId,
+            node: mockNode,
+            projectRoot: '/project',
+            repositoryRoot: '/project',
+            bundleGraph: mockBundleGraph,
+        });
+        assert_1.default.equal(result.assetTree.children.src.children.config.size, 25);
+    });
+    it('should call traverseAssets with correct bundle value', function () {
+        mockBundleGraph.traverseAssets.callsFake((_bundleValue, _callback) => {
+            // Just verify it was called
+        });
+        (0, buildTreemap_1.buildTreemapBundle)({
+            writeBundleRequestsByBundleId: mockWriteBundleRequestsByBundleId,
+            node: mockNode,
+            projectRoot: '/project',
+            repositoryRoot: '/project',
+            bundleGraph: mockBundleGraph,
+        });
+        (0, assert_1.default)(mockBundleGraph.traverseAssets.calledOnce);
+        (0, assert_1.default)(mockBundleGraph.traverseAssets.calledWith(mockNode.value));
+    });
+    it('should calculate directory sizes correctly', function () {
+        // Test case matching user's example:
+        // lib/child/a.js - 10
+        // lib/other/b.js - 10
+        // lib/other/c.js - 10
+        const mockAssets = [
+            {
+                filePath: 'lib/child/a.js',
+                stats: { size: 10 },
+            },
+            {
+                filePath: 'lib/other/b.js',
+                stats: { size: 10 },
+            },
+            {
+                filePath: 'lib/other/c.js',
+                stats: { size: 10 },
+            },
+        ];
+        mockBundleGraph.traverseAssets.callsFake((bundleValue, callback) => {
+            mockAssets.forEach(callback);
+        });
+        const result = (0, buildTreemap_1.buildTreemapBundle)({
+            writeBundleRequestsByBundleId: mockWriteBundleRequestsByBundleId,
+            node: mockNode,
+            projectRoot: '/project',
+            repositoryRoot: '/project',
+            bundleGraph: mockBundleGraph,
+        });
+        // Root should contain total of all files
+        // assert.equal(result.assetTree.size, 30); // 10+10+10
+        // lib directory should contain total of all files under lib
+        assert_1.default.equal(result.assetTree.children.lib.size, 30); // 10+10+10
+        // lib/child should contain only a.js
+        assert_1.default.equal(result.assetTree.children.lib.children.child.size, 10); // 10
+        // lib/other should contain b.js + c.js
+        assert_1.default.equal(result.assetTree.children.lib.children.other.size, 20); // 10+10
+        // Individual files should have their own sizes
+        assert_1.default.equal(result.assetTree.children.lib.children.child.children['a.js'].size, 10);
+        assert_1.default.equal(result.assetTree.children.lib.children.other.children['b.js'].size, 10);
+        assert_1.default.equal(result.assetTree.children.lib.children.other.children['c.js'].size, 10);
+    });
+    it('should handle fs.statSync errors gracefully', function () {
+        // Make fs.statSync throw an error
+        fs_1.default.statSync.throws(new Error('File not found'));
+        mockBundleGraph.traverseAssets.callsFake((_bundleValue, _callback) => {
+            // No assets
+        });
+        assert_1.default.doesNotThrow(() => {
+            (0, buildTreemap_1.buildTreemapBundle)({
+                writeBundleRequestsByBundleId: mockWriteBundleRequestsByBundleId,
+                node: mockNode,
+                projectRoot: '/project',
+                repositoryRoot: '/project',
+                bundleGraph: mockBundleGraph,
+            });
+        }, Error);
+    });
+});

package/lib/backend/services/findSourceCodeUrl.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRoot = findRoot;
+exports.findRepositoryRoot = findRepositoryRoot;
+exports.findProjectRoot = findProjectRoot;
+exports.findSourceCodeURL = findSourceCodeURL;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = __importDefault(require("child_process"));
+const PROJECT_ROOT_DIRS = [
+    '.parcelrc',
+    '.atlaspackrc',
+    'yarn.lock',
+    'package-lock.json',
+    'pnpm-lock.yaml',
+];
+/**
+ * Finds a root directory that contains a marker directory.
+ *
+ * @param target - The target directory to search from.
+ * @param candidate - The marker directory to search for.
+ */
+function findRoot(target, candidate) {
+    let projectRoot = path_1.default.resolve(process.cwd(), target);
+    let exists = false;
+    while (projectRoot !== '/' && projectRoot !== '.') {
+        if (fs_1.default.existsSync(path_1.default.join(projectRoot, candidate))) {
+            exists = true;
+            break;
+        }
+        projectRoot = path_1.default.dirname(projectRoot);
+    }
+    if (!exists) {
+        return null;
+    }
+    return projectRoot;
+}
+/**
+ * Finds a root directory that contains a `.git` directory.
+ * This is not quite matching `@atlaspack/core`'s logic.
+ *
+ * @param target - The target directory to search from.
+ */
+function findRepositoryRoot(target) {
+    return findRoot(target, '.git');
+}
+/**
+ * Finds a root directory that contains a project root directory.
+ *
+ * @param target - The target directory to search from.
+ */
+function findProjectRoot(target) {
+    for (const candidate of PROJECT_ROOT_DIRS) {
+        const root = findRoot(target, candidate);
+        if (root) {
+            return root;
+        }
+    }
+    return null;
+}
+/**
+ * Based on the directory path, find a source code URL for this project.
+ *
+ * This is based on parsing `git remote` URLs.
+ *
+ * Both SSH and HTTP URLs should be supported for both GitHub and BitBucket
+ * Cloud.
+ *
+ * If a repository has multiple remotes, the first GitHub/BitBucket remote
+ * will be used.
+ *
+ * This might not work for repositories using BitBucket Server, or mirror
+ * URLs as remotes.
+ */
+function findSourceCodeURL(target) {
+    const repositoryRoot = findRepositoryRoot(target);
+    const projectRoot = findProjectRoot(target);
+    if (!repositoryRoot || !projectRoot) {
+        return null;
+    }
+    const remotes = child_process_1.default
+        .execSync('git remote -v', {
+        cwd: repositoryRoot,
+    })
+        .toString()
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => line.split('\t'))
+        .map(([name, url]) => ({ name, url }));
+    const remote = remotes.find(({ url }) => url.includes('bitbucket.org') || url.includes('github.com'))?.url;
+    if (!remote) {
+        return null;
+    }
+    const remoteUrl = remote.split(' ')[0];
+    const type = remoteUrl.includes('bitbucket.org') ? 'bitbucket' : 'github';
+    // get owner and repo from HTTP or SSH urls
+    const regex = /^(?:https?:\/\/|git@)(github|bitbucket)\.(com|org)[:/]([^/\s.]+)\/([^/\s.]+)(\.git)?/;
+    const match = remoteUrl.match(regex);
+    if (!match) {
+        return null;
+    }
+    const [, , , owner, repo] = match;
+    return { type, owner, repo };
+}

package/lib/backend/services/findSourceCodeUrl.test.js

@@ -0,0 +1,216 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const sinon = __importStar(require("sinon"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = __importDefault(require("child_process"));
+const findSourceCodeUrl_1 = require("./findSourceCodeUrl");
+describe('findSourceCodeUrl', function () {
+    let sandbox;
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+    });
+    afterEach(() => {
+        sandbox.restore();
+    });
+    describe('findProjectRoot', function () {
+        it('should find project root when .git directory exists', function () {
+            const mockTarget = '/path/to/project/subdir';
+            const mockResolvedPath = '/resolved/path/to/project/subdir';
+            const mockProjectRoot = '/resolved/path/to/project';
+            sandbox.stub(path_1.default, 'resolve').returns(mockResolvedPath);
+            sandbox.stub(path_1.default, 'dirname').returns(mockProjectRoot);
+            sandbox.stub(path_1.default, 'join').returns('/resolved/path/to/project/.git');
+            sandbox.stub(fs_1.default, 'existsSync').returns(true);
+            const result = (0, findSourceCodeUrl_1.findProjectRoot)(mockTarget);
+            assert_1.default.equal(result, mockResolvedPath);
+            (0, assert_1.default)(path_1.default.resolve.calledWith(process.cwd(), mockTarget));
+            (0, assert_1.default)(fs_1.default.existsSync.calledWith('/resolved/path/to/project/.git'));
+        });
+        it('should return null when no .git directory is found', function () {
+            const mockTarget = '/path/to/project';
+            const mockResolvedPath = '/resolved/path/to/project';
+            sandbox.stub(path_1.default, 'resolve').returns(mockResolvedPath);
+            sandbox.stub(path_1.default, 'dirname').callsFake((p) => {
+                if (p === mockResolvedPath)
+                    return '/resolved/path/to';
+                if (p === '/resolved/path/to')
+                    return '/resolved/path';
+                if (p === '/resolved/path')
+                    return '/resolved';
+                if (p === '/resolved')
+                    return '/';
+                return '/';
+            });
+            sandbox
+                .stub(path_1.default, 'join')
+                .callsFake((p1, p2) => `${p1}/${p2}`);
+            sandbox.stub(fs_1.default, 'existsSync').returns(false);
+            const result = (0, findSourceCodeUrl_1.findProjectRoot)(mockTarget);
+            assert_1.default.equal(result, null);
+        });
+        it('should traverse up directories until finding .git', function () {
+            const mockTarget = '/path/to/project/deep/subdir';
+            const mockResolvedPath = '/resolved/path/to/project/deep/subdir';
+            sandbox.stub(path_1.default, 'resolve').returns(mockResolvedPath);
+            sandbox.stub(path_1.default, 'dirname').callsFake((p) => {
+                if (p === mockResolvedPath)
+                    return '/resolved/path/to/project/deep';
+                if (p === '/resolved/path/to/project/deep')
+                    return '/resolved/path/to/project';
+                if (p === '/resolved/path/to/project')
+                    return '/resolved/path/to';
+                return '/';
+            });
+            sandbox
+                .stub(path_1.default, 'join')
+                .callsFake((p1, _p2) => `${p1}/.git`);
+            const existsStub = sandbox.stub(fs_1.default, 'existsSync');
+            existsStub
+                .withArgs('/resolved/path/to/project/deep/subdir/.git')
+                .returns(false);
+            existsStub.withArgs('/resolved/path/to/project/deep/.git').returns(false);
+            existsStub.withArgs('/resolved/path/to/project/.git').returns(true);
+            const result = (0, findSourceCodeUrl_1.findProjectRoot)(mockTarget);
+            assert_1.default.equal(result, '/resolved/path/to/project');
+        });
+    });
+    describe('findSourceCodeURL', function () {
+        it('should return null when no project root is found', function () {
+            const mockTarget = '/path/to/project';
+            sandbox.stub(path_1.default, 'resolve').returns('/resolved/path');
+            sandbox.stub(path_1.default, 'dirname').returns('/');
+            sandbox.stub(path_1.default, 'join').returns('/.git');
+            sandbox.stub(fs_1.default, 'existsSync').returns(false);
+            const result = (0, findSourceCodeUrl_1.findSourceCodeURL)(mockTarget);
+            assert_1.default.equal(result, null);
+        });
+        it('should parse GitHub SSH URL correctly', function () {
+            const mockTarget = '/path/to/project';
+            sandbox.stub(path_1.default, 'resolve').returns('/resolved/path');
+            sandbox.stub(path_1.default, 'dirname').returns('/');
+            sandbox.stub(path_1.default, 'join').returns('/resolved/path/.git');
+            sandbox.stub(fs_1.default, 'existsSync').returns(true);
+            const mockGitOutput = 'origin\tgit@github.com:owner/repo.git (fetch)\norigin\tgit@github.com:owner/repo.git (push)';
+            sandbox
+                .stub(child_process_1.default, 'execSync')
+                .returns(Buffer.from(mockGitOutput));
+            const result = (0, findSourceCodeUrl_1.findSourceCodeURL)(mockTarget);
+            assert_1.default.deepEqual(result, {
+                type: 'github',
+                owner: 'owner',
+                repo: 'repo',
+            });
+        });
+        it('should parse GitHub HTTPS URL correctly', function () {
+            const mockTarget = '/path/to/project';
+            sandbox.stub(path_1.default, 'resolve').returns('/resolved/path');
+            sandbox.stub(path_1.default, 'dirname').returns('/');
+            sandbox.stub(path_1.default, 'join').returns('/resolved/path/.git');
+            sandbox.stub(fs_1.default, 'existsSync').returns(true);
+            const mockGitOutput = 'origin\thttps://github.com/owner/repo.git (fetch)';
+            sandbox
+                .stub(child_process_1.default, 'execSync')
+                .returns(Buffer.from(mockGitOutput));
+            const result = (0, findSourceCodeUrl_1.findSourceCodeURL)(mockTarget);
+            assert_1.default.deepEqual(result, {
+                type: 'github',
+                owner: 'owner',
+                repo: 'repo',
+            });
+        });
+        it('should parse Bitbucket SSH URL correctly', function () {
+            const mockTarget = '/path/to/project';
+            sandbox.stub(path_1.default, 'resolve').returns('/resolved/path');
+            sandbox.stub(path_1.default, 'dirname').returns('/');
+            sandbox.stub(path_1.default, 'join').returns('/resolved/path/.git');
+            sandbox.stub(fs_1.default, 'existsSync').returns(true);
+            const mockGitOutput = 'origin\tgit@bitbucket.org:owner/repo.git (fetch)';
+            sandbox
+                .stub(child_process_1.default, 'execSync')
+                .returns(Buffer.from(mockGitOutput));
+            const result = (0, findSourceCodeUrl_1.findSourceCodeURL)(mockTarget);
+            assert_1.default.deepEqual(result, {
+                type: 'bitbucket',
+                owner: 'owner',
+                repo: 'repo',
+            });
+        });
+        it('should return null when no valid remote is found', function () {
+            const mockTarget = '/path/to/project';
+            sandbox.stub(path_1.default, 'resolve').returns('/resolved/path');
+            sandbox.stub(path_1.default, 'dirname').returns('/');
+            sandbox.stub(path_1.default, 'join').returns('/resolved/path/.git');
+            sandbox.stub(fs_1.default, 'existsSync').returns(true);
+            const mockGitOutput = 'origin\tgit@example.com:owner/repo.git (fetch)';
+            sandbox
+                .stub(child_process_1.default, 'execSync')
+                .returns(Buffer.from(mockGitOutput));
+            const result = (0, findSourceCodeUrl_1.findSourceCodeURL)(mockTarget);
+            assert_1.default.equal(result, null);
+        });
+        it('should return null when git command fails', function () {
+            const mockTarget = '/path/to/project';
+            sandbox.stub(path_1.default, 'resolve').returns('/resolved/path');
+            sandbox.stub(path_1.default, 'dirname').returns('/');
+            sandbox.stub(path_1.default, 'join').returns('/resolved/path/.git');
+            sandbox.stub(fs_1.default, 'existsSync').returns(true);
+            sandbox
+                .stub(child_process_1.default, 'execSync')
+                .throws(new Error('Git command failed'));
+            assert_1.default.throws(() => {
+                (0, findSourceCodeUrl_1.findSourceCodeURL)(mockTarget);
+            }, Error);
+        });
+        it('should return null when URL format is invalid', function () {
+            const mockTarget = '/path/to/project';
+            sandbox.stub(path_1.default, 'resolve').returns('/resolved/path');
+            sandbox.stub(path_1.default, 'dirname').returns('/');
+            sandbox.stub(path_1.default, 'join').returns('/resolved/path/.git');
+            sandbox.stub(fs_1.default, 'existsSync').returns(true);
+            const mockGitOutput = 'origin\tinvalid-url-format (fetch)';
+            sandbox
+                .stub(child_process_1.default, 'execSync')
+                .returns(Buffer.from(mockGitOutput));
+            const result = (0, findSourceCodeUrl_1.findSourceCodeURL)(mockTarget);
+            assert_1.default.equal(result, null);
+        });
+    });
+});

package/lib/backend/services/getCacheStats.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCacheStats = getCacheStats;
+/**
+ * Aggregate data based on general cache usage, by reading all entries
+ * in the cache.
+ *
+ * This can take a non-neglible amount of time on large caches, but
+ * will still be a lot faster than the graph deserialization steps.
+ */
+function getCacheStats(cache) {
+    const stats = {
+        size: 0,
+        count: 0,
+        keySize: 0,
+        assetContentCount: 0,
+        assetContentSize: 0,
+        assetMapCount: 0,
+        assetMapSize: 0,
+    };
+    for (const key of cache.keys()) {
+        const value = cache.getBlobSync(key);
+        stats.size += value.length;
+        stats.keySize += Buffer.from(key).length;
+        stats.count++;
+        if (key.endsWith(':content')) {
+            stats.assetContentCount++;
+            stats.assetContentSize += value.length;
+        }
+        else if (key.endsWith(':map')) {
+            stats.assetMapCount++;
+            stats.assetMapSize += value.length;
+        }
+    }
+    return stats;
+}