deepdebug-local-agent 1.0.23 → 1.2.0

package/test/incident-forwarder.test.js

@@ -0,0 +1,231 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { IncidentForwarder } from '../src/siblings/incident-forwarder.js';
+
+const NOOP_LOGGER = { info() {}, warn() {}, error() {}, debug() {} };
+// Disable burst suppression where a test intentionally sends identical events.
+const NO_SUPPRESS = { shouldSuppress: () => false };
+
+function validEvent(over = {}) {
+    return {
+        adapter: 'sap',
+        errorCode: 'DUMP',
+        file: '/logs/dev_w0',
+        message: 'ABAP runtime error',
+        source: 'sap-nw-01',
+        timestamp: '2026-07-28T10:00:00Z',
+        ...over,
+    };
+}
+
+test('forwards a valid 6-key event to the gateway', async () => {
+    const calls = [];
+    const fetchImpl = async (url, opts) => {
+        calls.push({ url, body: JSON.parse(opts.body) });
+        return { ok: true, status: 200 };
+    };
+    const fwd = new IncidentForwarder({ logger: NOOP_LOGGER, maxRetries: 0 });
+    fwd.configure({ gatewayUrl: 'https://gw.example', tenantId: 't1', apiKey: 'k', fetchImpl });
+
+    fwd.handleAdapterEvent(validEvent(), 'SapAdapter');
+    await fwd.flush();
+
+    assert.equal(fwd.stats.forwarded, 1);
+    assert.equal(fwd.stats.failed, 0);
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].url, 'https://gw.example/api/v1/internal/incident/create');
+    assert.equal(calls[0].body.service, 'sap-nw-01');
+    assert.equal(calls[0].body.detectedBy, 'local-agent-adapter');
+});
+
+test('rejects a malformed event (missing key) without forwarding', async () => {
+    let fetched = false;
+    const fetchImpl = async () => { fetched = true; return { ok: true, status: 200 }; };
+    const fwd = new IncidentForwarder({ logger: NOOP_LOGGER, maxRetries: 0 });
+    fwd.configure({ gatewayUrl: 'https://gw.example', fetchImpl });
+
+    const bad = validEvent();
+    delete bad.source; // drop a required key
+    const outcome = fwd.handleAdapterEvent(bad, 'SapAdapter');
+    await fwd.flush();
+
+    assert.equal(outcome, 'malformed');
+    assert.equal(fetched, false);
+    assert.equal(fwd.stats.malformed, 1);
+    assert.equal(fwd.stats.forwarded, 0);
+});
+
+test('empty message is treated as malformed', async () => {
+    const fwd = new IncidentForwarder({ logger: NOOP_LOGGER, maxRetries: 0 });
+    fwd.configure({ gatewayUrl: 'https://gw.example', fetchImpl: async () => ({ ok: true, status: 200 }) });
+    fwd.handleAdapterEvent(validEvent({ message: '   ' }), 'SapAdapter');
+    await fwd.flush();
+    assert.equal(fwd.stats.malformed, 1);
+    assert.equal(fwd.stats.forwarded, 0);
+});
+
+test('gateway unreachable is retried then counted, never thrown', async () => {
+    let attempts = 0;
+    const fetchImpl = async () => { attempts++; throw new Error('ECONNREFUSED'); };
+    const fwd = new IncidentForwarder({ logger: NOOP_LOGGER, maxRetries: 2 });
+    fwd.configure({ gatewayUrl: 'https://gw.example', fetchImpl });
+
+    assert.doesNotThrow(() => fwd.handleAdapterEvent(validEvent(), 'SapAdapter'));
+    await fwd.flush();
+
+    assert.equal(attempts, 3); // 1 + 2 retries
+    assert.equal(fwd.stats.failed, 1);
+    assert.equal(fwd.stats.forwarded, 0);
+});
+
+test('non-2xx response is a failure', async () => {
+    const fwd = new IncidentForwarder({ logger: NOOP_LOGGER, maxRetries: 0 });
+    fwd.configure({ gatewayUrl: 'https://gw.example', fetchImpl: async () => ({ ok: false, status: 503 }) });
+    fwd.handleAdapterEvent(validEvent(), 'SapAdapter');
+    await fwd.flush();
+    assert.equal(fwd.stats.failed, 1);
+    assert.equal(fwd.stats.forwarded, 0);
+});
+
+test('events received before configure() are buffered, not lost', async () => {
+    const calls = [];
+    const fetchImpl = async () => { calls.push(1); return { ok: true, status: 200 }; };
+    const fwd = new IncidentForwarder({ logger: NOOP_LOGGER, maxRetries: 0, suppressor: NO_SUPPRESS });
+
+    // Not configured yet -> should buffer.
+    fwd.handleAdapterEvent(validEvent(), 'SapAdapter');
+    fwd.handleAdapterEvent(validEvent(), 'SapAdapter');
+    assert.equal(calls.length, 0);
+    assert.equal(fwd.queue.length, 2);
+
+    fwd.configure({ gatewayUrl: 'https://gw.example', fetchImpl });
+    await fwd.flush();
+    assert.equal(fwd.stats.forwarded, 2);
+});
+
+test('contract error (401) is NOT retried and is recorded loudly', async () => {
+    let calls = 0;
+    const fetchImpl = async () => {
+        calls++;
+        return { ok: false, status: 401, text: async () => 'unauthorized' };
+    };
+    const fwd = new IncidentForwarder({ logger: NOOP_LOGGER, maxRetries: 3 });
+    fwd.configure({ gatewayUrl: 'https://gw.example', fetchImpl });
+    fwd.handleAdapterEvent(validEvent(), 'SapAdapter');
+    await fwd.flush();
+
+    assert.equal(calls, 1); // no retries on a contract error
+    assert.equal(fwd.stats.contract, 1);
+    assert.equal(fwd.stats.forwarded, 0);
+    assert.ok(fwd.contractError);
+    assert.equal(fwd.contractError.status, 401);
+    assert.equal(fwd.contractError.body, 'unauthorized');
+    assert.equal(fwd.getStatus().contract_ok, false);
+});
+
+test('403 and 404 are also contract errors (no retry)', async () => {
+    for (const status of [403, 404]) {
+        let calls = 0;
+        const fwd = new IncidentForwarder({ logger: NOOP_LOGGER, maxRetries: 5 });
+        fwd.configure({ gatewayUrl: 'https://gw.example', fetchImpl: async () => { calls++; return { ok: false, status, text: async () => '' }; } });
+        fwd.handleAdapterEvent(validEvent(), 'a');
+        await fwd.flush();
+        assert.equal(calls, 1, `status ${status} must not retry`);
+        assert.equal(fwd.stats.contract, 1);
+    }
+});
+
+test('5xx is transport-class and IS retried', async () => {
+    let calls = 0;
+    const fetchImpl = async () => { calls++; return { ok: false, status: 503, text: async () => 'busy' }; };
+    const fwd = new IncidentForwarder({ logger: NOOP_LOGGER, maxRetries: 2 });
+    fwd.configure({ gatewayUrl: 'https://gw.example', fetchImpl });
+    fwd.handleAdapterEvent(validEvent(), 'a');
+    await fwd.flush();
+    assert.equal(calls, 3); // 1 + 2 retries
+    assert.equal(fwd.stats.contract, 0);
+    assert.equal(fwd.stats.failed, 1);
+});
+
+test('429 is rate limiting -> TRANSPORT class, keeps retry/backoff', async () => {
+    let calls = 0;
+    const fetchImpl = async () => { calls++; return { ok: false, status: 429, text: async () => 'slow down' }; };
+    const fwd = new IncidentForwarder({ logger: NOOP_LOGGER, maxRetries: 2 });
+    fwd.configure({ gatewayUrl: 'https://gw.example', fetchImpl });
+    fwd.handleAdapterEvent(validEvent(), 'a');
+    await fwd.flush();
+    assert.equal(calls, 3); // retried, not treated as a contract error
+    assert.equal(fwd.stats.contract, 0);
+    assert.equal(fwd.contractError, null);
+});
+
+test('failure metric reason is class-based (contract vs transport) with a code', async () => {
+    const seen = [];
+    const metrics = {
+        incReceived() {}, incForwarded() {}, incDropped() {},
+        incFailure: (reason, code) => seen.push({ reason, code }),
+    };
+    // contract
+    const c = new IncidentForwarder({ logger: NOOP_LOGGER, maxRetries: 3, metrics });
+    c.configure({ gatewayUrl: 'https://gw.example', fetchImpl: async () => ({ ok: false, status: 401, text: async () => '' }) });
+    c.handleAdapterEvent(validEvent(), 'a'); await c.flush();
+    // transport
+    const t = new IncidentForwarder({ logger: NOOP_LOGGER, maxRetries: 0, metrics });
+    t.configure({ gatewayUrl: 'https://gw.example', fetchImpl: async () => { throw new Error('down'); } });
+    t.handleAdapterEvent(validEvent(), 'a'); await t.flush();
+
+    assert.deepEqual(seen.find((s) => s.reason === 'contract'), { reason: 'contract', code: '401' });
+    assert.ok(seen.some((s) => s.reason === 'transport'));
+});
+
+test('contract preflight maps status -> verdict without creating data', async () => {
+    const cases = [
+        [400, true, 'reachable_auth_ok'],
+        [401, false, 'auth_rejected'],
+        [404, false, 'path_not_found'],
+        [503, false, 'transport_or_5xx'],
+    ];
+    for (const [status, ok, reason] of cases) {
+        const sent = [];
+        const fwd = new IncidentForwarder({ logger: NOOP_LOGGER });
+        fwd.configure({ gatewayUrl: 'https://gw.example', fetchImpl: async (_u, o) => { sent.push(JSON.parse(o.body)); return { ok: status < 400, status, text: async () => '' }; } });
+        const r = await fwd.contractPreflight();
+        assert.equal(r.ok, ok, `status ${status}`);
+        assert.equal(r.reason, reason);
+        // The probe must NOT carry a tenantId (so it can never create an incident).
+        assert.equal(sent[0].tenantId, undefined);
+    }
+});
+
+test('contract preflight when unreachable is not-ok and never throws', async () => {
+    const fwd = new IncidentForwarder({ logger: NOOP_LOGGER });
+    fwd.configure({ gatewayUrl: 'https://gw.example', fetchImpl: async () => { throw new Error('ECONNREFUSED'); } });
+    const r = await fwd.contractPreflight();
+    assert.equal(r.ok, false);
+    assert.equal(r.reason, 'unreachable');
+});
+
+test('backpressure evicts oldest and counts the drop (no silent drop)', async () => {
+    // Gate fetch so in-flight stays busy and the queue fills past maxQueue.
+    let release;
+    const gate = new Promise((r) => { release = r; });
+    const fetchImpl = async () => { await gate; return { ok: true, status: 200 }; };
+    const fwd = new IncidentForwarder({
+        logger: NOOP_LOGGER, maxRetries: 0, maxInflight: 1, maxQueue: 2, suppressor: NO_SUPPRESS,
+    });
+    fwd.configure({ gatewayUrl: 'https://gw.example', fetchImpl });
+
+    fwd.handleAdapterEvent(validEvent(), 'a'); // -> in-flight (gated)
+    fwd.handleAdapterEvent(validEvent(), 'a'); // -> queue [1]
+    fwd.handleAdapterEvent(validEvent(), 'a'); // -> queue [1,2] (== maxQueue)
+    const outcome = fwd.handleAdapterEvent(validEvent(), 'a'); // -> evict oldest
+
+    assert.equal(outcome, 'dropped');
+    assert.equal(fwd.stats.dropped, 1);
+
+    release();
+    await fwd.flush();
+    // 1 in-flight + 2 remaining in queue were forwarded; 1 was dropped.
+    assert.equal(fwd.stats.forwarded, 3);
+    assert.equal(fwd.stats.dropped, 1);
+});

package/test/multi-repo-open.test.js

@@ -0,0 +1,180 @@
+// test/multi-repo-open.test.js
+// MULTI-REPO OPEN partial tolerance (QA 2026-09-22): POST /workspace/open
+// with repos[] used ONE try/catch around a sequential clone loop, so the
+// first failed clone ("https://github.com/williambella/visionhammer-vault.git
+// -> Repository not found") aborted the loop and answered 500, discarding the
+// 9 repos already cloned. The hydration is now per-repo tolerant: >=1 cloned
+// -> 200 {partial:true, failed:[...masked]}; ALL failed -> 500;
+// MULTI_REPO_ALLOW_PARTIAL=false -> first failure aborts (old behavior).
+
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import {
+  hydrateRepos,
+  multiRepoAllowPartial,
+  planRepos,
+  repoDirName,
+} from '../src/utils/multi-repo-open.js';
+import { confineToRoot } from '../src/utils/sandbox.js';
+
+const WS = '/tmp/workspaces/ws-multi-qa';
+const TOKEN = 'ghp_SECRET_TOKEN_123';
+const BAD_REPO = 'https://github.com/williambella/visionhammer-vault.git';
+const GOOD_REPOS = [
+  'https://github.com/VISIONHAMMER/deepdebug-gateway.git',
+  'https://github.com/VISIONHAMMER/visionhammer-agents.git',
+  'https://github.com/VISIONHAMMER/deepdebug-local-agent.git',
+];
+
+const maskUrlCreds = (s) => String(s).replace(/(https?:\/\/)[^\s@]+@/gi, '$1***@');
+const quiet = { log() {}, warn() {} };
+
+/** Fake git: fails for repo URLs in `failing` with the QA-shaped message. */
+function fakeCloneRepo(failing) {
+  const calls = [];
+  const cloneRepo = async ({ repoUrl, token, destDir }) => {
+    calls.push({ repoUrl, destDir });
+    if (failing.has(repoUrl)) {
+      const authed = repoUrl.replace('https://', `https://x-access-token:${token}@`);
+      throw new Error(`Command failed: git clone --branch main --single-branch --depth 50 "${authed}" "${destDir}"\nremote: Repository not found.\nfatal: repository '${authed}' not found`);
+    }
+  };
+  return { cloneRepo, calls };
+}
+
+function deps(overrides = {}) {
+  return {
+    detectProject: async () => ({ language: 'java', buildTool: 'maven' }),
+    mkdir: async () => {},
+    maskUrlCreds,
+    token: TOKEN,
+    branch: 'main',
+    allowPartial: true,
+    wsId: 'ws-multi-qa',
+    logger: quiet,
+    ...overrides,
+  };
+}
+
+describe('multiRepoAllowPartial (env flag)', () => {
+  test('defaults ON; only the literal "false" turns it off', () => {
+    assert.equal(multiRepoAllowPartial({}), true);
+    assert.equal(multiRepoAllowPartial({ MULTI_REPO_ALLOW_PARTIAL: 'true' }), true);
+    assert.equal(multiRepoAllowPartial({ MULTI_REPO_ALLOW_PARTIAL: '' }), true);
+    assert.equal(multiRepoAllowPartial({ MULTI_REPO_ALLOW_PARTIAL: 'false' }), false);
+    assert.equal(multiRepoAllowPartial({ MULTI_REPO_ALLOW_PARTIAL: ' FALSE ' }), false);
+  });
+});
+
+describe('planRepos (validation before any clone)', () => {
+  test('resolves per-repo dirs inside the workspace dir', () => {
+    const plan = planRepos(
+      [{ repoUrl: GOOD_REPOS[0] }, { repoUrl: GOOD_REPOS[1], dir: 'agents' }],
+      { workspaceDir: WS, confineToRoot },
+    );
+    assert.deepEqual(plan.map((p) => p.dir), ['VISIONHAMMER_deepdebug-gateway', 'agents']);
+    // confineToRoot realpaths the base (macOS: /tmp -> /private/tmp); compare the tail
+    assert.ok(plan[1].destDir.endsWith(path.join('ws-multi-qa', 'agents')), plan[1].destDir);
+  });
+
+  test('missing repoUrl / escaping dir -> tagged 400, nothing planned', () => {
+    assert.throws(() => planRepos([{ repoUrl: GOOD_REPOS[0] }, {}], { workspaceDir: WS, confineToRoot }),
+      (e) => e.code === 'BAD_REQUEST' && e.httpStatus === 400);
+    assert.throws(() => planRepos([{ repoUrl: GOOD_REPOS[0], dir: '../escape' }], { workspaceDir: WS, confineToRoot: () => { throw new Error('escape'); } }),
+      (e) => e.code === 'BAD_REQUEST' && /invalid repo dir/.test(e.message));
+  });
+
+  test('repoDirName: org_repo, .git stripped', () => {
+    assert.equal(repoDirName(BAD_REPO), 'williambella_visionhammer-vault');
+  });
+});
+
+describe('hydrateRepos - partial tolerance', () => {
+  test('QA failure mode: ONE bad repo among good ones -> the good ones survive, failed[] is masked', async () => {
+    const repos = [...GOOD_REPOS.slice(0, 2), BAD_REPO, GOOD_REPOS[2]].map((repoUrl) => ({ repoUrl }));
+    const plan = planRepos(repos, { workspaceDir: WS, confineToRoot });
+    const { cloneRepo, calls } = fakeCloneRepo(new Set([BAD_REPO]));
+
+    const { cloned, failed, firstError } = await hydrateRepos(plan, deps({ cloneRepo }));
+
+    assert.equal(calls.length, 4, 'the loop must NOT stop at the failing repo');
+    assert.equal(cloned.length, 3);
+    assert.equal(failed.length, 1);
+    assert.equal(failed[0].dir, 'williambella_visionhammer-vault');
+    assert.equal(failed[0].repoUrl, BAD_REPO);
+    assert.match(failed[0].error, /Repository not found/);
+    // SEG-1: the token never leaks through the response/log shape
+    assert.doesNotMatch(JSON.stringify({ cloned, failed }), new RegExp(TOKEN));
+    assert.match(failed[0].error, /x-access-token:\*\*\*@|\/\/\*\*\*@/);
+    assert.ok(firstError instanceof Error);
+    // the server maps this to 200 {ok:true, partial:true}
+    assert.equal(cloned.length > 0 && failed.length > 0, true);
+  });
+
+  test('ALL repos bad -> nothing cloned, every failure listed (server answers 500)', async () => {
+    const plan = planRepos([{ repoUrl: BAD_REPO }, { repoUrl: GOOD_REPOS[0] }], { workspaceDir: WS, confineToRoot });
+    const { cloneRepo } = fakeCloneRepo(new Set([BAD_REPO, GOOD_REPOS[0]]));
+
+    const { cloned, failed, firstError } = await hydrateRepos(plan, deps({ cloneRepo }));
+
+    assert.equal(cloned.length, 0);
+    assert.equal(failed.length, 2);
+    assert.match(firstError.message, /visionhammer-vault/);
+  });
+
+  test('MULTI_REPO_ALLOW_PARTIAL=false -> first failure aborts the loop (pre-fix behavior)', async () => {
+    const repos = [GOOD_REPOS[0], BAD_REPO, GOOD_REPOS[1]].map((repoUrl) => ({ repoUrl }));
+    const plan = planRepos(repos, { workspaceDir: WS, confineToRoot });
+    const { cloneRepo, calls } = fakeCloneRepo(new Set([BAD_REPO]));
+
+    await assert.rejects(
+      hydrateRepos(plan, deps({ cloneRepo, allowPartial: multiRepoAllowPartial({ MULTI_REPO_ALLOW_PARTIAL: 'false' }) })),
+      /Repository not found/,
+    );
+    assert.equal(calls.length, 2, 'third repo never attempted');
+  });
+
+  test('all good -> partial:false shape (failed empty, no firstError)', async () => {
+    const plan = planRepos(GOOD_REPOS.map((repoUrl) => ({ repoUrl })), { workspaceDir: WS, confineToRoot });
+    const { cloneRepo } = fakeCloneRepo(new Set());
+    const { cloned, failed, firstError } = await hydrateRepos(plan, deps({ cloneRepo }));
+    assert.equal(cloned.length, 3);
+    assert.deepEqual(failed, []);
+    assert.equal(firstError, null);
+    assert.deepEqual(cloned.map((c) => c.repoUrl), GOOD_REPOS);
+  });
+
+  test('per-repo token/branch override the workspace-level ones; tagged git errors keep their code', async () => {
+    const seen = [];
+    const cloneRepo = async (args) => {
+      seen.push(args);
+      if (args.branch === 'nope') { const e = new Error('branch nope not found'); e.code = 'BRANCH_NOT_FOUND'; e.httpStatus = 404; throw e; }
+    };
+    const plan = planRepos([
+      { repoUrl: GOOD_REPOS[0], token: 'per-repo-token', branch: 'develop' },
+      { repoUrl: GOOD_REPOS[1], branch: 'nope' },
+    ], { workspaceDir: WS, confineToRoot });
+    const { cloned, failed, firstError } = await hydrateRepos(plan, deps({ cloneRepo }));
+    assert.equal(seen[0].token, 'per-repo-token');
+    assert.equal(seen[0].branch, 'develop');
+    assert.equal(seen[1].token, TOKEN);
+    assert.equal(cloned.length, 1);
+    assert.equal(failed.length, 1);
+    assert.equal(firstError.code, 'BRANCH_NOT_FOUND');
+  });
+
+  test('the partial log line names counts and masked reasons', async () => {
+    const lines = [];
+    const logger = { log() {}, warn: (m) => lines.push(m) };
+    const plan = planRepos([{ repoUrl: GOOD_REPOS[0] }, { repoUrl: BAD_REPO }], { workspaceDir: WS, confineToRoot });
+    const { cloneRepo } = fakeCloneRepo(new Set([BAD_REPO]));
+    const cleaned = [];
+    await hydrateRepos(plan, deps({ cloneRepo, logger, cleanupFailed: async (d) => { cleaned.push(d); } }));
+    const partial = lines.find((l) => l.startsWith('[multi-repo] partial:'));
+    assert.match(partial, /1 cloned, 1 failed/);
+    assert.deepEqual(cleaned, [path.join(plan[1].destDir)], 'failed per-repo dir is cleaned up');
+    assert.match(partial, /williambella_visionhammer-vault \(.*Repository not found/s);
+    assert.doesNotMatch(lines.join('\n'), new RegExp(TOKEN));
+  });
+});

package/test/multi-repo-pr.test.js

@@ -0,0 +1,129 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+import {
+    multiRepoPrEnabled,
+    listRepoSubdirs,
+    isMultiRepoRoot,
+    parseAuthedRemote,
+    stripRemoteCreds,
+    buildCompareUrl,
+    buildCrossLinkNote,
+    buildMultiRepoPrBody,
+} from "../src/git/multi-repo-pr.js";
+
+function mkTmp() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), "mrpr-"));
+}
+function mkRepo(root, name) {
+    const p = path.join(root, name);
+    fs.mkdirSync(path.join(p, ".git"), { recursive: true });
+    return p;
+}
+
+test("multiRepoPrEnabled defaults on, false disables", () => {
+    assert.equal(multiRepoPrEnabled({}), true);
+    assert.equal(multiRepoPrEnabled({ MULTI_REPO_PR_ENABLED: "true" }), true);
+    assert.equal(multiRepoPrEnabled({ MULTI_REPO_PR_ENABLED: "false" }), false);
+    assert.equal(multiRepoPrEnabled({ MULTI_REPO_PR_ENABLED: "FALSE" }), false);
+});
+
+test("listRepoSubdirs finds only git sub-dirs, sorted", () => {
+    const root = mkTmp();
+    mkRepo(root, "beta");
+    mkRepo(root, "alpha");
+    fs.mkdirSync(path.join(root, "not-a-repo"), { recursive: true });
+    const dirs = listRepoSubdirs(root).map((r) => r.dir);
+    assert.deepEqual(dirs, ["alpha", "beta"]);
+});
+
+test("isMultiRepoRoot: parent with git sub-repos = true", () => {
+    const root = mkTmp();
+    mkRepo(root, "svc-a");
+    mkRepo(root, "svc-b");
+    assert.equal(isMultiRepoRoot(root), true);
+});
+
+test("isMultiRepoRoot: single-repo root (root itself a git repo) = false", () => {
+    const root = mkTmp();
+    fs.mkdirSync(path.join(root, ".git"), { recursive: true });
+    mkRepo(root, "nested"); // even with a nested repo, root being a repo wins
+    assert.equal(isMultiRepoRoot(root), false);
+});
+
+test("isMultiRepoRoot: empty/plain dir = false", () => {
+    const root = mkTmp();
+    fs.mkdirSync(path.join(root, "plain"), { recursive: true });
+    assert.equal(isMultiRepoRoot(root), false);
+});
+
+test("parseAuthedRemote: GitHub x-access-token", () => {
+    const r = parseAuthedRemote("https://x-access-token:ghp_ABC@github.com/acme/web.git");
+    assert.equal(r.provider, "github");
+    assert.equal(r.host, "github.com");
+    assert.equal(r.ownerRepo, "acme/web");
+    assert.equal(r.apiToken, "ghp_ABC");
+});
+
+test("parseAuthedRemote: GitLab oauth2 + no .git suffix", () => {
+    const r = parseAuthedRemote("https://oauth2:glpat_X@gitlab.com/group/sub/repo");
+    assert.equal(r.provider, "gitlab");
+    assert.equal(r.ownerRepo, "group/sub/repo");
+    assert.equal(r.apiToken, "glpat_X");
+});
+
+test("parseAuthedRemote: no credentials", () => {
+    const r = parseAuthedRemote("https://github.com/acme/web");
+    assert.equal(r.provider, "github");
+    assert.equal(r.ownerRepo, "acme/web");
+    assert.equal(r.apiToken, "");
+});
+
+test("stripRemoteCreds removes userinfo and .git", () => {
+    assert.equal(
+        stripRemoteCreds("https://x-access-token:TOK@github.com/acme/web.git"),
+        "https://github.com/acme/web"
+    );
+});
+
+test("buildCompareUrl per provider", () => {
+    assert.match(buildCompareUrl("https://github.com/a/b", "github", "vh/x", "main"),
+        /\/compare\/main\.\.\.vh\/x\?expand=1$/);
+    assert.match(buildCompareUrl("https://gitlab.com/a/b", "gitlab", "vh/x", "main"),
+        /merge_requests\/new/);
+    assert.match(buildCompareUrl("https://bitbucket.org/a/b", "bitbucket", "vh/x", "main"),
+        /pull-requests\/new/);
+});
+
+test("buildCrossLinkNote links only siblings", () => {
+    const prs = [
+        { dir: "web", prUrl: "https://github.com/a/web/pull/1" },
+        { dir: "api", prUrl: "https://github.com/a/api/pull/2" },
+        { dir: "libs", prUrl: "" }, // no url -> excluded
+    ];
+    const note = buildCrossLinkNote("web", prs);
+    assert.ok(note.includes("api: https://github.com/a/api/pull/2"));
+    assert.ok(!note.includes("web/pull/1")); // not self
+    assert.ok(!note.includes("libs:"));
+});
+
+test("buildCrossLinkNote: no siblings -> empty", () => {
+    assert.equal(buildCrossLinkNote("only", [{ dir: "only", prUrl: "u" }]), "");
+});
+
+test("buildMultiRepoPrBody is ASCII and carries dir/branch + trailer", () => {
+    const body = buildMultiRepoPrBody({
+        dir: "web", branch: "vh/abc123", commitMessage: "feat: x",
+        filesChanged: 3, commitSha: "deadbeefcafe",
+    });
+    assert.ok(body.includes("`web`"));
+    assert.ok(body.includes("vh/abc123"));
+    assert.ok(body.includes("deadbeef"));
+    assert.ok(body.includes("Generated by VisionHammer Agent"));
+    assert.ok(!/claude/i.test(body));
+    // ASCII-only guard
+    assert.ok(/^[\x00-\x7F]*$/.test(body), "PR body must be ASCII-only");
+});

package/test/next-version.test.js

@@ -0,0 +1,48 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { classify, bumpFor, nextVersion } from '../scripts/next-version.mjs'
+
+test('fix and other non-feature types are a patch', () => {
+  for (const s of ['fix: handle empty body', 'fix(ci): x', 'chore: tidy', 'docs: readme', 'ci: workflow', 'perf: faster', 'refactor: split', 'Update thing']) {
+    assert.equal(classify(s), 'patch', s)
+  }
+})
+
+test('feat is a minor', () => {
+  assert.equal(classify('feat: add DLP masking'), 'minor')
+  assert.equal(classify('feat(ws): metadata only channel'), 'minor')
+})
+
+test('breaking changes are a major, by "!" or by footer', () => {
+  assert.equal(classify('feat!: drop node 18'), 'major')
+  assert.equal(classify('fix(api)!: rename endpoint'), 'major')
+  assert.equal(classify('fix: x\n\nBREAKING CHANGE: signature enforce is mandatory'), 'major')
+  assert.equal(classify('chore: y\n\nBREAKING-CHANGE: z'), 'major')
+})
+
+test('auto-bump and merge commits are ignored', () => {
+  assert.equal(classify('ci: auto bump to 1.1.0 [skip ci]'), null)
+  assert.equal(classify('Merge pull request #55 from x/y'), null)
+  assert.equal(classify(''), null)
+})
+
+test('the highest level wins', () => {
+  assert.equal(bumpFor(['fix: a', 'fix: b']), 'patch')
+  assert.equal(bumpFor(['fix: a', 'feat: b', 'chore: c']), 'minor')
+  assert.equal(bumpFor(['feat: a', 'fix!: b', 'fix: c']), 'major')
+  assert.equal(bumpFor([]), 'patch')
+  assert.equal(bumpFor(['ci: auto bump to 1.2.0 [skip ci]']), 'patch')
+})
+
+test('a footer that is not at the start of a line is not breaking', () => {
+  assert.equal(classify('fix: mention BREAKING CHANGE: in prose'), 'patch')
+})
+
+test('nextVersion resets the lower levels', () => {
+  assert.equal(nextVersion('1.1.0', 'patch'), '1.1.1')
+  assert.equal(nextVersion('1.1.7', 'minor'), '1.2.0')
+  assert.equal(nextVersion('1.9.4', 'major'), '2.0.0')
+  assert.equal(nextVersion('0.0.1', 'minor'), '0.1.0')
+  assert.throws(() => nextVersion('1.1', 'patch'))
+  assert.throws(() => nextVersion('1.x.0', 'patch'))
+})