archbyte 0.4.1 → 0.5.0

package/README.md

@@ -8,40 +8,24 @@ AI-powered architecture visualization for your codebase. Analyzes code, generate
 # Install
 curl -fsSL https://archbyte.heartbyte.io/install.sh | bash
 
-# Sign in or create a free account
-archbyte login
-
-# Configure your AI provider (BYOK)
-archbyte init
-
-# Using Claude Code / Codex? Install the MCP server too:
-archbyte mcp install
+# Run (auto-configures on first use)
+archbyte run
 ```
 
-Your API keys stay on your machine. ArchByte never stores or transmits your provider credentials.
+On first run, ArchByte walks you through sign-in and provider setup interactively. Your API keys stay on your machine — ArchByte never stores or transmits your provider credentials.
 
-### Setup with Claude Code
+### Manual setup
 
-**Option A: MCP** — use ArchByte tools directly in Claude Code. You still need to sign in and configure a provider first:
+Prefer to configure each step separately:
 
 ```bash
-archbyte mcp install
-# or manually:
-claude mcp add archbyte --transport stdio -- npx -y archbyte@latest mcp
+archbyte login          # Sign in or create a free account
+archbyte init           # Configure your AI provider (BYOK)
 ```
 
-Then just ask Claude Code in plain English:
-
-```
-"Analyze the architecture of this project"
-"Export the architecture as a Mermaid diagram"
-"Show me the architecture stats"
-"Read the current architecture diagram"
-```
-
-Available MCP tools: `archbyte_analyze`, `archbyte_generate`, `archbyte_validate` (Pro), `archbyte_export`, `archbyte_stats`, `archbyte_diff`, `archbyte_read_diagram`.
+### Setup with Claude Code
 
-**Option B: Slash commands** — installed globally so they work in any project:
+Slash commands — installed globally so they work in any project:
 
 ```bash
 mkdir -p ~/.claude/commands

package/bin/archbyte.js

@@ -11,10 +11,7 @@ import { Command } from 'commander';
 import { handleServe } from '../dist/cli/serve.js';
 import { handleGenerate } from '../dist/cli/generate.js';
 import { handleStats } from '../dist/cli/stats.js';
-import { handleValidate } from '../dist/cli/validate.js';
 import { handleExport } from '../dist/cli/export.js';
-import { handleDiff } from '../dist/cli/diff.js';
-import { handlePatrol } from '../dist/cli/patrol.js';
 import { handleWorkflow } from '../dist/cli/workflow.js';
 import { handleAnalyze } from '../dist/cli/analyze.js';
 import { handleConfig } from '../dist/cli/config.js';
@@ -36,9 +33,13 @@ program
   .version(PKG_VERSION, '-v, --version', 'Show version number')
   .addHelpText('after', `
   Quick start:
+    $ archbyte run            Analyze + open diagram (auto-configures on first run)
+
+  Or step by step:
     $ archbyte login          Sign in or create a free account
     $ archbyte init           Configure your model provider
-    $ archbyte run            Analyze + open interactive diagram UI
+
+  Run from your project root, or pass --dir <path> to specify the directory.
 
   https://archbyte.heartbyte.io
 `);
@@ -93,7 +94,7 @@ program
   .option('--force', 'Force full re-scan (skip incremental detection)')
   .option('--dry-run', 'Preview without running')
   .action(async (options) => {
-    await requireLicense('analyze');
+    // handleRun manages login + setup + requireLicense internally
     await handleRun(options);
   });
 
@@ -145,27 +146,6 @@ program
     await handleStats(options);
   });
 
-program
-  .command('validate')
-  .description('Run architecture fitness function rules')
-  .option('-d, --diagram <path>', 'Path to architecture JSON (default: .archbyte/architecture.json)')
-  .option('-c, --config <path>', 'Path to archbyte.yaml config')
-  .option('--ci', 'Machine-readable JSON output for CI pipelines')
-  .action(async (options) => {
-    await requireLicense('analyze');
-    await handleValidate(options);
-  });
-
-program
-  .command('diff')
-  .description('Compare architecture snapshots and detect drift')
-  .requiredOption('-b, --baseline <path>', 'Path to baseline architecture JSON')
-  .option('-c, --current <path>', 'Path to current architecture JSON (default: .archbyte/architecture.json)')
-  .option('--config <path>', 'Path to archbyte.yaml config')
-  .action(async (options) => {
-    await handleDiff(options);
-  });
-
 program
   .command('export')
   .description('Export architecture to various formats')
@@ -178,21 +158,6 @@ program
 
 // — Advanced (Pro) —
 
-program
-  .command('patrol')
-  .description('Run continuous architecture health monitoring (Gastown-inspired patrol loop)')
-  .option('-d, --diagram <path>', 'Path to architecture JSON (default: .archbyte/architecture.json)')
-  .option('-c, --config <path>', 'Path to archbyte.yaml config')
-  .option('-i, --interval <duration>', 'Patrol interval: 30s, 5m, 1h (default: 5m)')
-  .option('--on-violation <action>', 'Action on new violations: log, json (default: log)')
-  .option('--once', 'Run a single patrol cycle then exit')
-  .option('-w, --watch', 'Watch source files for changes instead of polling on interval')
-  .option('--history', 'Show patrol history dashboard')
-  .action(async (options) => {
-    await requireLicense('analyze');
-    await handlePatrol(options);
-  });
-
 program
   .command('workflow')
   .description('Run composable architecture workflows (MEOW-inspired pipeline system)')

package/dist/cli/analyze.js

@@ -6,7 +6,7 @@ import { resolveConfig } from "./config.js";
 import { recordUsage } from "./license-gate.js";
 import { staticResultToSpec, writeSpec, writeMetadata, loadSpec, loadMetadata } from "./yaml-io.js";
 import { getChangedFiles, mapFilesToComponents, shouldRunAgents, isGitAvailable, categorizeChanges, computeNeighbors, getCommitCount } from "./incremental.js";
-import { progressBar } from "./ui.js";
+import { progressBar, confirm } from "./ui.js";
 export async function handleAnalyze(options) {
     const rootDir = options.dir ? path.resolve(options.dir) : process.cwd();
     const isStaticOnly = options.static || options.skipLlm;
@@ -48,12 +48,18 @@ export async function handleAnalyze(options) {
             progress.update(0, `Static analysis: ${msg}`);
         });
         progress.update(1, "Building analysis...");
-        const analysis = buildAnalysisFromStatic(result, rootDir);
+        const freshAnalysis = buildAnalysisFromStatic(result, rootDir);
         const duration = Date.now() - startTime;
+        // Merge into existing analysis if it was produced by an agentic run,
+        // preserving LLM-generated components/connections while refreshing
+        // static data (environments, metadata, project info).
+        const existingAnalysis = loadExistingAnalysis(rootDir);
+        const wasAgentic = existingAnalysis && existingAnalysis.metadata?.mode !== "static";
+        const analysis = wasAgentic ? mergeStaticIntoExisting(existingAnalysis, freshAnalysis) : freshAnalysis;
         // Stamp scan metadata on analysis.json (backward compat)
         const ameta = analysis.metadata;
         ameta.durationMs = duration;
-        ameta.mode = "static";
+        ameta.mode = wasAgentic ? "static-refresh" : "static";
         writeAnalysis(rootDir, analysis);
         // Dual-write: archbyte.yaml + metadata.json
         const existingSpec = loadSpec(rootDir);
@@ -79,28 +85,20 @@ export async function handleAnalyze(options) {
         config.apiKey = options.apiKey;
     }
     if (!config) {
-        const msg = [
-            chalk.red("No model provider configured."),
-            "",
-            chalk.bold("Zero-config (Claude Code users):"),
-            chalk.gray("  Install Claude Code → archbyte analyze just works"),
-            "",
-            chalk.bold("Or set up with:"),
-            chalk.gray("  archbyte config set provider anthropic"),
-            chalk.gray("  archbyte config set api-key sk-ant-..."),
-            "",
-            chalk.bold("Or use environment variables:"),
-            chalk.gray("  export ARCHBYTE_PROVIDER=anthropic"),
-            chalk.gray("  export ARCHBYTE_API_KEY=sk-ant-..."),
-            "",
-            chalk.bold("Or run without a model:"),
-            chalk.gray("  archbyte analyze --static"),
-            "",
-            chalk.bold("Supported providers:"),
-            chalk.gray("  anthropic, openai, google, claude-sdk"),
-        ].join("\n");
-        console.error(msg);
-        throw new Error("No model provider configured");
+        console.log(chalk.yellow("No model provider configured."));
+        console.log();
+        const shouldSetup = await confirm("Set up your AI provider now?");
+        if (shouldSetup) {
+            const { handleSetup } = await import("./setup.js");
+            await handleSetup();
+            config = resolveConfig();
+        }
+        if (!config) {
+            console.log();
+            console.log(chalk.gray("Running static-only analysis (no AI)."));
+            console.log();
+            return handleAnalyze({ ...options, static: true });
+        }
     }
     const providerLabel = config.provider === "claude-sdk" ? "Claude Code (SDK)" : config.provider;
     console.log(chalk.gray(`Provider: ${chalk.white(providerLabel)}`));
@@ -413,10 +411,34 @@ function printSummary(analysis, durationMs, mode, options) {
     if (!options?.skipServeHint) {
         console.log(`  ${chalk.cyan("archbyte serve")}      Open the interactive diagram`);
     }
-    console.log(`  ${chalk.cyan("archbyte validate")}   Check architecture fitness rules ${chalk.yellow("[Pro]")}`);
-    console.log(`  ${chalk.cyan("archbyte patrol")}     Continuous architecture monitoring ${chalk.yellow("[Pro]")}`);
     console.log();
 }
+// ─── Analysis merge helpers ───
+function loadExistingAnalysis(rootDir) {
+    const p = path.join(rootDir, ".archbyte", "analysis.json");
+    try {
+        return JSON.parse(fs.readFileSync(p, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Merge fresh static scan into an existing agentic analysis.
+ * Preserves: components, connections, flows, databases, externalServices (LLM-generated).
+ * Updates: project info, environments, metadata, c4/infra if present.
+ */
+function mergeStaticIntoExisting(existing, fresh) {
+    return {
+        ...existing,
+        project: fresh.project,
+        environments: fresh.environments,
+        metadata: {
+            ...(existing.metadata ?? {}),
+            ...(fresh.metadata ?? {}),
+        },
+    };
+}
 // ─── Analysis converters ───
 /**
  * Convert a StaticAnalysisResult (from pipeline or static-only) into the

package/dist/cli/license-gate.js

@@ -1,6 +1,7 @@
 import chalk from "chalk";
 import { loadCredentials, cacheVerifiedTier, resetOfflineActions, checkOfflineAction } from "./auth.js";
 import { API_BASE, NETWORK_TIMEOUT_MS } from "./constants.js";
+import { confirm } from "./ui.js";
 /**
  * Pre-flight license check. Must be called before scan/analyze/generate.
  *
@@ -16,25 +17,44 @@ import { API_BASE, NETWORK_TIMEOUT_MS } from "./constants.js";
  * the 1-hour cache window. Exceeding limits blocks the action.
  */
 export async function requireLicense(action) {
-    const creds = loadCredentials();
-    // Not logged in
+    let creds = loadCredentials();
+    // Not logged in — offer interactive login
     if (!creds) {
-        console.error();
-        console.error(chalk.red("Authentication required."));
-        console.error();
-        console.error(chalk.gray("Sign in or create a free account:"));
-        console.error(chalk.gray("  archbyte login"));
-        console.error();
-        console.error(chalk.gray("Free tier includes unlimited scans. No credit card required."));
-        process.exit(1);
+        console.log();
+        console.log(chalk.yellow("Not signed in."));
+        console.log(chalk.gray("Free tier includes unlimited scans. No credit card required."));
+        console.log();
+        const shouldLogin = await confirm("Sign in now?");
+        if (!shouldLogin)
+            process.exit(1);
+        const { handleLogin } = await import("./auth.js");
+        await handleLogin();
+        creds = loadCredentials();
+        if (!creds) {
+            console.error(chalk.red("Login failed. Please try again with `archbyte login`."));
+            process.exit(1);
+        }
     }
-    // Token expired locally (treat invalid dates as expired — fail-closed)
+    // Token expired locally — offer re-login
     const expiry = new Date(creds.expiresAt);
     if (isNaN(expiry.getTime()) || expiry < new Date()) {
-        console.error();
-        console.error(chalk.red("Session expired."));
-        console.error(chalk.gray("Run `archbyte login` to refresh your session."));
-        process.exit(1);
+        console.log();
+        console.log(chalk.yellow("Session expired."));
+        const shouldRelogin = await confirm("Sign in again?");
+        if (!shouldRelogin)
+            process.exit(1);
+        const { handleLogin } = await import("./auth.js");
+        await handleLogin();
+        creds = loadCredentials();
+        if (!creds) {
+            console.error(chalk.red("Login failed. Please try again with `archbyte login`."));
+            process.exit(1);
+        }
+        const freshExpiry = new Date(creds.expiresAt);
+        if (isNaN(freshExpiry.getTime()) || freshExpiry < new Date()) {
+            console.error(chalk.red("Session still expired. Please try `archbyte login`."));
+            process.exit(1);
+        }
     }
     // Check usage with server
     try {
@@ -48,10 +68,18 @@ export async function requireLicense(action) {
             signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
         });
         if (res.status === 401) {
-            console.error();
-            console.error(chalk.red("Session invalid. Please log in again."));
-            console.error(chalk.gray("  archbyte login"));
-            process.exit(1);
+            console.log();
+            console.log(chalk.yellow("Session invalid."));
+            const shouldRelogin = await confirm("Sign in again?");
+            if (!shouldRelogin)
+                process.exit(1);
+            const { handleLogin } = await import("./auth.js");
+            await handleLogin();
+            creds = loadCredentials();
+            if (!creds)
+                process.exit(1);
+            // Re-check usage with fresh credentials
+            return requireLicense(action);
         }
         if (!res.ok) {
             // Server error — enforce offline limits instead of allowing freely

package/dist/cli/run.js

@@ -1,8 +1,124 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
 import { handleAnalyze } from "./analyze.js";
 import { handleServe } from "./serve.js";
-import { DEFAULT_PORT } from "./constants.js";
+import { DEFAULT_PORT, CONFIG_PATH } from "./constants.js";
+import { loadCredentials } from "./auth.js";
+import { resolveConfig } from "./config.js";
+import { requireLicense } from "./license-gate.js";
+import { isTTY } from "./utils.js";
+/**
+ * Check if the user has explicitly configured a provider via `archbyte init`.
+ * This reads the raw config file — unlike resolveConfig() which auto-detects
+ * Claude Code on PATH, env vars, etc. We want to trigger setup only when
+ * the user hasn't gone through init yet.
+ */
+function hasExplicitConfig() {
+    try {
+        if (!fs.existsSync(CONFIG_PATH))
+            return false;
+        const config = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+        return !!config.provider;
+    }
+    catch {
+        return false;
+    }
+}
 export async function handleRun(options) {
     const port = options.port || DEFAULT_PORT;
+    const isStaticOnly = options.static || options.skipLlm;
+    // ─── First-run onboarding: login + provider setup ───
+    const creds = loadCredentials();
+    const needsLogin = !creds;
+    const needsSetup = !hasExplicitConfig() && !isStaticOnly && !options.provider;
+    if (needsLogin || needsSetup) {
+        const dim = chalk.gray;
+        const sep = dim("  ───");
+        console.log();
+        console.log(chalk.bold.cyan("  Welcome to ArchByte"));
+        console.log(dim("  Visual observability for agentic development."));
+        console.log(dim("  Understand what your agents are building, in real time."));
+        console.log();
+        console.log(sep);
+        console.log();
+        console.log(dim("  Docs     ") + chalk.cyan("https://archbyte.heartbyte.io/setup.html"));
+        console.log(dim("  Website  ") + chalk.cyan("https://archbyte.heartbyte.io"));
+        console.log();
+        console.log(sep);
+        console.log();
+        console.log(dim("  Let's get you set up. This takes about 30 seconds."));
+        console.log();
+        // Step 1: Login
+        if (needsLogin) {
+            const { handleLogin } = await import("./auth.js");
+            await handleLogin();
+            if (!loadCredentials()) {
+                console.error(chalk.red("Login required. Run `archbyte login` to try again."));
+                process.exit(1);
+            }
+        }
+        // Step 2: Provider setup
+        if (needsSetup) {
+            const { handleSetup } = await import("./setup.js");
+            await handleSetup({ calledFromRun: true });
+        }
+        // Show config summary and pause before scanning
+        const resolvedConfig = resolveConfig();
+        const resolvedCreds = loadCredentials();
+        const rootDir = options.dir ? path.resolve(options.dir) : process.cwd();
+        console.log(sep);
+        console.log();
+        console.log("  " + chalk.bold("Ready to scan"));
+        console.log();
+        if (resolvedCreds) {
+            console.log(dim("  Account    ") + chalk.white(resolvedCreds.email));
+        }
+        if (resolvedConfig) {
+            const providerLabel = resolvedConfig.provider === "claude-sdk"
+                ? "Claude Code (SDK)"
+                : resolvedConfig.provider;
+            console.log(dim("  Provider   ") + chalk.white(providerLabel));
+            if (resolvedConfig.model) {
+                console.log(dim("  Model      ") + chalk.white(resolvedConfig.model));
+            }
+            if (resolvedConfig.provider !== "claude-sdk") {
+                console.log(dim("  API key    ") + (resolvedConfig.apiKey ? chalk.green("configured") : chalk.yellow("not set")));
+            }
+        }
+        console.log(dim("  Project    ") + chalk.white(path.basename(rootDir)));
+        console.log(dim("  Directory  ") + chalk.white(rootDir));
+        console.log();
+        // Pause — let the user absorb the config before scanning
+        if (isTTY()) {
+            await new Promise((resolve) => {
+                process.stdout.write(dim("  Press Enter to start analysis (q to quit)..."));
+                const stdin = process.stdin;
+                stdin.setRawMode(true);
+                stdin.resume();
+                stdin.setEncoding("utf8");
+                const onData = (data) => {
+                    if (data === "\r" || data === "\n" || data === " ") {
+                        stdin.setRawMode(false);
+                        stdin.pause();
+                        stdin.removeListener("data", onData);
+                        process.stdout.write("\n\n");
+                        resolve();
+                    }
+                    else if (data === "q" || data === "Q" || data === "\u0003" || data === "\u001b") {
+                        stdin.setRawMode(false);
+                        stdin.pause();
+                        stdin.removeListener("data", onData);
+                        process.stdout.write("\n");
+                        process.exit(0);
+                    }
+                };
+                stdin.on("data", onData);
+            });
+        }
+    }
+    // License/usage check (creds guaranteed to exist after onboarding)
+    await requireLicense("analyze");
     // 1. Analyze (includes auto-generate)
     await handleAnalyze({
         verbose: options.verbose,

package/dist/cli/setup.d.ts

@@ -1 +1,6 @@
-export declare function handleSetup(): Promise<void>;
+interface SetupOptions {
+    /** When true, skip "archbyte run" in next steps (called from `archbyte run`) */
+    calledFromRun?: boolean;
+}
+export declare function handleSetup(opts?: SetupOptions): Promise<void>;
+export {};

package/dist/cli/setup.js

@@ -207,7 +207,8 @@ async function validateProviderSilent(providerName, apiKey, model) {
 function getProfiles(config) {
     return config.profiles ?? {};
 }
-export async function handleSetup() {
+export async function handleSetup(opts) {
+    const calledFromRun = opts?.calledFromRun ?? false;
     console.log();
     console.log(chalk.bold.cyan("ArchByte Setup"));
     console.log(chalk.gray("Configure your model provider and API key.\n"));
@@ -300,12 +301,20 @@ export async function handleSetup() {
             console.log();
             console.log(sep);
             console.log();
-            console.log("  " + chalk.bold("Next steps"));
-            console.log();
-            console.log("  " + chalk.cyan("archbyte run") + "            Analyze your codebase");
-            console.log("  " + chalk.cyan("archbyte status") + "         Check account and usage");
-            console.log("  " + chalk.cyan("archbyte --help") + "         See all commands");
-            console.log();
+            if (calledFromRun) {
+                console.log(dim("  Continuing to scan your codebase..."));
+                console.log();
+            }
+            else {
+                console.log("  " + chalk.bold("Next steps"));
+                console.log();
+                console.log("  " + chalk.cyan("archbyte run") + "            Analyze your codebase");
+                console.log("  " + chalk.cyan("archbyte status") + "         Check account and usage");
+                console.log("  " + chalk.cyan("archbyte --help") + "         See all commands");
+                console.log();
+                console.log(dim("  Run from your project root, or use --dir <path> to specify the directory."));
+                console.log();
+            }
             return;
         }
         if (choice === "codex") {
@@ -588,18 +597,28 @@ export async function handleSetup() {
     console.log();
     console.log(sep);
     console.log();
-    console.log("  " + chalk.bold("Next steps"));
-    console.log();
-    console.log("  " + chalk.cyan("archbyte run") + "            Analyze your codebase");
-    if (hasClaude || hasCodex) {
+    if (calledFromRun) {
+        if (result === false) {
+            console.log(chalk.yellow("  Warning: credentials unverified. Saving anyway."));
+            console.log();
+        }
+        console.log(dim("  Continuing to scan your codebase..."));
+        console.log();
     }
-    console.log("  " + chalk.cyan("archbyte status") + "         Check account and usage");
-    console.log("  " + chalk.cyan("archbyte --help") + "         See all commands");
-    if (result === false) {
+    else {
+        console.log("  " + chalk.bold("Next steps"));
+        console.log();
+        console.log("  " + chalk.cyan("archbyte run") + "            Analyze your codebase");
+        console.log("  " + chalk.cyan("archbyte status") + "         Check account and usage");
+        console.log("  " + chalk.cyan("archbyte --help") + "         See all commands");
+        console.log();
+        console.log(dim("  Run from your project root, or use --dir <path> to specify the directory."));
+        if (result === false) {
+            console.log();
+            console.log(chalk.yellow("  Warning: credentials unverified. Saving anyway."));
+        }
         console.log();
-        console.log(chalk.yellow("  Warning: credentials unverified. Saving anyway."));
     }
-    console.log();
 }
 function writeArchbyteReadme(archbyteDir) {
     const readmePath = path.join(archbyteDir, "README.md");

package/dist/cli/shared.d.ts

@@ -64,16 +64,5 @@ export declare function parseRulesFromYaml(content: string): RuleConfig;
  *         level: error
  */
 export declare function parseCustomRulesFromYaml(content: string): CustomRule[];
-/**
- * Parse the patrol.ignore list from archbyte.yaml.
- * Returns user-defined glob patterns for watch mode to ignore.
- *
- *   patrol:
- *     ignore:
- *       - "docs/"
- *       - "*.md"
- *       - "build/"
- */
-export declare function loadPatrolIgnore(configPath?: string): string[];
 export declare function getRuleLevel(config: RuleConfig, rule: keyof RuleConfig, defaultLevel: RuleLevel): RuleLevel;
 export declare function getThreshold(config: RuleConfig, rule: "max-connections", defaultVal: number): number;

package/dist/cli/shared.js

@@ -259,67 +259,6 @@ export function parseCustomRulesFromYaml(content) {
         flushItem();
     return rules;
 }
-/**
- * Parse the patrol.ignore list from archbyte.yaml.
- * Returns user-defined glob patterns for watch mode to ignore.
- *
- *   patrol:
- *     ignore:
- *       - "docs/"
- *       - "*.md"
- *       - "build/"
- */
-export function loadPatrolIgnore(configPath) {
-    const rootDir = process.cwd();
-    const yamlPath = configPath
-        ? path.resolve(rootDir, configPath)
-        : path.join(rootDir, ".archbyte", "archbyte.yaml");
-    if (!fs.existsSync(yamlPath))
-        return [];
-    try {
-        const lines = fs.readFileSync(yamlPath, "utf-8").split("\n");
-        const patterns = [];
-        let inPatrol = false;
-        let inIgnore = false;
-        for (const line of lines) {
-            const trimmed = line.trimEnd();
-            if (/^patrol:\s*$/.test(trimmed)) {
-                inPatrol = true;
-                continue;
-            }
-            // Another top-level section ends patrol
-            if (inPatrol && /^\S/.test(trimmed) && !trimmed.startsWith("#")) {
-                inPatrol = false;
-                inIgnore = false;
-                continue;
-            }
-            if (!inPatrol)
-                continue;
-            if (trimmed === "" || trimmed.trim().startsWith("#"))
-                continue;
-            if (/^ {2}ignore:\s*$/.test(trimmed)) {
-                inIgnore = true;
-                continue;
-            }
-            // Another patrol sub-key ends ignore
-            if (inIgnore && /^ {2}\S/.test(trimmed) && !/^ {2}ignore:/.test(trimmed)) {
-                inIgnore = false;
-                continue;
-            }
-            if (!inIgnore)
-                continue;
-            // List item: "    - pattern"
-            const itemMatch = trimmed.match(/^ {4}-\s+"?([^"]+)"?\s*$/);
-            if (itemMatch) {
-                patterns.push(itemMatch[1].trim());
-            }
-        }
-        return patterns;
-    }
-    catch {
-        return [];
-    }
-}
 export function getRuleLevel(config, rule, defaultLevel) {
     const entry = config[rule];
     if (!entry)