complexity-cli 1.0.0 → 1.1.0

package/README.md

@@ -1,25 +1,29 @@
 # complexity-cli
 
+[![npm package](https://img.shields.io/npm/v/complexity-cli.svg)](https://www.npmjs.com/package/complexity-cli)
+
 A CLI tool for managing project complexity and knowledge maps. Perfect for
 tracking what developers need to know to work on your project, with AI-friendly
 workflows.
 
 ## Installation
 
+```bash
+npm install -g complexity-cli
+```
+
 ### Local Development
 
+If you want to contribute or develop locally:
+
 ```bash
+git clone https://github.com/SamBWagner/complexity-cli.git
+cd complexity-cli
 npm install
 npm run build
 npm link
 ```
 
-### From npm (Coming Soon)
-
-```bash
-npm install -g complexity-cli
-```
-
 ## Usage
 
 ### Initialize a Complexity Map
@@ -112,6 +116,10 @@ This outputs a comprehensive prompt that instructs an AI to:
 - Use the `complexity` CLI to maintain consistency
 - Consider all relevant technologies and concepts
 
+> Note: I really recommend using a larger, thinking AI model like Claude Opus or
+> GPT 5.x. This tool's duty isn't the analysis of the project. But, rather the
+> maintenance of a simple markdown document. Bigger model, better time.
+
 ## Features
 
 - **Simple CLI**: Easy-to-use commands for managing complexity documentation

package/dist/index.js

@@ -1,48 +1,489 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-const init_1 = require("./commands/init");
-const add_1 = require("./commands/add");
-const remove_1 = require("./commands/remove");
-const update_1 = require("./commands/update");
-const list_1 = require("./commands/list");
-const prompt_1 = require("./commands/prompt");
-const program = new commander_1.Command();
-program
-    .name('complexity')
-    .description('A CLI tool for managing project complexity and knowledge maps')
-    .version('1.0.0');
-program
-    .command('init')
-    .description('Initialize a COMPLEXITY.md file in the current directory')
-    .option('-n, --name <name>', 'Project name')
-    .option('-f, --force', 'Overwrite existing file')
-    .action(init_1.initCommand);
-program
-    .command('add <concept> [level] [area]')
-    .description('Add a concept to the complexity map')
-    .option('-l, --level <level>', 'Criticality level (1-3)')
-    .action(add_1.addCommand);
-program
-    .command('remove <concept>')
-    .description('Remove a concept from the complexity map')
-    .option('-f, --force', 'Skip confirmation')
-    .action(remove_1.removeCommand);
-program
-    .command('update <concept>')
-    .description('Update an existing concept')
-    .option('-l, --level <level>', 'New criticality level (1-3)')
-    .option('-a, --area <area>', 'New area')
-    .option('-n, --name <name>', 'New concept name')
-    .action(update_1.updateCommand);
-program
-    .command('list')
-    .description('List all concepts in the complexity map')
-    .action(list_1.listCommand);
-program
-    .command('prompt')
-    .description('Display the AI prompt for complexity analysis')
-    .action(prompt_1.promptCommand);
+import { Command } from "commander";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as fs from "fs";
+import * as path$1 from "path";
+import chalk from "chalk";
+import inquirer from "inquirer";
+
+//#region node_modules/tsdown/esm-shims.js
+const getFilename = () => fileURLToPath(import.meta.url);
+const getDirname = () => path.dirname(getFilename());
+const __dirname = /* @__PURE__ */ getDirname();
+
+//#endregion
+//#region src/utils/prompts.ts
+async function confirmAction(message) {
+	const { confirmed } = await inquirer.prompt([{
+		type: "confirm",
+		name: "confirmed",
+		message,
+		default: false
+	}]);
+	return confirmed;
+}
+async function promptForInput(message, defaultValue) {
+	const { value } = await inquirer.prompt([{
+		type: "input",
+		name: "value",
+		message,
+		default: defaultValue,
+		validate: (input) => {
+			if (!input || input.trim() === "") return "This field is required";
+			return true;
+		}
+	}]);
+	return value;
+}
+
+//#endregion
+//#region src/utils/error-helpers.ts
+function exitWithError(message, hint) {
+	console.error(chalk.red(`Error: ${message}`));
+	if (hint) console.error(chalk.yellow(hint));
+	process.exit(1);
+}
+function exitWithUsageError(message, usageExample) {
+	console.error(chalk.red(`Error: ${message}`));
+	console.error(chalk.yellow(`Usage: ${usageExample}`));
+	process.exit(1);
+}
+function exitCancelled() {
+	console.log(chalk.yellow("Cancelled."));
+	process.exit(0);
+}
+
+//#endregion
+//#region src/commands/init.ts
+const TEMPLATE_FILE = path$1.join(__dirname, "../Complexity.template.md");
+const OUTPUT_FILE = "COMPLEXITY.md";
+function getOutputPath() {
+	return path$1.join(process.cwd(), OUTPUT_FILE);
+}
+function validateFileDoesNotExist(outputPath, force) {
+	if (fs.existsSync(outputPath) && !force) exitWithError(`${OUTPUT_FILE} already exists in this directory.`, "Use --force to overwrite it.");
+}
+async function getProjectName(providedName) {
+	if (providedName) return providedName;
+	return promptForInput("Enter project name:", path$1.basename(process.cwd()));
+}
+function readTemplateFile() {
+	if (!fs.existsSync(TEMPLATE_FILE)) exitWithError(`Template file not found at ${TEMPLATE_FILE}`);
+	return fs.readFileSync(TEMPLATE_FILE, "utf-8");
+}
+function initializeTemplateContent(template, projectName) {
+	return template.replace(/\{Project Name\}/g, projectName).replace(/\{X\}/g, "0").replace(/\{Y\}/g, "0").replace(/\{A\}/g, "0").replace(/\{B\}/g, "0").replace(/\{C\}/g, "0");
+}
+async function initCommand(options) {
+	const outputPath = getOutputPath();
+	validateFileDoesNotExist(outputPath, options.force ?? false);
+	const projectName = await getProjectName(options.name);
+	const content = initializeTemplateContent(readTemplateFile(), projectName);
+	fs.writeFileSync(outputPath, content, "utf-8");
+	console.log(chalk.green(`✓ Created ${OUTPUT_FILE} for project: ${projectName}`));
+}
+
+//#endregion
+//#region src/core/parser.ts
+const COMPLEXITY_FILE = "COMPLEXITY.md";
+const BLANK_AREA$2 = "___";
+const DEFAULT_PROJECT_NAME = "Project Name";
+function extractProjectName(lines) {
+	const projectNameLine = lines[3];
+	if (!projectNameLine) return DEFAULT_PROJECT_NAME;
+	const match = projectNameLine.match(/A guide to what you need to know to work on (.+?), broken/);
+	return match ? match[1] : DEFAULT_PROJECT_NAME;
+}
+function findTableStartIndex(lines) {
+	for (let i = 0; i < lines.length; i++) if (lines[i].trim().startsWith("| Topic | Area | Criticality")) return i + 2;
+	return -1;
+}
+function isValidCriticality(criticality) {
+	return !isNaN(criticality) && criticality >= 1 && criticality <= 3;
+}
+function parseTableRow(line) {
+	const parts = line.split("|").map((p) => p.trim()).filter((p) => p);
+	if (parts.length !== 3) return null;
+	const [topic, area, criticalityStr] = parts;
+	if (!topic || topic === "Topic") return null;
+	const criticality = parseInt(criticalityStr);
+	if (!isValidCriticality(criticality)) return null;
+	return {
+		topic,
+		area: area || BLANK_AREA$2,
+		criticality
+	};
+}
+function parseTableRows(lines, startIndex) {
+	if (startIndex === -1) return [];
+	const concepts = [];
+	for (let i = startIndex; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (!line.startsWith("|")) break;
+		const concept = parseTableRow(line);
+		if (concept) concepts.push(concept);
+	}
+	return concepts;
+}
+function parseComplexityFile(filePath) {
+	if (!fs.existsSync(filePath)) throw new Error(`COMPLEXITY.md not found at: ${filePath}`);
+	const lines = fs.readFileSync(filePath, "utf-8").split("\n");
+	return {
+		projectName: extractProjectName(lines),
+		concepts: parseTableRows(lines, findTableStartIndex(lines))
+	};
+}
+function findGitRoot(startDir) {
+	let searchDir = startDir;
+	const filesystemRoot = path$1.parse(searchDir).root;
+	while (searchDir !== filesystemRoot) {
+		if (fs.existsSync(path$1.join(searchDir, ".git"))) return searchDir;
+		searchDir = path$1.dirname(searchDir);
+	}
+	return null;
+}
+function searchUpwardForFile(startDir, filename, stopAtDir) {
+	let currentDir = startDir;
+	while (true) {
+		const filePath = path$1.join(currentDir, filename);
+		if (fs.existsSync(filePath)) return filePath;
+		if (currentDir === stopAtDir) break;
+		const parentDir = path$1.dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	return null;
+}
+function findComplexityFile(startDir = process.cwd()) {
+	const resolvedStartDir = path$1.resolve(startDir);
+	return searchUpwardForFile(resolvedStartDir, COMPLEXITY_FILE, findGitRoot(resolvedStartDir) || path$1.parse(resolvedStartDir).root);
+}
+
+//#endregion
+//#region src/core/generator.ts
+function calculateStats(concepts) {
+	const uniqueAreas = new Set(concepts.map((c) => c.area).filter((a) => a && a !== "___"));
+	return {
+		totalConcepts: concepts.length,
+		totalAreas: uniqueAreas.size,
+		criticalCount: concepts.filter((c) => c.criticality === 3).length,
+		importantCount: concepts.filter((c) => c.criticality === 2).length,
+		situationalCount: concepts.filter((c) => c.criticality === 1).length
+	};
+}
+function sortConcepts(concepts) {
+	return [...concepts].sort((a, b) => {
+		if (a.criticality !== b.criticality) return b.criticality - a.criticality;
+		return a.topic.localeCompare(b.topic);
+	});
+}
+function generateMarkdown(projectName, concepts) {
+	const stats = calculateStats(concepts);
+	const sorted = sortConcepts(concepts);
+	const critical = sorted.filter((c) => c.criticality === 3);
+	const important = sorted.filter((c) => c.criticality === 2);
+	const situational = sorted.filter((c) => c.criticality === 1);
+	const lines = [];
+	lines.push("# Project Complexity & Knowledge Map");
+	lines.push("");
+	lines.push(`<!-- Replace {Project Name} with your project name -->`);
+	lines.push(`A guide to what you need to know to work on ${projectName}, broken into three tiers.`);
+	lines.push("");
+	lines.push(`> **${stats.totalConcepts} technologies/concepts** across ${stats.totalAreas} areas`);
+	lines.push(`> **${stats.criticalCount} critical**`);
+	lines.push(`> **${stats.importantCount} important**`);
+	lines.push(`> **${stats.situationalCount} situational**`);
+	lines.push("");
+	lines.push("---");
+	lines.push("");
+	lines.push("## **What you NEED to know to do any meaningful work**");
+	lines.push("");
+	if (critical.length > 0) critical.forEach((c) => lines.push(`- ${c.topic}`));
+	else lines.push("<!-- Criticality 3 items from the table below -->");
+	lines.push("");
+	lines.push("## **What you SHOULD know to be very helpful**");
+	lines.push("");
+	if (important.length > 0) important.forEach((c) => lines.push(`- ${c.topic}`));
+	else lines.push("<!-- Everything above, plus Criticality 2 items -->");
+	lines.push("");
+	lines.push("## **What you should EVENTUALLY learn for specific areas**");
+	lines.push("");
+	if (situational.length > 0) situational.forEach((c) => lines.push(`- ${c.topic}`));
+	else lines.push("<!-- Criticality 1 items -->");
+	lines.push("");
+	lines.push("---");
+	lines.push("");
+	lines.push("## Full Reference");
+	lines.push("");
+	lines.push("<!--");
+	lines.push("  Criticality scale:");
+	lines.push("    3 = Can't do meaningful work without it");
+	lines.push("    2 = Will encounter regularly; gaps will slow you down");
+	lines.push("    1 = Comes up occasionally or is abstracted away enough to learn on the job");
+	lines.push("-->");
+	lines.push("");
+	lines.push("| Topic | Area | Criticality (1-3) |");
+	lines.push("|---|---|---|");
+	if (sorted.length > 0) sorted.forEach((c) => {
+		lines.push(`| ${c.topic} | ${c.area} | ${c.criticality} |`);
+	});
+	else lines.push("| | | |");
+	lines.push("");
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/core/validator.ts
+function isDuplicate(concept, existingConcepts) {
+	return existingConcepts.some((c) => c.topic.toLowerCase() === concept.toLowerCase());
+}
+function isValidLevel(level) {
+	const num = parseInt(level);
+	return !isNaN(num) && num >= 1 && num <= 3;
+}
+function isExistingArea(area, existingConcepts) {
+	if (!area || area === "___") return true;
+	return existingConcepts.some((c) => c.area.toLowerCase() === area.toLowerCase());
+}
+function findConcept(conceptName, concepts) {
+	return concepts.find((c) => c.topic.toLowerCase() === conceptName.toLowerCase());
+}
+
+//#endregion
+//#region src/commands/add.ts
+const BLANK_AREA$1 = "___";
+function getLevelInput(levelArg, options) {
+	const levelInput = options.level || levelArg;
+	if (!levelInput) exitWithUsageError("Criticality level is required.", "complexity add <concept> <level> [area]\n   or: complexity add <concept> --level <level> [area]");
+	return levelInput;
+}
+function validateLevel(levelInput) {
+	if (!isValidLevel(levelInput)) exitWithError("Level must be 1, 2, or 3.");
+	return parseInt(levelInput);
+}
+function requireComplexityFile$3() {
+	const filePath = findComplexityFile();
+	if (!filePath) exitWithError("COMPLEXITY.md not found.", "Run \"complexity init\" to create one.");
+	return filePath;
+}
+function validateConceptDoesNotExist(concept, existingConcepts) {
+	if (isDuplicate(concept, existingConcepts)) exitWithError(`Concept "${concept}" already exists.`, "Use \"complexity update\" to modify it.");
+}
+async function confirmNewAreaIfNeeded$1(area, existingConcepts) {
+	if (area === BLANK_AREA$1) return;
+	if (isExistingArea(area, existingConcepts)) return;
+	if (!await confirmAction(`No pre-existing area "${area}" found. Would you still like to add it?`)) exitCancelled();
+}
+function createConcept(concept, level, area) {
+	return {
+		topic: concept,
+		area,
+		criticality: level
+	};
+}
+function saveComplexityFile$2(filePath, projectName, concepts) {
+	const markdown = generateMarkdown(projectName, concepts);
+	fs.writeFileSync(filePath, markdown, "utf-8");
+}
+async function addCommand(concept, levelArg, areaArg, options) {
+	const level = validateLevel(getLevelInput(levelArg, options));
+	const area = areaArg || BLANK_AREA$1;
+	const filePath = requireComplexityFile$3();
+	const doc = parseComplexityFile(filePath);
+	validateConceptDoesNotExist(concept, doc.concepts);
+	await confirmNewAreaIfNeeded$1(area, doc.concepts);
+	const newConcept = createConcept(concept, level, area);
+	const updatedConcepts = [...doc.concepts, newConcept];
+	saveComplexityFile$2(filePath, doc.projectName, updatedConcepts);
+	console.log(chalk.green(`✓ Added "${concept}" (Level ${level}, Area: ${area})`));
+}
+
+//#endregion
+//#region src/commands/remove.ts
+function requireComplexityFile$2() {
+	const filePath = findComplexityFile();
+	if (!filePath) exitWithError("COMPLEXITY.md not found.", "Run \"complexity init\" to create one.");
+	return filePath;
+}
+function requireConceptExists$1(conceptName, concepts) {
+	const existing = findConcept(conceptName, concepts);
+	if (!existing) exitWithError(`Concept "${conceptName}" not found.`);
+	return existing;
+}
+async function confirmRemovalIfNeeded(concept, force) {
+	if (force) return;
+	if (!await confirmAction(`Remove "${concept.topic}" (Level ${concept.criticality}, Area: ${concept.area})?`)) exitCancelled();
+}
+function removeConcept(conceptName, concepts) {
+	return concepts.filter((c) => c.topic.toLowerCase() !== conceptName.toLowerCase());
+}
+function saveComplexityFile$1(filePath, projectName, concepts) {
+	const markdown = generateMarkdown(projectName, concepts);
+	fs.writeFileSync(filePath, markdown, "utf-8");
+}
+async function removeCommand(concept, options) {
+	const filePath = requireComplexityFile$2();
+	const doc = parseComplexityFile(filePath);
+	const existing = requireConceptExists$1(concept, doc.concepts);
+	await confirmRemovalIfNeeded(existing, options.force ?? false);
+	const updatedConcepts = removeConcept(concept, doc.concepts);
+	saveComplexityFile$1(filePath, doc.projectName, updatedConcepts);
+	console.log(chalk.green(`✓ Removed "${existing.topic}"`));
+}
+
+//#endregion
+//#region src/commands/update.ts
+const BLANK_AREA = "___";
+function validateAtLeastOneOptionProvided(options) {
+	if (!options.level && !options.area && !options.name) exitWithUsageError("At least one option (--level, --area, or --name) is required.", "complexity update <concept> [--level <level>] [--area <area>] [--name <new-name>]");
+}
+function requireComplexityFile$1() {
+	const filePath = findComplexityFile();
+	if (!filePath) exitWithError("COMPLEXITY.md not found.", "Run \"complexity init\" to create one.");
+	return filePath;
+}
+function requireConceptExists(conceptName, concepts) {
+	const existing = findConcept(conceptName, concepts);
+	if (!existing) exitWithError(`Concept "${conceptName}" not found.`);
+	return existing;
+}
+function validateLevelIfProvided(level) {
+	if (!level) return;
+	if (!isValidLevel(level)) exitWithError("Level must be 1, 2, or 3.");
+}
+async function confirmNewAreaIfNeeded(area, existingConcepts) {
+	if (!area || area === BLANK_AREA) return;
+	if (isExistingArea(area, existingConcepts)) return;
+	if (!await confirmAction(`No pre-existing area "${area}" found. Would you still like to use it?`)) exitCancelled();
+}
+function createUpdatedConcept(existing, options) {
+	return {
+		topic: options.name || existing.topic,
+		area: options.area !== void 0 ? options.area : existing.area,
+		criticality: options.level ? parseInt(options.level) : existing.criticality
+	};
+}
+function replaceConceptInList(conceptName, updatedConcept, concepts) {
+	return concepts.map((c) => c.topic.toLowerCase() === conceptName.toLowerCase() ? updatedConcept : c);
+}
+function saveComplexityFile(filePath, projectName, concepts) {
+	const markdown = generateMarkdown(projectName, concepts);
+	fs.writeFileSync(filePath, markdown, "utf-8");
+}
+function displayUpdateSummary(conceptName, updatedConcept, options) {
+	console.log(chalk.green(`✓ Updated "${conceptName}"`));
+	if (options.name) console.log(chalk.gray(`  → Name: ${updatedConcept.topic}`));
+	if (options.level) console.log(chalk.gray(`  → Level: ${updatedConcept.criticality}`));
+	if (options.area !== void 0) console.log(chalk.gray(`  → Area: ${updatedConcept.area}`));
+}
+async function updateCommand(concept, options) {
+	validateAtLeastOneOptionProvided(options);
+	validateLevelIfProvided(options.level);
+	const filePath = requireComplexityFile$1();
+	const doc = parseComplexityFile(filePath);
+	const existing = requireConceptExists(concept, doc.concepts);
+	await confirmNewAreaIfNeeded(options.area, doc.concepts);
+	const updatedConcept = createUpdatedConcept(existing, options);
+	const updatedConcepts = replaceConceptInList(concept, updatedConcept, doc.concepts);
+	saveComplexityFile(filePath, doc.projectName, updatedConcepts);
+	displayUpdateSummary(concept, updatedConcept, options);
+}
+
+//#endregion
+//#region src/commands/list.ts
+function requireComplexityFile() {
+	const filePath = findComplexityFile();
+	if (!filePath) exitWithError("COMPLEXITY.md not found.", "Run \"complexity init\" to create one.");
+	return filePath;
+}
+function displayEmptyState(filePath) {
+	console.log(chalk.yellow("No concepts found in COMPLEXITY.md"));
+	console.log(chalk.gray(`File location: ${filePath}`));
+}
+function displayHeader(projectName, filePath, totalConcepts) {
+	console.log(chalk.bold(`\nProject: ${projectName}`));
+	console.log(chalk.gray(`File: ${filePath}`));
+	console.log(chalk.gray(`Total concepts: ${totalConcepts}\n`));
+}
+function displayConceptGroup(title, concepts, color) {
+	if (concepts.length === 0) return;
+	console.log(color(title));
+	concepts.forEach((concept) => {
+		console.log(`  ${chalk.bold(concept.topic)} ${chalk.gray(`[${concept.area}]`)}`);
+	});
+	console.log("");
+}
+function groupConceptsByCriticality(concepts) {
+	return {
+		critical: concepts.filter((c) => c.criticality === 3),
+		important: concepts.filter((c) => c.criticality === 2),
+		situational: concepts.filter((c) => c.criticality === 1)
+	};
+}
+function listCommand() {
+	const filePath = requireComplexityFile();
+	const doc = parseComplexityFile(filePath);
+	const sorted = sortConcepts(doc.concepts);
+	if (sorted.length === 0) {
+		displayEmptyState(filePath);
+		return;
+	}
+	displayHeader(doc.projectName, filePath, sorted.length);
+	const groups = groupConceptsByCriticality(sorted);
+	displayConceptGroup("Critical (Level 3):", groups.critical, chalk.red.bold);
+	displayConceptGroup("Important (Level 2):", groups.important, chalk.yellow.bold);
+	displayConceptGroup("Situational (Level 1):", groups.situational, chalk.green.bold);
+}
+
+//#endregion
+//#region src/commands/prompt.ts
+function promptCommand() {
+	const prompt = `
+I'd like you to analyze this project and create a comprehensive complexity map. This map should list everything someone needs to know to take full ownership of this software project.
+
+For each technology, concept, or skill:
+- Rate its criticality from 1-3:
+  * 3 = Can't do meaningful work without it
+  * 2 = Will encounter regularly; gaps will slow you down  
+  * 1 = Comes up occasionally or is abstracted away
+
+- Categorize it by area (e.g., backend, frontend, infrastructure, devops, etc.)
+
+Use the following CLI commands to maintain the COMPLEXITY.md file:
+- \`complexity add <concept> <level> [area]\` - Add a new technology
+- \`complexity update <concept> --level <level> --area <area>\` - Update existing entry
+- \`complexity remove <concept>\` - Remove an entry
+- \`complexity list\` - View current entries
+
+Be thorough and accurate. Consider:
+- Programming languages and frameworks
+- Databases and data stores
+- DevOps and infrastructure tools
+- Testing frameworks and methodologies
+- Build tools and package managers
+- Domain-specific knowledge
+- Architectural patterns and design principles
+- Third-party services and APIs
+
+Start by reviewing the existing entries with \`complexity list\`, then add, update, or remove entries as needed to ensure completeness and accuracy.
+
+Do not update the COMPLEXITY.md file manually.
+`.trim();
+	console.log(prompt);
+}
+
+//#endregion
+//#region src/index.ts
+const program = new Command();
+program.name("complexity").description("A CLI tool for managing project complexity and knowledge maps").version("1.0.0");
+program.command("init").description("Initialize a COMPLEXITY.md file in the current directory").option("-n, --name <name>", "Project name").option("-f, --force", "Overwrite existing file").action(initCommand);
+program.command("add <concept> [level] [area]").description("Add a concept to the complexity map").option("-l, --level <level>", "Criticality level (1-3)").action(addCommand);
+program.command("remove <concept>").description("Remove a concept from the complexity map").option("-f, --force", "Skip confirmation").action(removeCommand);
+program.command("update <concept>").description("Update an existing concept").option("-l, --level <level>", "New criticality level (1-3)").option("-a, --area <area>", "New area").option("-n, --name <name>", "New concept name").action(updateCommand);
+program.command("list").description("List all concepts in the complexity map").action(listCommand);
+program.command("prompt").description("Display the AI prompt for complexity analysis").action(promptCommand);
 program.parse();
-//# sourceMappingURL=index.js.map
+
+//#endregion
+export {  };

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "complexity-cli",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A CLI tool for managing project complexity and knowledge maps",
+  "type": "module",
   "main": "dist/index.js",
   "bin": {
     "complexity": "dist/index.js"
   },
   "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "link": "npm run build && npm link",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -37,13 +40,14 @@
     "LICENSE"
   ],
   "dependencies": {
+    "chalk": "^4.1.2",
     "commander": "^12.0.0",
-    "inquirer": "^9.2.0",
-    "chalk": "^4.1.2"
+    "inquirer": "^9.2.0"
   },
   "devDependencies": {
-    "@types/node": "^20.0.0",
     "@types/inquirer": "^9.0.0",
+    "@types/node": "^20.0.0",
+    "tsdown": "^0.20.3",
     "typescript": "^5.3.0"
   },
   "engines": {

package/dist/commands/add.d.ts

@@ -1,4 +0,0 @@
-export declare function addCommand(concept: string, levelArg: string | undefined, areaArg: string | undefined, options: {
-    level?: string;
-}): Promise<void>;
-//# sourceMappingURL=add.d.ts.map

package/dist/commands/add.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../src/commands/add.ts"],"names":[],"mappings":"AA8EA,wBAAsB,UAAU,CAC9B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,OAAO,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,iBAkB5B"}