Add cli package to monorepo

Add codeforge-cli v0.1.0 (Bun/TypeScript) — a CLI for CodeForge
development workflows including session search, plan management,
and task tracking. The docs package was already tracked from the
previous repository structure.

Author: AnExiledDev

cli/bun.lock

@@ -0,0 +1,29 @@
+{
+	"name": "codeforge-cli",
+	"version": "0.1.0",
+	"description": "CLI for CodeForge development workflows",
+	"type": "module",
+	"bin": {
+		"codeforge": "./dist/codeforge.js"
+	},
+	"scripts": {
+		"build": "bun build src/index.ts --outdir dist --target bun",
+		"dev": "bun run src/index.ts",
+		"test": "bun test"
+	},
+	"dependencies": {
+		"commander": "^13.0.0",
+		"chalk": "^5.4.0",
+		"fast-glob": "^3.3.0"
+	},
+	"devDependencies": {
+		"@types/bun": "^1.3.10",
+		"@types/node": "^22.0.0",
+		"typescript": "^5.7.0"
+	},
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"license": "GPL-3.0",
+	"author": "AnExiledDev"
+}

cli/package.json

@@ -0,0 +1,107 @@
+import chalk from "chalk";
+import type { Command } from "commander";
+import { loadPlans } from "../../loaders/plan-loader.js";
+import {
+	formatPlanJson,
+	formatPlanText,
+	type PlanSearchResult,
+} from "../../output/plan-text.js";
+import { evaluate, parse } from "../../search/query-parser.js";
+
+interface PlanSearchOptions {
+	limit: string;
+	format: string;
+	color?: boolean;
+	fullText?: boolean;
+}
+
+function extractContextLines(content: string, query: string): string[] {
+	const contentLines = content.split("\n");
+	// Extract individual terms from the query (simple word extraction)
+	const terms = query
+		.replace(/\b(AND|OR|NOT)\b/gi, "")
+		.replace(/[()]/g, "")
+		.split(/\s+/)
+		.filter((t) => t.length > 0)
+		.map((t) => t.replace(/^["']|["']$/g, "").toLowerCase());
+
+	if (terms.length === 0) return [];
+
+	const matchingIndices = new Set<number>();
+
+	for (let i = 0; i < contentLines.length; i++) {
+		const lower = contentLines[i].toLowerCase();
+		for (const term of terms) {
+			if (lower.includes(term)) {
+				matchingIndices.add(i);
+				break;
+			}
+		}
+	}
+
+	// Add context lines (+/- 1 line)
+	const contextIndices = new Set<number>();
+	for (const idx of matchingIndices) {
+		if (idx > 0) contextIndices.add(idx - 1);
+		contextIndices.add(idx);
+		if (idx < contentLines.length - 1) contextIndices.add(idx + 1);
+	}
+
+	// Sort and deduplicate, cap at 5
+	const sorted = [...contextIndices].sort((a, b) => a - b).slice(0, 5);
+	return sorted.map((i) => contentLines[i]);
+}
+
+export function registerPlanSearchCommand(parent: Command): void {
+	parent
+		.command("search")
+		.description("Search across plan files")
+		.argument("[query]", "Search query (supports AND, OR, NOT, quotes)")
+		.option("-n, --limit <count>", "Maximum number of results", "20")
+		.option("-f, --format <format>", "Output format: text|json", "text")
+		.option("--no-color", "Disable colored output")
+		.option("--full-text", "Disable content truncation")
+		.action(async (query: string | undefined, options: PlanSearchOptions) => {
+			try {
+				if (!options.color) {
+					chalk.level = 0;
+				}
+
+				const plans = await loadPlans();
+
+				let results: PlanSearchResult[];
+
+				if (query) {
+					const queryNode = parse(query);
+					results = [];
+					for (const plan of plans) {
+						if (evaluate(queryNode, plan.content)) {
+							const matchingLines = extractContextLines(plan.content, query);
+							results.push({ plan, matchingLines });
+						}
+					}
+				} else {
+					results = plans.map((plan) => ({ plan }));
+				}
+
+				// Apply limit
+				const limit = parseInt(options.limit, 10);
+				results = results.slice(0, limit);
+
+				if (options.format === "json") {
+					console.log(formatPlanJson(results));
+				} else {
+					console.log(
+						formatPlanText(results, {
+							noColor: !options.color,
+							fullText: options.fullText,
+						}),
+					);
+				}
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				console.error(`Error: ${message}`);
+				process.exit(1);
+			}
+		});
+}

cli/src/commands/plan/search.ts

@@ -0,0 +1,96 @@
+import chalk from "chalk";
+import type { Command } from "commander";
+import { loadHistory } from "../../loaders/history-loader.js";
+import { extractSessionMeta } from "../../loaders/session-meta.js";
+import {
+	formatSessionListJson,
+	formatSessionListText,
+	type SessionListEntry,
+} from "../../output/session-list.js";
+import { discoverSessionFiles } from "../../utils/glob.js";
+import { parseRelativeTime, parseTime } from "../../utils/time.js";
+
+interface ListCommandOptions {
+	project?: string;
+	since?: string;
+	after?: string;
+	before?: string;
+	limit: string;
+	format: string;
+	color?: boolean;
+}
+
+export function registerListCommand(parent: Command): void {
+	parent
+		.command("list")
+		.description("List previous Claude Code sessions")
+		.option("--project <path>", "Project directory filter")
+		.option("--since <time>", 'Relative time filter (e.g. "1 day ago")')
+		.option("--after <timestamp>", "Show sessions after this timestamp")
+		.option("--before <timestamp>", "Show sessions before this timestamp")
+		.option("-n, --limit <count>", "Maximum number of results", "20")
+		.option("-f, --format <format>", "Output format: text|json", "text")
+		.option("--no-color", "Disable colored output")
+		.action(async (options: ListCommandOptions) => {
+			try {
+				if (!options.color) {
+					chalk.level = 0;
+				}
+
+				const after = options.since
+					? parseRelativeTime(options.since)
+					: options.after
+						? parseTime(options.after)
+						: undefined;
+
+				const before = options.before ? parseTime(options.before) : undefined;
+
+				const summaries = await loadHistory({
+					project: options.project,
+					after: after ?? undefined,
+					before: before ?? undefined,
+					limit: parseInt(options.limit, 10),
+				});
+
+				// Discover session files for enrichment
+				const sessionFiles = await discoverSessionFiles();
+				const filesBySessionId = new Map<string, string>();
+				for (const filePath of sessionFiles) {
+					// Extract session ID from filename (basename without extension)
+					const parts = filePath.split("/");
+					const filename = parts[parts.length - 1];
+					const id = filename.replace(/\.jsonl$/, "");
+					filesBySessionId.set(id, filePath);
+				}
+
+				// Enrich summaries with session metadata
+				const entries: SessionListEntry[] = [];
+				for (const summary of summaries) {
+					const filePath = filesBySessionId.get(summary.sessionId);
+					let meta;
+					if (filePath) {
+						try {
+							meta = await extractSessionMeta(filePath);
+						} catch {
+							// Skip enrichment on error
+						}
+					}
+					entries.push({ summary, meta });
+				}
+
+				if (options.format === "json") {
+					console.log(formatSessionListJson(entries));
+				} else {
+					console.log(
+						formatSessionListText(entries, {
+							noColor: !options.color,
+						}),
+					);
+				}
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				console.error(`Error: ${message}`);
+				process.exit(1);
+			}
+		});
+}

cli/src/commands/session/list.ts

@@ -0,0 +1,86 @@
+import chalk from "chalk";
+import type { Command } from "commander";
+import { formatJson } from "../../output/json.js";
+import { formatStats } from "../../output/stats.js";
+import { formatText } from "../../output/text.js";
+import { search } from "../../search/engine.js";
+import { parseRelativeTime, parseTime } from "../../utils/time.js";
+
+interface SearchCommandOptions {
+	role?: string;
+	limit: string;
+	project?: string;
+	since?: string;
+	after?: string;
+	before?: string;
+	session?: string;
+	format: string;
+	stats?: boolean;
+	color?: boolean;
+	fullText?: boolean;
+	pattern?: string;
+}
+
+export function registerSearchCommand(parent: Command): void {
+	parent
+		.command("search")
+		.description("Search Claude Code session history")
+		.argument("[query]", "Search query (supports AND, OR, NOT, quotes)")
+		.option("-r, --role <role>", "Filter by role (user/assistant/system)")
+		.option("-n, --limit <count>", "Maximum number of results", "200")
+		.option("--project <path>", "Project directory filter")
+		.option("--since <time>", 'Relative time filter (e.g. "1 day ago")')
+		.option("--after <timestamp>", "Show messages after this timestamp")
+		.option("--before <timestamp>", "Show messages before this timestamp")
+		.option("-s, --session <id>", "Filter by session ID")
+		.option("-f, --format <format>", "Output format: text|json", "text")
+		.option("--stats", "Show statistics only")
+		.option("--no-color", "Disable colored output")
+		.option("--full-text", "Disable content truncation")
+		.option("-p, --pattern <glob>", "Custom file glob pattern")
+		.action(
+			async (query: string | undefined, options: SearchCommandOptions) => {
+				try {
+					if (!options.color) {
+						chalk.level = 0;
+					}
+
+					const after = options.since
+						? parseRelativeTime(options.since)
+						: options.after
+							? parseTime(options.after)
+							: undefined;
+
+					const before = options.before ? parseTime(options.before) : undefined;
+
+					const result = await search({
+						query: query ?? "",
+						role: options.role,
+						limit: parseInt(options.limit, 10),
+						project: options.project,
+						after: after?.toISOString(),
+						before: before?.toISOString(),
+						sessionId: options.session,
+						pattern: options.pattern,
+					});
+
+					if (options.stats) {
+						console.log(formatStats(result, { noColor: !options.color }));
+					} else if (options.format === "json") {
+						console.log(formatJson(result));
+					} else {
+						console.log(
+							formatText(result, {
+								fullText: options.fullText,
+								noColor: !options.color,
+							}),
+						);
+					}
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					console.error(`Error: ${message}`);
+					process.exit(1);
+				}
+			},
+		);
+}