@oh-my-pi/pi-coding-agent 11.10.0 → 11.10.2

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 ## [Unreleased]
 
+## [11.10.2] - 2026-02-10
+
+### Added
+
+- Exported `streamHashLinesFromUtf8` and `streamHashLinesFromLines` functions for streaming hashline-formatted output with configurable chunking
+- Added `HashlineStreamOptions` interface to control streaming behavior (startLine, maxChunkLines, maxChunkBytes)
+- Added `streamHashLinesFromUtf8` function to incrementally format content with hash lines from a UTF-8 byte stream
+- Added `streamHashLinesFromLines` function to incrementally format content with hash lines from an iterable of lines
+
+### Changed
+
+- Updated hashline format to use 2-character hex hashes instead of 4-character hashes for more compact line references
+- Modified `computeLineHash` to normalize whitespace in line content and removed line number from hash seed for consistency
+- Improved CLI argument parsing to explicitly handle `--help`, `--version`, and subcommand detection instead of prefix-based routing
+
+### Removed
+
+- Removed `@types/diff` dev dependency
+- Removed AggregateError unwrapping from console.warn in CLI initialization
+
+## [11.10.1] - 2026-02-10
+### Changed
+
+- Migrated CLI framework from oclif to lightweight pi-utils CLI runner
+- Replaced oclif command registration with explicit command entries in cli.ts
+- Changed default root command name from 'index' to 'launch'
+- Updated all command imports to use @oh-my-pi/pi-utils/cli instead of @oclif/core
+
+### Removed
+
+- Removed @oclif/core and @oclif/plugin-autocomplete dependencies
+- Removed oclif configuration from package.json
+- Removed custom oclif help renderer (oclif-help.ts)
+
 ## [11.10.0] - 2026-02-10
 ### Breaking Changes
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "11.10.0",
+	"version": "11.10.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -10,14 +10,6 @@
 	"bin": {
 		"omp": "src/cli.ts"
 	},
-	"oclif": {
-		"bin": "omp",
-		"commands": "./src/commands",
-		"helpClass": "./src/cli/oclif-help.ts",
-		"plugins": [
-			"@oclif/plugin-autocomplete"
-		]
-	},
 	"main": "./src/index.ts",
 	"types": "./src/index.ts",
 	"exports": {
@@ -88,14 +80,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "0.6.0",
-		"@oclif/core": "^4.8.0",
-		"@oclif/plugin-autocomplete": "^3.2.40",
-		"@oh-my-pi/omp-stats": "11.10.0",
-		"@oh-my-pi/pi-agent-core": "11.10.0",
-		"@oh-my-pi/pi-ai": "11.10.0",
-		"@oh-my-pi/pi-natives": "11.10.0",
-		"@oh-my-pi/pi-tui": "11.10.0",
-		"@oh-my-pi/pi-utils": "11.10.0",
+		"@oh-my-pi/omp-stats": "11.10.2",
+		"@oh-my-pi/pi-agent-core": "11.10.2",
+		"@oh-my-pi/pi-ai": "11.10.2",
+		"@oh-my-pi/pi-natives": "11.10.2",
+		"@oh-my-pi/pi-tui": "11.10.2",
+		"@oh-my-pi/pi-utils": "11.10.2",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",
 		"chalk": "^5.6.2",
@@ -112,7 +102,6 @@
 		"zod": "^4.3.6"
 	},
 	"devDependencies": {
-		"@types/diff": "^7.0.2",
 		"@types/ms": "^2.1.0",
 		"@types/bun": "^1.3.8",
 		"ms": "^2.1.3",

package/src/cli.ts

@@ -1,32 +1,58 @@
 #!/usr/bin/env bun
 /**
- * CLI entry point for the refactored coding agent.
- * Uses main.ts with AgentSession and new mode modules.
- *
- * Test with: npx tsx src/cli-new.ts [args...]
+ * CLI entry point — registers all commands explicitly and delegates to the
+ * lightweight CLI runner from pi-utils.
  */
-import { run } from "@oclif/core";
-import { APP_NAME } from "./config";
+import { type CommandEntry, run } from "@oh-my-pi/pi-utils/cli";
+import { APP_NAME, VERSION } from "./config";
 
-// oclif's warn() doesn't unwrap AggregateError — override to surface the real messages
-const originalWarn = console.warn;
-console.warn = (...args: unknown[]) => {
-	for (const arg of args) {
-		if (arg instanceof AggregateError) {
-			for (const err of arg.errors) {
-				originalWarn(err instanceof Error ? (err.stack ?? err.message) : String(err));
-			}
-			return;
-		}
+process.title = APP_NAME;
+
+const commands: CommandEntry[] = [
+	{ name: "launch", load: () => import("./commands/launch").then(m => m.default) },
+	{ name: "commit", load: () => import("./commands/commit").then(m => m.default) },
+	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
+	{ name: "grep", load: () => import("./commands/grep").then(m => m.default) },
+	{ name: "jupyter", load: () => import("./commands/jupyter").then(m => m.default) },
+	{ name: "plugin", load: () => import("./commands/plugin").then(m => m.default) },
+	{ name: "setup", load: () => import("./commands/setup").then(m => m.default) },
+	{ name: "shell", load: () => import("./commands/shell").then(m => m.default) },
+	{ name: "stats", load: () => import("./commands/stats").then(m => m.default) },
+	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
+	{ name: "search", load: () => import("./commands/web-search").then(m => m.default), aliases: ["q"] },
+];
+
+async function showHelp(config: import("@oh-my-pi/pi-utils/cli").CliConfig): Promise<void> {
+	const { renderRootHelp } = await import("@oh-my-pi/pi-utils/cli");
+	const { getExtraHelpText } = await import("./cli/args");
+	renderRootHelp(config);
+	const extra = getExtraHelpText();
+	if (extra.trim().length > 0) {
+		process.stdout.write(`\n${extra}\n`);
 	}
-	originalWarn(...args);
-};
+}
 
-process.title = APP_NAME;
-const argv = process.argv.slice(2);
-const runArgv = argv.length === 0 || argv[0]?.startsWith("-") ? ["index", ...argv] : argv;
-run(runArgv, import.meta.url).catch((error: unknown) => {
-	const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
-	process.stderr.write(`${message}\n`);
-	process.exit(1);
-});
+/**
+ * Determine whether argv[0] is a known subcommand name.
+ * If not, the entire argv is treated as args to the default "launch" command.
+ */
+function isSubcommand(first: string | undefined): boolean {
+	if (!first || first.startsWith("-") || first.startsWith("@")) return false;
+	return commands.some(e => e.name === first || e.aliases?.includes(first));
+}
+
+/** Run the CLI with the given argv (no `process.argv` prefix). */
+export function runCli(argv: string[]): Promise<void> {
+	// --help and --version are handled by run() directly, don't rewrite those.
+	// Everything else that isn't a known subcommand routes to "launch".
+	const first = argv[0];
+	const runArgv =
+		first === "--help" || first === "-h" || first === "--version" || first === "-v" || first === "help"
+			? argv
+			: isSubcommand(first)
+				? argv
+				: ["launch", ...argv];
+	return run({ bin: APP_NAME, version: VERSION, argv: runArgv, commands, help: showHelp });
+}
+
+await runCli(process.argv.slice(2));

package/src/commands/commit.ts

@@ -1,7 +1,7 @@
 /**
  * Generate and optionally push a commit with changelog updates.
  */
-import { Command, Flags } from "@oclif/core";
+import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { runCommitCommand } from "../commit";
 import type { CommitCommandArgs } from "../commit/types";
 import { initTheme } from "../modes/theme/theme";

package/src/commands/config.ts

@@ -1,7 +1,7 @@
 /**
  * Manage configuration settings.
  */
-import { Args, Command, Flags } from "@oclif/core";
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { type ConfigAction, type ConfigCommandArgs, runConfigCommand } from "../cli/config-cli";
 import { initTheme } from "../modes/theme/theme";
 

package/src/commands/grep.ts

@@ -1,7 +1,7 @@
 /**
  * Test grep tool.
  */
-import { Args, Command, Flags } from "@oclif/core";
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { type GrepCommandArgs, runGrepCommand } from "../cli/grep-cli";
 import { initTheme } from "../modes/theme/theme";
 

package/src/commands/jupyter.ts

@@ -1,7 +1,7 @@
 /**
  * Manage the shared Jupyter gateway.
  */
-import { Args, Command } from "@oclif/core";
+import { Args, Command } from "@oh-my-pi/pi-utils/cli";
 import { type JupyterAction, type JupyterCommandArgs, runJupyterCommand } from "../cli/jupyter-cli";
 import { initTheme } from "../modes/theme/theme";
 

package/src/commands/{index/index.ts → launch.ts}

@@ -1,10 +1,10 @@
 /**
  * Root command for the coding agent CLI.
  */
-import { Args, Command, Flags } from "@oclif/core";
-import { parseArgs } from "../../cli/args";
-import { APP_NAME } from "../../config";
-import { runRootCommand } from "../../main";
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { parseArgs } from "../cli/args";
+import { APP_NAME } from "../config";
+import { runRootCommand } from "../main";
 
 export default class Index extends Command {
 	static description = "AI coding assistant";

package/src/commands/plugin.ts

@@ -1,7 +1,7 @@
 /**
  * Manage plugins (install, uninstall, list, etc.).
  */
-import { Args, Command, Flags } from "@oclif/core";
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { type PluginAction, type PluginCommandArgs, runPluginCommand } from "../cli/plugin-cli";
 import { initTheme } from "../modes/theme/theme";
 

package/src/commands/setup.ts

@@ -1,7 +1,7 @@
 /**
  * Install dependencies for optional features.
  */
-import { Args, Command, Flags } from "@oclif/core";
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { runSetupCommand, type SetupCommandArgs, type SetupComponent } from "../cli/setup-cli";
 import { initTheme } from "../modes/theme/theme";
 

package/src/commands/shell.ts

@@ -1,7 +1,7 @@
 /**
  * Interactive shell console.
  */
-import { Command, Flags } from "@oclif/core";
+import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { runShellCommand, type ShellCommandArgs } from "../cli/shell-cli";
 import { initTheme } from "../modes/theme/theme";
 

package/src/commands/stats.ts

@@ -1,7 +1,7 @@
 /**
  * View usage statistics dashboard.
  */
-import { Command, Flags } from "@oclif/core";
+import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { runStatsCommand, type StatsCommandArgs } from "../cli/stats-cli";
 import { initTheme } from "../modes/theme/theme";
 
@@ -10,8 +10,8 @@ export default class Stats extends Command {
 
 	static flags = {
 		port: Flags.integer({ char: "p", description: "Port for the dashboard server", default: 3847 }),
-		json: Flags.boolean({ char: "j", description: "Output stats as JSON" }),
-		summary: Flags.boolean({ char: "s", description: "Print summary to console" }),
+		json: Flags.boolean({ char: "j", description: "Output stats as JSON", default: false }),
+		summary: Flags.boolean({ char: "s", description: "Print summary to console", default: false }),
 	};
 
 	async run(): Promise<void> {

package/src/commands/update.ts

@@ -1,7 +1,7 @@
 /**
  * Check for and install updates.
  */
-import { Command, Flags } from "@oclif/core";
+import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { runUpdateCommand } from "../cli/update-cli";
 import { initTheme } from "../modes/theme/theme";
 
@@ -9,8 +9,8 @@ export default class Update extends Command {
 	static description = "Check for and install updates";
 
 	static flags = {
-		force: Flags.boolean({ char: "f", description: "Force update" }),
-		check: Flags.boolean({ char: "c", description: "Check for updates without installing" }),
+		force: Flags.boolean({ char: "f", description: "Force update", default: false }),
+		check: Flags.boolean({ char: "c", description: "Check for updates without installing", default: false }),
 	};
 
 	async run(): Promise<void> {

package/src/commands/web-search.ts

@@ -1,7 +1,7 @@
 /**
  * Test web search providers.
  */
-import { Args, Command, Flags } from "@oclif/core";
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { runSearchCommand, type SearchCommandArgs } from "../cli/web-search-cli";
 import type { SearchProviderId } from "../web/search/types";
 

package/src/main.ts

@@ -8,7 +8,6 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { createInterface } from "node:readline/promises";
-import { run } from "@oclif/core";
 import { type ImageContent, supportsXhigh } from "@oh-my-pi/pi-ai";
 import { $env, postmortem } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
@@ -713,6 +712,6 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 }
 
 export async function main(args: string[]): Promise<void> {
-	const argv = args.length === 0 ? ["index"] : args;
-	await run(argv, import.meta.url);
+	const { runCli } = await import("./cli");
+	await runCli(args.length === 0 ? ["launch"] : args);
 }

package/src/patch/hashline.ts

@@ -1,15 +1,15 @@
 /**
  * Hashline edit mode — a line-addressable edit format using content hashes.
  *
- * Each line in a file is identified by its 1-indexed line number and a 4-character
- * hex hash derived from the line content and the line number (xxHash64 with the
- * line number as seed, truncated to 4 hex chars).
+ * Each line in a file is identified by its 1-indexed line number and a short
+ * hex hash derived from the normalized line content (xxHash64, truncated to 2
+ * hex chars).
  * The combined `LINE:HASH` reference acts as both an address and a staleness check:
  * if the file has changed since the caller last read it, hash mismatches are caught
  * before any mutation occurs.
  *
  * Displayed format: `LINENUM:HASH| CONTENT`
- * Reference format: `"LINENUM:HASH"` (e.g. `"5:a3f2"`)
+ * Reference format: `"LINENUM:HASH"` (e.g. `"5:a3"`)
  */
 
 import type { HashlineEdit, HashMismatch, SrcSpec } from "./types";
@@ -305,11 +305,11 @@ const HASH_MASK = BigInt((1 << (HASH_LEN * 4)) - 1);
 const HEX_DICT = Array.from({ length: Number(HASH_MASK) + 1 }, (_, i) => i.toString(16).padStart(HASH_LEN, "0"));
 
 /**
- * Compute the 4-character hex hash of a single line.
+ * Compute a short hex hash of a single line.
  *
- * Uses xxHash64 truncated to the first 4 hex characters.
- * The line number is included as a seed so the same content on different lines
- * produces different hashes.
+ * Uses xxHash64 on a whitespace-normalized line, truncated to {@link HASH_LEN}
+ * hex characters. The `idx` parameter is accepted for compatibility with older
+ * call sites, but is not currently mixed into the hash.
  * The line input should not include a trailing newline.
  */
 export function computeLineHash(idx: number, line: string): string {
@@ -333,7 +333,7 @@ export function computeLineHash(idx: number, line: string): string {
  * @example
  * ```
  * formatHashLines("function hi() {\n  return;\n}")
- * // "1:a3f2| function hi() {\n2:b1c0|   return;\n3:de45| }"
+ * // "1:HH| function hi() {\n2:HH|   return;\n3:HH| }"
  * ```
  */
 export function formatHashLines(content: string, startLine = 1): string {
@@ -347,6 +347,218 @@ export function formatHashLines(content: string, startLine = 1): string {
 		.join("\n");
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Hashline streaming formatter
+// ═══════════════════════════════════════════════════════════════════════════
+
+export interface HashlineStreamOptions {
+	/** First line number to use when formatting (1-indexed). */
+	startLine?: number;
+	/** Maximum formatted lines per yielded chunk (default: 200). */
+	maxChunkLines?: number;
+	/** Maximum UTF-8 bytes per yielded chunk (default: 64 KiB). */
+	maxChunkBytes?: number;
+}
+
+function isReadableStream(value: unknown): value is ReadableStream<Uint8Array> {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		"getReader" in value &&
+		typeof (value as { getReader?: unknown }).getReader === "function"
+	);
+}
+
+async function* bytesFromReadableStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<Uint8Array> {
+	const reader = stream.getReader();
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) return;
+			if (value) yield value;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+
+/**
+ * Stream hashline-formatted output from a UTF-8 byte source.
+ *
+ * This is intended for large files where callers want incremental output
+ * (e.g. while reading from a file handle) rather than allocating a single
+ * large string.
+ */
+export async function* streamHashLinesFromUtf8(
+	source: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>,
+	options: HashlineStreamOptions = {},
+): AsyncGenerator<string> {
+	const startLine = options.startLine ?? 1;
+	const maxChunkLines = options.maxChunkLines ?? 200;
+	const maxChunkBytes = options.maxChunkBytes ?? 64 * 1024;
+	const decoder = new TextDecoder("utf-8");
+	const chunks = isReadableStream(source) ? bytesFromReadableStream(source) : source;
+	let lineNum = startLine;
+	let pending = "";
+	let sawAnyText = false;
+	let endedWithNewline = false;
+	let outLines: string[] = [];
+	let outBytes = 0;
+
+	const flush = (): string | undefined => {
+		if (outLines.length === 0) return undefined;
+		const chunk = outLines.join("\n");
+		outLines = [];
+		outBytes = 0;
+		return chunk;
+	};
+
+	const pushLine = (line: string): string[] => {
+		const formatted = `${lineNum}:${computeLineHash(lineNum, line)}| ${line}`;
+		lineNum++;
+
+		const chunksToYield: string[] = [];
+		const sepBytes = outLines.length === 0 ? 0 : 1; // "\n"
+		const lineBytes = Buffer.byteLength(formatted, "utf-8");
+
+		if (
+			outLines.length > 0 &&
+			(outLines.length >= maxChunkLines || outBytes + sepBytes + lineBytes > maxChunkBytes)
+		) {
+			const flushed = flush();
+			if (flushed) chunksToYield.push(flushed);
+		}
+
+		outLines.push(formatted);
+		outBytes += (outLines.length === 1 ? 0 : 1) + lineBytes;
+
+		if (outLines.length >= maxChunkLines || outBytes >= maxChunkBytes) {
+			const flushed = flush();
+			if (flushed) chunksToYield.push(flushed);
+		}
+
+		return chunksToYield;
+	};
+
+	const consumeText = (text: string): string[] => {
+		if (text.length === 0) return [];
+		sawAnyText = true;
+		pending += text;
+		const chunksToYield: string[] = [];
+		while (true) {
+			const idx = pending.indexOf("\n");
+			if (idx === -1) break;
+			const line = pending.slice(0, idx);
+			pending = pending.slice(idx + 1);
+			endedWithNewline = true;
+			chunksToYield.push(...pushLine(line));
+		}
+		if (pending.length > 0) endedWithNewline = false;
+		return chunksToYield;
+	};
+	for await (const chunk of chunks) {
+		for (const out of consumeText(decoder.decode(chunk, { stream: true }))) {
+			yield out;
+		}
+	}
+
+	for (const out of consumeText(decoder.decode())) {
+		yield out;
+	}
+	if (!sawAnyText) {
+		// Mirror `"".split("\n")` behavior: one empty line.
+		for (const out of pushLine("")) {
+			yield out;
+		}
+	} else if (pending.length > 0 || endedWithNewline) {
+		// Emit the final line (may be empty if the file ended with a newline).
+		for (const out of pushLine(pending)) {
+			yield out;
+		}
+	}
+
+	const last = flush();
+	if (last) yield last;
+}
+
+/**
+ * Stream hashline-formatted output from an (async) iterable of lines.
+ *
+ * Each yielded chunk is a `\n`-joined string of one or more formatted lines.
+ */
+export async function* streamHashLinesFromLines(
+	lines: Iterable<string> | AsyncIterable<string>,
+	options: HashlineStreamOptions = {},
+): AsyncGenerator<string> {
+	const startLine = options.startLine ?? 1;
+	const maxChunkLines = options.maxChunkLines ?? 200;
+	const maxChunkBytes = options.maxChunkBytes ?? 64 * 1024;
+
+	let lineNum = startLine;
+	let outLines: string[] = [];
+	let outBytes = 0;
+	let sawAnyLine = false;
+	const flush = (): string | undefined => {
+		if (outLines.length === 0) return undefined;
+		const chunk = outLines.join("\n");
+		outLines = [];
+		outBytes = 0;
+		return chunk;
+	};
+
+	const pushLine = (line: string): string[] => {
+		sawAnyLine = true;
+		const formatted = `${lineNum}:${computeLineHash(lineNum, line)}| ${line}`;
+		lineNum++;
+
+		const chunksToYield: string[] = [];
+		const sepBytes = outLines.length === 0 ? 0 : 1;
+		const lineBytes = Buffer.byteLength(formatted, "utf-8");
+
+		if (
+			outLines.length > 0 &&
+			(outLines.length >= maxChunkLines || outBytes + sepBytes + lineBytes > maxChunkBytes)
+		) {
+			const flushed = flush();
+			if (flushed) chunksToYield.push(flushed);
+		}
+
+		outLines.push(formatted);
+		outBytes += (outLines.length === 1 ? 0 : 1) + lineBytes;
+
+		if (outLines.length >= maxChunkLines || outBytes >= maxChunkBytes) {
+			const flushed = flush();
+			if (flushed) chunksToYield.push(flushed);
+		}
+
+		return chunksToYield;
+	};
+
+	const asyncIterator = (lines as AsyncIterable<string>)[Symbol.asyncIterator];
+	if (typeof asyncIterator === "function") {
+		for await (const line of lines as AsyncIterable<string>) {
+			for (const out of pushLine(line)) {
+				yield out;
+			}
+		}
+	} else {
+		for (const line of lines as Iterable<string>) {
+			for (const out of pushLine(line)) {
+				yield out;
+			}
+		}
+	}
+	if (!sawAnyLine) {
+		// Mirror `"".split("\n")` behavior: one empty line.
+		for (const out of pushLine("")) {
+			yield out;
+		}
+	}
+
+	const last = flush();
+	if (last) yield last;
+}
+
 /**
  * Parse a line reference string like `"5:abcd"` into structured form.
  *
@@ -360,7 +572,7 @@ export function parseLineRef(ref: string): { line: number; hash: string } {
 	const prefixMatch = strictMatch ? null : cleaned.match(new RegExp(`^(\\d+):([0-9a-fA-F]{${HASH_LEN}})`));
 	const match = strictMatch ?? prefixMatch;
 	if (!match) {
-		throw new Error(`Invalid line reference "${ref}". Expected format "LINE:HASH" (e.g. "5:a3f2").`);
+		throw new Error(`Invalid line reference "${ref}". Expected format "LINE:HASH" (e.g. "5:aa").`);
 	}
 	const line = Number.parseInt(match[1], 10);
 	if (line < 1) {

package/src/patch/index.ts

@@ -55,6 +55,8 @@ export {
 	formatHashLines,
 	HashlineMismatchError,
 	parseLineRef,
+	streamHashLinesFromLines,
+	streamHashLinesFromUtf8,
 	validateLineRef,
 } from "./hashline";
 // Normalization

package/src/cli/oclif-help.ts

@@ -1,26 +0,0 @@
-/**
- * Custom help renderer for the coding agent CLI.
- */
-import { CommandHelp, Help } from "@oclif/core";
-import { getExtraHelpText } from "./args";
-
-export default class OclifHelp extends Help {
-	async showRootHelp(): Promise<void> {
-		await super.showRootHelp();
-		const rootCommand = this.config.findCommand("index");
-		if (rootCommand) {
-			const rootHelp = new CommandHelp(rootCommand, this.config, {
-				...this.opts,
-				sections: ["arguments", "flags", "examples"],
-			});
-			const output = rootHelp.generate();
-			if (output.trim().length > 0) {
-				process.stdout.write(`\n${output}\n`);
-			}
-		}
-		const extra = getExtraHelpText();
-		if (extra.trim().length > 0) {
-			process.stdout.write(`\n${extra}\n`);
-		}
-	}
-}