@taskforcehq/taskforce 0.3.311 → 0.3.313

package/scripts/qa-open-lib.mjs

@@ -1,175 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-export const QA_MODES = ['local', 'performance', 'staging'];
-
-export const QA_CLOUD_BASE_URLS = {
-    performance: 'https://performance-app.taskforcehq.ai',
-    staging: 'https://staging-app.taskforcehq.ai'
-};
-
-function normalizePort(raw) {
-    const value = String(raw || '').trim();
-    if (!value) return null;
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isInteger(parsed) || parsed <= 0) {
-        return null;
-    }
-    return parsed;
-}
-
-function stripQuotes(raw) {
-    const value = String(raw || '').trim();
-    if (
-        (value.startsWith('"') && value.endsWith('"'))
-        || (value.startsWith("'") && value.endsWith("'"))
-    ) {
-        return value.slice(1, -1);
-    }
-    return value;
-}
-
-export function normalizeQaMode(raw) {
-    const normalized = String(raw || '').trim().toLowerCase();
-    return QA_MODES.includes(normalized) ? normalized : null;
-}
-
-export function sanitizeQaAgentId(raw) {
-    const normalized = String(raw || '')
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9_-]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .replace(/-{2,}/g, '-');
-    return normalized || null;
-}
-
-export function parseQaArgs(argv, env = process.env) {
-    const positional = (argv || []).filter((arg) => !String(arg || '').startsWith('--'));
-    const mode = normalizeQaMode(positional[0] || env.TASKFORCE_QA_MODE || 'local');
-    const preferredPort = normalizePort(positional[1] || env.TASKFORCE_QA_PORT);
-    const agentId = sanitizeQaAgentId(env.TASKFORCE_QA_AGENT);
-    return { mode, agentId, preferredPort };
-}
-
-export function resolveQaPaths({ agentId, homeDir = os.homedir() }) {
-    const safeAgentId = sanitizeQaAgentId(agentId);
-    if (!safeAgentId) {
-        throw new Error('TASKFORCE_QA_AGENT is required and must contain at least one safe path character.');
-    }
-    const root = path.resolve(homeDir, '.taskforce', 'qa', safeAgentId);
-    return {
-        agentId: safeAgentId,
-        root,
-        projectRoot: path.join(root, 'project'),
-        envFile: path.join(root, 'env'),
-        logsDir: path.join(root, 'logs'),
-        artifactsDir: path.join(root, 'artifacts'),
-        homeDir: path.join(root, 'home'),
-        playwrightStorageState: path.join(root, 'playwright-auth.json')
-    };
-}
-
-export function isPathInside(parentPath, childPath) {
-    const parent = path.resolve(parentPath);
-    const child = path.resolve(childPath);
-    const relative = path.relative(parent, child);
-    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
-}
-
-export function assertQaProjectRootSafe(projectRoot, repoRoot) {
-    if (isPathInside(repoRoot, projectRoot)) {
-        throw new Error(
-            `Refusing to use QA project root inside the repository: ${projectRoot}\n`
-            + `Move the QA root outside ${repoRoot}.`
-        );
-    }
-}
-
-export function parseEnvFileContents(raw) {
-    const env = {};
-    const lines = String(raw || '').split(/\r?\n/);
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#')) continue;
-        const normalized = trimmed.startsWith('export ') ? trimmed.slice(7).trim() : trimmed;
-        const separatorIndex = normalized.indexOf('=');
-        if (separatorIndex <= 0) continue;
-        const key = normalized.slice(0, separatorIndex).trim();
-        if (!key) continue;
-        const value = normalized.slice(separatorIndex + 1);
-        env[key] = stripQuotes(value);
-    }
-    return env;
-}
-
-export function loadEnvFile(filePath) {
-    const raw = fs.readFileSync(filePath, 'utf8');
-    return parseEnvFileContents(raw);
-}
-
-export function ensureQaRootStructure(paths, options = {}) {
-    const projectName = String(options.projectName || `taskforce-qa-${paths.agentId}`).trim();
-    fs.mkdirSync(paths.root, { recursive: true });
-    fs.mkdirSync(paths.projectRoot, { recursive: true });
-    fs.mkdirSync(paths.logsDir, { recursive: true });
-    fs.mkdirSync(paths.artifactsDir, { recursive: true });
-    fs.mkdirSync(paths.homeDir, { recursive: true });
-
-    const packageJsonPath = path.join(paths.projectRoot, 'package.json');
-    if (!fs.existsSync(packageJsonPath)) {
-        fs.writeFileSync(packageJsonPath, JSON.stringify({ name: projectName }, null, 2) + '\n', 'utf8');
-    }
-    return packageJsonPath;
-}
-
-export function resolveExpectedWorkspace(env) {
-    const workspaceId = String(env.TASKFORCE_QA_EXPECTED_WORKSPACE_ID || '').trim();
-    const workspaceSlug = String(env.TASKFORCE_QA_EXPECTED_WORKSPACE_SLUG || '').trim();
-    if (!workspaceId && !workspaceSlug) return null;
-    return {
-        workspaceId: workspaceId || null,
-        workspaceSlug: workspaceSlug || null
-    };
-}
-
-export function matchExpectedWorkspace(result, expected) {
-    const nestedWorkspaces = Array.isArray(result?.workspaces?.workspaces) ? result.workspaces.workspaces : [];
-    const workspaces = Array.isArray(result?.workspaces) ? result.workspaces : nestedWorkspaces;
-    const currentWorkspaceId = String(result?.currentWorkspaceId || '').trim();
-    if (!expected) {
-        return {
-            ok: true,
-            matchedWorkspaceId: currentWorkspaceId || null,
-            reason: 'No expected workspace configured.'
-        };
-    }
-
-    if (expected.workspaceId) {
-        return {
-            ok: currentWorkspaceId === expected.workspaceId,
-            matchedWorkspaceId: currentWorkspaceId || null,
-            reason: currentWorkspaceId === expected.workspaceId
-                ? 'Matched expected workspace id.'
-                : `Expected workspace id ${expected.workspaceId} but current workspace id was ${currentWorkspaceId || '(empty)'}.`
-        };
-    }
-
-    const matchedBySlug = workspaces.find((workspace) => String(workspace?.slug || '').trim() === expected.workspaceSlug);
-    if (!matchedBySlug) {
-        return {
-            ok: false,
-            matchedWorkspaceId: currentWorkspaceId || null,
-            reason: `Expected workspace slug ${expected.workspaceSlug} was not present in the available workspaces list.`
-        };
-    }
-
-    return {
-        ok: currentWorkspaceId === String(matchedBySlug.id || '').trim(),
-        matchedWorkspaceId: currentWorkspaceId || null,
-        reason: currentWorkspaceId === String(matchedBySlug.id || '').trim()
-            ? 'Matched expected workspace slug.'
-            : `Expected workspace slug ${expected.workspaceSlug} to resolve to workspace id ${String(matchedBySlug.id || '').trim()}, but current workspace id was ${currentWorkspaceId || '(empty)'}.`
-    };
-}

package/scripts/qa-open-lib.mjs.d.ts

@@ -1,49 +0,0 @@
-export const QA_MODES: string[];
-export const QA_CLOUD_BASE_URLS: Record<string, string>;
-
-export function normalizeQaMode(raw: unknown): string | null;
-export function sanitizeQaAgentId(raw: unknown): string | null;
-export function parseQaArgs(
-    argv?: string[],
-    env?: Record<string, string | undefined>
-): { mode: string | null; agentId: string | null; preferredPort: number | null };
-export function resolveQaPaths(input: {
-    agentId: string;
-    homeDir?: string;
-}): {
-    agentId: string;
-    root: string;
-    projectRoot: string;
-    envFile: string;
-    logsDir: string;
-    artifactsDir: string;
-    homeDir: string;
-    playwrightStorageState: string;
-};
-export function isPathInside(parentPath: string, childPath: string): boolean;
-export function assertQaProjectRootSafe(projectRoot: string, repoRoot: string): void;
-export function parseEnvFileContents(raw: unknown): Record<string, string>;
-export function loadEnvFile(filePath: string): Record<string, string>;
-export function ensureQaRootStructure(
-    paths: {
-        agentId: string;
-        root: string;
-        projectRoot: string;
-        logsDir: string;
-        artifactsDir: string;
-        homeDir: string;
-    },
-    options?: { projectName?: string }
-): string;
-export function resolveExpectedWorkspace(env: Record<string, string | undefined>): {
-    workspaceId: string | null;
-    workspaceSlug: string | null;
-} | null;
-export function matchExpectedWorkspace(
-    result: unknown,
-    expected: { workspaceId: string | null; workspaceSlug: string | null } | null
-): {
-    ok: boolean;
-    matchedWorkspaceId: string | null;
-    reason: string;
-};

package/scripts/qa-open.mjs

@@ -1,352 +0,0 @@
-#!/usr/bin/env node
-import { chromium } from '@playwright/test';
-import { spawn } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import {
-    QA_CLOUD_BASE_URLS,
-    assertQaProjectRootSafe,
-    ensureQaRootStructure,
-    loadEnvFile,
-    matchExpectedWorkspace,
-    parseQaArgs,
-    resolveExpectedWorkspace,
-    resolveQaPaths
-} from './qa-open-lib.mjs';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const REPO_ROOT = path.resolve(__dirname, '..');
-const CLI_PATH = path.resolve(REPO_ROOT, 'src/cli.ts');
-const TSX_LOADER_PATH = path.resolve(REPO_ROOT, 'node_modules/tsx/dist/loader.mjs');
-const UI_INDEX_PATH = path.resolve(REPO_ROOT, 'dist/ui/index.html');
-
-function fail(message) {
-    throw new Error(message);
-}
-
-function createLogWriter(logFilePath, prefix) {
-    const stream = fs.createWriteStream(logFilePath, { flags: 'a' });
-    return (chunk) => {
-        const text = String(chunk || '');
-        process.stdout.write(`${prefix}${text}`);
-        stream.write(text);
-    };
-}
-
-function createErrorLogWriter(logFilePath, prefix) {
-    const stream = fs.createWriteStream(logFilePath, { flags: 'a' });
-    return (chunk) => {
-        const text = String(chunk || '');
-        process.stderr.write(`${prefix}${text}`);
-        stream.write(text);
-    };
-}
-
-function spawnLogged(command, args, options) {
-    const child = spawn(command, args, {
-        cwd: options.cwd,
-        env: options.env,
-        stdio: ['ignore', 'pipe', 'pipe']
-    });
-    const stdoutWriter = createLogWriter(options.stdoutLogPath, options.stdoutPrefix);
-    const stderrWriter = createErrorLogWriter(options.stderrLogPath, options.stderrPrefix);
-    child.stdout?.on('data', stdoutWriter);
-    child.stderr?.on('data', stderrWriter);
-    return child;
-}
-
-function isTruthyEnv(raw) {
-    return /^(1|true|yes)$/i.test(String(raw || '').trim());
-}
-
-function stripRuntimeOnlyEnv(baseEnv) {
-    const env = { ...baseEnv };
-    for (const key of Object.keys(env)) {
-        if (key.startsWith('TASKFORCE_QA_')) {
-            delete env[key];
-            continue;
-        }
-        if (key.startsWith('TASKFORCE_PLAYWRIGHT_')) {
-            delete env[key];
-            continue;
-        }
-        if (key === 'TASKFORCE_E2E_EMAIL' || key === 'TASKFORCE_E2E_PASSWORD') {
-            delete env[key];
-        }
-    }
-    return env;
-}
-
-function waitForChildExit(child, label) {
-    return new Promise((resolve, reject) => {
-        child.once('exit', (code, signal) => resolve({ label, code, signal }));
-        child.once('error', (error) => {
-            const message = error instanceof Error ? error.message : String(error);
-            reject(new Error(`${label} failed to start: ${message}`));
-        });
-    });
-}
-
-async function waitForFreshUiBuild(child, startTimeMs, timeoutMs = 120000) {
-    const startedAt = Date.now();
-    return await new Promise((resolve, reject) => {
-        let settled = false;
-        const onExit = (code, signal) => {
-            if (settled) return;
-            settled = true;
-            reject(new Error(`UI watch process exited before initial build completed (code=${code ?? 'null'} signal=${signal ?? 'null'}).`));
-        };
-        child.once('exit', onExit);
-
-        const interval = setInterval(() => {
-            try {
-                const stat = fs.statSync(UI_INDEX_PATH);
-                if (stat.mtimeMs >= startTimeMs) {
-                    settled = true;
-                    clearInterval(interval);
-                    child.off('exit', onExit);
-                    resolve();
-                    return;
-                }
-            } catch {
-                // keep polling until timeout
-            }
-            if (Date.now() - startedAt > timeoutMs) {
-                settled = true;
-                clearInterval(interval);
-                child.off('exit', onExit);
-                reject(new Error(`Timed out waiting for a fresh standalone UI build at ${UI_INDEX_PATH}.`));
-            }
-        }, 500);
-    });
-}
-
-async function runPlaywrightAuth(env) {
-    await new Promise((resolve, reject) => {
-        const child = spawn('npm', ['run', 'playwright:auth'], {
-            cwd: REPO_ROOT,
-            env,
-            stdio: 'inherit'
-        });
-        child.once('exit', (code, signal) => {
-            if (code === 0) {
-                resolve();
-                return;
-            }
-            reject(new Error(`Playwright auth bootstrap failed (code=${code ?? 'null'} signal=${signal ?? 'null'}).`));
-        });
-        child.once('error', reject);
-    });
-}
-
-async function verifyCloudWorkspace(baseUrl, storageStatePath, expectedWorkspace) {
-    const browser = await chromium.launch({ headless: true });
-    try {
-        const context = await browser.newContext({ storageState: storageStatePath });
-        const page = await context.newPage();
-        await page.goto(`${baseUrl}/taskforce/`, { waitUntil: 'domcontentloaded', timeout: 60000 });
-        const payload = await page.evaluate(async () => {
-            const sessionResponse = await fetch('/api/taskforce/auth/session', {
-                method: 'GET',
-                credentials: 'include',
-                headers: { Accept: 'application/json' }
-            });
-            const workspacesResponse = await fetch('/api/taskforce/workspaces', {
-                method: 'GET',
-                credentials: 'include',
-                headers: { Accept: 'application/json' }
-            });
-            return {
-                session: await sessionResponse.json(),
-                workspaces: await workspacesResponse.json()
-            };
-        });
-        await context.close();
-        const authenticated = Boolean(payload?.session?.authenticated);
-        if (!authenticated) {
-            fail(`Authentication succeeded earlier, but the saved storage state at ${storageStatePath} is not currently authenticated.`);
-        }
-        const match = matchExpectedWorkspace(payload?.workspaces, expectedWorkspace);
-        if (!match.ok) {
-            fail(
-                `${match.reason}\n`
-                + 'Check the expected workspace env vars and make sure the account is a member of the intended workspace.'
-            );
-        }
-    } finally {
-        await browser.close();
-    }
-}
-
-function buildRuntimeEnv(baseEnv, paths) {
-    const isolateHome = isTruthyEnv(baseEnv.TASKFORCE_QA_ISOLATE_HOME);
-    const env = stripRuntimeOnlyEnv(baseEnv);
-    if (isolateHome) {
-        env.HOME = paths.homeDir;
-        env.USERPROFILE = paths.homeDir;
-    }
-    return env;
-}
-
-async function main() {
-    const { mode, agentId, preferredPort } = parseQaArgs(process.argv.slice(2), process.env);
-    if (!mode) {
-        fail('Invalid or missing QA mode. Use one of: local, performance, staging.');
-    }
-    if (!agentId) {
-        fail('TASKFORCE_QA_AGENT is required. Example: TASKFORCE_QA_AGENT=codex npm run qa:open -- performance');
-    }
-
-    const paths = resolveQaPaths({ agentId });
-    assertQaProjectRootSafe(paths.projectRoot, REPO_ROOT);
-
-    const cloudMode = mode !== 'local';
-    const envFileExists = fs.existsSync(paths.envFile);
-    let envFileVars = {};
-    if (envFileExists) {
-        envFileVars = loadEnvFile(paths.envFile);
-    } else if (cloudMode) {
-        fail(
-            `Missing QA env file for agent ${agentId}: ${paths.envFile}\n`
-            + 'Create the file with TASKFORCE_E2E_EMAIL, TASKFORCE_E2E_PASSWORD, and the expected workspace id or slug.'
-        );
-    }
-
-    const projectName = String(envFileVars.TASKFORCE_QA_PROJECT_NAME || `taskforce-qa-${paths.agentId}`).trim();
-    ensureQaRootStructure(paths, { projectName });
-
-    const qaEnv = {
-        ...process.env,
-        ...envFileVars,
-        TASKFORCE_PLAYWRIGHT_ENV_FILE: paths.envFile,
-        TASKFORCE_PLAYWRIGHT_STORAGE_STATE: paths.playwrightStorageState
-    };
-    const expectedWorkspace = resolveExpectedWorkspace(qaEnv);
-    if (cloudMode && !expectedWorkspace) {
-        fail(
-            `Cloud QA for ${mode} requires TASKFORCE_QA_EXPECTED_WORKSPACE_ID or TASKFORCE_QA_EXPECTED_WORKSPACE_SLUG in ${paths.envFile}.`
-        );
-    }
-    const runtimeEnv = buildRuntimeEnv(qaEnv, paths);
-
-    console.log(`[qa:open] Agent: ${paths.agentId}`);
-    console.log(`[qa:open] Mode: ${mode}`);
-    console.log(`[qa:open] QA root: ${paths.root}`);
-    console.log(`[qa:open] External project root: ${paths.projectRoot}`);
-    console.log(`[qa:open] Artifact dir: ${paths.artifactsDir}`);
-    if (preferredPort) {
-        console.log(`[qa:open] Preferred port: ${preferredPort}`);
-    }
-    if (isTruthyEnv(qaEnv.TASKFORCE_QA_ISOLATE_HOME)) {
-        console.log(`[qa:open] HOME isolation enabled: ${paths.homeDir}`);
-    }
-
-    if (cloudMode) {
-        await runPlaywrightAuth({
-            ...qaEnv,
-            TASKFORCE_PLAYWRIGHT_CLOUD_BASE_URL: String(
-                qaEnv.TASKFORCE_PLAYWRIGHT_CLOUD_BASE_URL || QA_CLOUD_BASE_URLS[mode]
-            )
-        });
-        await verifyCloudWorkspace(
-            String(qaEnv.TASKFORCE_PLAYWRIGHT_CLOUD_BASE_URL || QA_CLOUD_BASE_URLS[mode]),
-            paths.playwrightStorageState,
-            expectedWorkspace
-        );
-        console.log('[qa:open] Cloud auth and workspace verification passed.');
-    }
-
-    const devAppStartedAt = Date.now();
-    const devApp = spawnLogged('npm', ['run', 'dev:app'], {
-        cwd: REPO_ROOT,
-        env: runtimeEnv,
-        stdoutLogPath: path.join(paths.logsDir, 'dev-app.stdout.log'),
-        stderrLogPath: path.join(paths.logsDir, 'dev-app.stderr.log'),
-        stdoutPrefix: '[qa:open:dev-app] ',
-        stderrPrefix: '[qa:open:dev-app] '
-    });
-    let runtime;
-    let cleanupSignalHandlers = () => {};
-    let shutdownStarted = false;
-    let shutdownTimer = null;
-
-    const shutdown = () => {
-        if (shutdownStarted) return;
-        shutdownStarted = true;
-        for (const child of [runtime, devApp]) {
-            if (child?.exitCode == null && child?.signalCode == null) {
-                child.kill('SIGTERM');
-            }
-        }
-        shutdownTimer = setTimeout(() => {
-            for (const child of [runtime, devApp]) {
-                if (child?.exitCode == null && child?.signalCode == null) {
-                    child.kill('SIGKILL');
-                }
-            }
-        }, 5000);
-        shutdownTimer.unref?.();
-    };
-
-    try {
-        await waitForFreshUiBuild(devApp, devAppStartedAt);
-        console.log('[qa:open] Standalone UI build is ready.');
-
-        const runtimeArgs = ['--import', TSX_LOADER_PATH, CLI_PATH, 'open'];
-        if (mode !== 'local') runtimeArgs.push(mode);
-        if (preferredPort) runtimeArgs.push(String(preferredPort));
-        runtime = spawnLogged(process.execPath, runtimeArgs, {
-            cwd: paths.projectRoot,
-            env: runtimeEnv,
-            stdoutLogPath: path.join(paths.logsDir, 'runtime.stdout.log'),
-            stderrLogPath: path.join(paths.logsDir, 'runtime.stderr.log'),
-            stdoutPrefix: '[qa:open:runtime] ',
-            stderrPrefix: '[qa:open:runtime] '
-        });
-
-        const devAppExit = waitForChildExit(devApp, 'UI watch process');
-        const runtimeExit = waitForChildExit(runtime, 'Runtime process');
-        const signalResult = await new Promise((resolve) => {
-            const onSignal = (signal) => {
-                shutdown();
-                resolve({ type: 'signal', signal });
-            };
-            process.once('SIGINT', onSignal);
-            process.once('SIGTERM', onSignal);
-            cleanupSignalHandlers = () => {
-                process.off('SIGINT', onSignal);
-                process.off('SIGTERM', onSignal);
-            };
-            Promise.race([
-                devAppExit.then((event) => ({ type: 'child', event })),
-                runtimeExit.then((event) => ({ type: 'child', event }))
-            ]).then(resolve, (error) => resolve({ type: 'error', error }));
-        });
-
-        cleanupSignalHandlers();
-        shutdown();
-        await Promise.allSettled([devAppExit, runtimeExit]);
-
-        if (signalResult.type === 'signal') {
-            return;
-        }
-        if (signalResult.type === 'error') {
-            throw signalResult.error;
-        }
-        const { label, code, signal } = signalResult.event;
-        throw new Error(`${label} exited unexpectedly (code=${code ?? 'null'} signal=${signal ?? 'null'}).`);
-    } finally {
-        cleanupSignalHandlers();
-        shutdown();
-        if (shutdownTimer) {
-            clearTimeout(shutdownTimer);
-        }
-    }
-}
-
-main().catch((error) => {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exitCode = 1;
-});

package/scripts/release-version-lib.mjs

@@ -1,88 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-export function parseVersionTriplet(version) {
-    const raw = String(version || '').trim();
-    const match = raw.match(/^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
-    if (!match) return null;
-    return {
-        major: Number(match[1]),
-        minor: Number(match[2]),
-        patch: Number(match[3])
-    };
-}
-
-export function parseReleaseTag(tag) {
-    const raw = String(tag || '').trim();
-    const match = raw.match(/^v(\d+)\.(\d+)\.(\d+)$/);
-    if (!match) return null;
-    return {
-        major: Number(match[1]),
-        minor: Number(match[2]),
-        patch: Number(match[3])
-    };
-}
-
-export function readVersionConfig(projectRoot) {
-    const configPath = path.resolve(projectRoot, 'version.config.json');
-    const raw = fs.readFileSync(configPath, 'utf8');
-    const parsed = JSON.parse(raw);
-    const major = Number(parsed?.major);
-    const minor = Number(parsed?.minor);
-    if (!Number.isInteger(major) || major < 0) {
-        throw new Error(`version.config.json major must be a non-negative integer (got: ${parsed?.major})`);
-    }
-    if (!Number.isInteger(minor) || minor < 0) {
-        throw new Error(`version.config.json minor must be a non-negative integer (got: ${parsed?.minor})`);
-    }
-    return {
-        major,
-        minor,
-        path: configPath
-    };
-}
-
-export function readPackageVersion(projectRoot) {
-    const packagePath = path.resolve(projectRoot, 'package.json');
-    const raw = fs.readFileSync(packagePath, 'utf8');
-    const parsed = JSON.parse(raw);
-    return String(parsed?.version || '').trim();
-}
-
-export function computeNextPatch({
-    major,
-    minor,
-    releaseTags,
-    currentPackageVersion
-}) {
-    const patches = (releaseTags || [])
-        .map(parseReleaseTag)
-        .filter(tag => tag && tag.major === major && tag.minor === minor)
-        .map(tag => tag.patch);
-
-    if (patches.length > 0) {
-        return Math.max(...patches) + 1;
-    }
-
-    const packageParsed = parseVersionTriplet(currentPackageVersion);
-    if (packageParsed && packageParsed.major === major && packageParsed.minor === minor) {
-        return packageParsed.patch + 1;
-    }
-
-    return 0;
-}
-
-export function computeNextVersion({
-    major,
-    minor,
-    releaseTags,
-    currentPackageVersion
-}) {
-    const nextPatch = computeNextPatch({
-        major,
-        minor,
-        releaseTags,
-        currentPackageVersion
-    });
-    return `${major}.${minor}.${nextPatch}`;
-}