aicm 0.17.1 → 0.17.3

package/README.md

@@ -343,6 +343,14 @@ Options:
 - `--verbose`: show detailed output and stack traces for debugging
 - `--dry-run`: simulate installation without writing files, useful for validating presets in CI
 
+### `clean`
+
+Removes all files, directories & changes made by aicm.
+
+```bash
+npx aicm clean
+```
+
 ## Node.js API
 
 In addition to the CLI, aicm can be used programmatically in Node.js applications:

package/dist/cli.js

@@ -10,6 +10,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const init_1 = require("./commands/init");
 const install_1 = require("./commands/install");
 const list_1 = require("./commands/list");
+const clean_1 = require("./commands/clean");
 // Define version from package.json
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const pkg = require("../package.json");
@@ -48,6 +49,9 @@ async function runCli() {
             case "list":
                 await (0, list_1.listCommand)();
                 break;
+            case "clean":
+                await (0, clean_1.cleanCommand)(args["--verbose"]);
+                break;
             default:
                 showHelp();
                 break;
@@ -69,6 +73,7 @@ ${chalk_1.default.bold("COMMANDS")}
   init                Initialize a new aicm configuration file
   install             Install rules from configured sources
   list                List all configured rules and their status
+  clean               Remove all files and directories created by aicm
 
 ${chalk_1.default.bold("OPTIONS")}
   -h, --help          Show this help message

package/dist/commands/clean.d.ts

@@ -0,0 +1,19 @@
+export interface CleanOptions {
+    /**
+     * Base directory to use instead of process.cwd()
+     */
+    cwd?: string;
+    /**
+     * Show verbose output
+     */
+    verbose?: boolean;
+}
+export interface CleanResult {
+    success: boolean;
+    error?: Error;
+    cleanedCount: number;
+}
+export declare function cleanPackage(options?: CleanOptions): Promise<CleanResult>;
+export declare function cleanWorkspaces(cwd: string, verbose?: boolean): Promise<CleanResult>;
+export declare function clean(options?: CleanOptions): Promise<CleanResult>;
+export declare function cleanCommand(verbose?: boolean): Promise<void>;

package/dist/commands/clean.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanPackage = cleanPackage;
+exports.cleanWorkspaces = cleanWorkspaces;
+exports.clean = clean;
+exports.cleanCommand = cleanCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("../utils/config");
+const working_directory_1 = require("../utils/working-directory");
+const rules_file_writer_1 = require("../utils/rules-file-writer");
+const workspace_discovery_1 = require("../utils/workspace-discovery");
+function cleanFile(filePath, verbose) {
+    if (!fs_extra_1.default.existsSync(filePath))
+        return false;
+    try {
+        fs_extra_1.default.removeSync(filePath);
+        if (verbose)
+            console.log(chalk_1.default.gray(`  Removed ${filePath}`));
+        return true;
+    }
+    catch (_a) {
+        console.warn(chalk_1.default.yellow(`Warning: Failed to remove ${filePath}`));
+        return false;
+    }
+}
+function cleanRulesBlock(filePath, verbose) {
+    if (!fs_extra_1.default.existsSync(filePath))
+        return false;
+    try {
+        const content = fs_extra_1.default.readFileSync(filePath, "utf8");
+        const cleanedContent = (0, rules_file_writer_1.removeRulesBlock)(content);
+        if (content === cleanedContent)
+            return false;
+        if (cleanedContent.trim() === "") {
+            fs_extra_1.default.removeSync(filePath);
+            if (verbose)
+                console.log(chalk_1.default.gray(`  Removed empty file ${filePath}`));
+        }
+        else {
+            fs_extra_1.default.writeFileSync(filePath, cleanedContent);
+            if (verbose)
+                console.log(chalk_1.default.gray(`  Cleaned rules block from ${filePath}`));
+        }
+        return true;
+    }
+    catch (_a) {
+        console.warn(chalk_1.default.yellow(`Warning: Failed to clean ${filePath}`));
+        return false;
+    }
+}
+function cleanMcpServers(cwd, verbose) {
+    const mcpPath = node_path_1.default.join(cwd, ".cursor", "mcp.json");
+    if (!fs_extra_1.default.existsSync(mcpPath))
+        return false;
+    try {
+        const content = fs_extra_1.default.readJsonSync(mcpPath);
+        const mcpServers = content.mcpServers;
+        if (!mcpServers)
+            return false;
+        let hasChanges = false;
+        const newMcpServers = {};
+        for (const [key, value] of Object.entries(mcpServers)) {
+            if (typeof value === "object" &&
+                value !== null &&
+                "aicm" in value &&
+                value.aicm === true) {
+                hasChanges = true;
+            }
+            else {
+                newMcpServers[key] = value;
+            }
+        }
+        if (!hasChanges)
+            return false;
+        // If no servers remain and no other properties, remove the file
+        if (Object.keys(newMcpServers).length === 0 &&
+            Object.keys(content).length === 1) {
+            fs_extra_1.default.removeSync(mcpPath);
+            if (verbose)
+                console.log(chalk_1.default.gray(`  Removed empty ${mcpPath}`));
+        }
+        else {
+            content.mcpServers = newMcpServers;
+            fs_extra_1.default.writeJsonSync(mcpPath, content, { spaces: 2 });
+            if (verbose)
+                console.log(chalk_1.default.gray(`  Cleaned aicm MCP servers from ${mcpPath}`));
+        }
+        return true;
+    }
+    catch (_a) {
+        console.warn(chalk_1.default.yellow(`Warning: Failed to clean MCP servers`));
+        return false;
+    }
+}
+function cleanEmptyDirectories(cwd, verbose) {
+    let cleanedCount = 0;
+    const dirsToCheck = [
+        node_path_1.default.join(cwd, ".cursor", "rules"),
+        node_path_1.default.join(cwd, ".cursor", "commands"),
+        node_path_1.default.join(cwd, ".cursor"),
+    ];
+    for (const dir of dirsToCheck) {
+        if (fs_extra_1.default.existsSync(dir)) {
+            try {
+                const contents = fs_extra_1.default.readdirSync(dir);
+                if (contents.length === 0) {
+                    fs_extra_1.default.removeSync(dir);
+                    if (verbose)
+                        console.log(chalk_1.default.gray(`  Removed empty directory ${dir}`));
+                    cleanedCount++;
+                }
+            }
+            catch (_a) {
+                // Ignore errors when checking/removing empty directories
+            }
+        }
+    }
+    return cleanedCount;
+}
+async function cleanPackage(options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const verbose = options.verbose || false;
+    return (0, working_directory_1.withWorkingDirectory)(cwd, async () => {
+        let cleanedCount = 0;
+        const filesToClean = [
+            node_path_1.default.join(cwd, ".cursor", "rules", "aicm"),
+            node_path_1.default.join(cwd, ".cursor", "commands", "aicm"),
+            node_path_1.default.join(cwd, ".aicm"),
+        ];
+        const rulesFilesToClean = [
+            node_path_1.default.join(cwd, ".windsurfrules"),
+            node_path_1.default.join(cwd, "AGENTS.md"),
+            node_path_1.default.join(cwd, "CLAUDE.md"),
+        ];
+        // Clean directories and files
+        for (const file of filesToClean) {
+            if (cleanFile(file, verbose))
+                cleanedCount++;
+        }
+        // Clean rules blocks from files
+        for (const file of rulesFilesToClean) {
+            if (cleanRulesBlock(file, verbose))
+                cleanedCount++;
+        }
+        // Clean MCP servers
+        if (cleanMcpServers(cwd, verbose))
+            cleanedCount++;
+        // Clean empty directories
+        cleanedCount += cleanEmptyDirectories(cwd, verbose);
+        return {
+            success: true,
+            cleanedCount,
+        };
+    });
+}
+async function cleanWorkspaces(cwd, verbose = false) {
+    if (verbose)
+        console.log(chalk_1.default.blue("🔍 Discovering packages..."));
+    const packages = await (0, workspace_discovery_1.discoverPackagesWithAicm)(cwd);
+    if (verbose && packages.length > 0) {
+        console.log(chalk_1.default.blue(`Found ${packages.length} packages with aicm configurations.`));
+    }
+    let totalCleaned = 0;
+    // Clean all discovered packages
+    for (const pkg of packages) {
+        if (verbose)
+            console.log(chalk_1.default.blue(`Cleaning package: ${pkg.relativePath}`));
+        const result = await cleanPackage({
+            cwd: pkg.absolutePath,
+            verbose,
+        });
+        totalCleaned += result.cleanedCount;
+    }
+    // Always clean root directory (for merged artifacts like mcp.json and commands)
+    const rootPackage = packages.find((p) => p.absolutePath === cwd);
+    if (!rootPackage) {
+        if (verbose)
+            console.log(chalk_1.default.blue(`Cleaning root workspace artifacts...`));
+        const rootResult = await cleanPackage({ cwd, verbose });
+        totalCleaned += rootResult.cleanedCount;
+    }
+    return {
+        success: true,
+        cleanedCount: totalCleaned,
+    };
+}
+async function clean(options = {}) {
+    var _a;
+    const cwd = options.cwd || process.cwd();
+    const verbose = options.verbose || false;
+    const shouldUseWorkspaces = ((_a = (await (0, config_1.loadConfig)(cwd))) === null || _a === void 0 ? void 0 : _a.config.workspaces) ||
+        (0, config_1.detectWorkspacesFromPackageJson)(cwd);
+    if (shouldUseWorkspaces) {
+        return cleanWorkspaces(cwd, verbose);
+    }
+    return cleanPackage(options);
+}
+async function cleanCommand(verbose) {
+    const result = await clean({ verbose });
+    if (result.cleanedCount === 0) {
+        console.log("Nothing to clean.");
+    }
+    else {
+        console.log(chalk_1.default.green(`Successfully cleaned ${result.cleanedCount} file(s)/director(y/ies).`));
+    }
+}

package/dist/commands/install.js

@@ -9,11 +9,11 @@ exports.installCommand = installCommand;
 const chalk_1 = __importDefault(require("chalk"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
-const child_process_1 = require("child_process");
 const config_1 = require("../utils/config");
 const working_directory_1 = require("../utils/working-directory");
 const is_ci_1 = require("../utils/is-ci");
 const rules_file_writer_1 = require("../utils/rules-file-writer");
+const workspace_discovery_1 = require("../utils/workspace-discovery");
 function getTargetPaths() {
     const projectDir = process.cwd();
     return {
@@ -342,49 +342,6 @@ function mergeWorkspaceMcpServers(packages) {
     }
     return { merged, conflicts };
 }
-/**
- * Discover all packages with aicm configurations using git ls-files
- */
-function findAicmFiles(rootDir) {
-    try {
-        const output = (0, child_process_1.execSync)("git ls-files --cached --others --exclude-standard aicm.json **/aicm.json", {
-            cwd: rootDir,
-            encoding: "utf8",
-        });
-        return output
-            .trim()
-            .split("\n")
-            .filter(Boolean)
-            .map((file) => node_path_1.default.resolve(rootDir, file));
-    }
-    catch (_a) {
-        // Fallback to manual search if git is not available
-        return [];
-    }
-}
-/**
- * Discover all packages with aicm configurations
- */
-async function discoverPackagesWithAicm(rootDir) {
-    const aicmFiles = findAicmFiles(rootDir);
-    const packages = [];
-    for (const aicmFile of aicmFiles) {
-        const packageDir = node_path_1.default.dirname(aicmFile);
-        const relativePath = node_path_1.default.relative(rootDir, packageDir);
-        // Normalize to forward slashes for cross-platform compatibility
-        const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-        const config = await (0, config_1.loadConfig)(packageDir);
-        if (config) {
-            packages.push({
-                relativePath: normalizedRelativePath || ".",
-                absolutePath: packageDir,
-                config,
-            });
-        }
-    }
-    // Sort packages by relativePath for deterministic order
-    return packages.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-}
 /**
  * Install rules for a single package (used within workspaces and standalone installs)
  */
@@ -507,7 +464,7 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
         if (verbose) {
             console.log(chalk_1.default.blue("🔍 Discovering packages..."));
         }
-        const allPackages = await discoverPackagesWithAicm(cwd);
+        const allPackages = await (0, workspace_discovery_1.discoverPackagesWithAicm)(cwd);
         const packages = allPackages.filter((pkg) => {
             if (pkg.config.config.skipInstall === true) {
                 return false;

package/dist/utils/rules-file-writer.d.ts

@@ -3,6 +3,10 @@ export type RuleMetadata = Record<string, string | boolean | string[]>;
  * Parse YAML frontmatter blocks from a rule file and return a flat metadata object
  */
 export declare function parseRuleFrontmatter(content: string): RuleMetadata;
+/**
+ * Remove the rules block from the content
+ */
+export declare function removeRulesBlock(content: string): string;
 /**
  * Write rules to the .windsurfrules file
  * This will update the content between the RULES_BEGIN and RULES_END markers

package/dist/utils/rules-file-writer.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseRuleFrontmatter = parseRuleFrontmatter;
+exports.removeRulesBlock = removeRulesBlock;
 exports.writeRulesFile = writeRulesFile;
 exports.generateRulesFileContent = generateRulesFileContent;
 const fs_extra_1 = __importDefault(require("fs-extra"));
@@ -55,6 +56,20 @@ function parseRuleFrontmatter(content) {
 const RULES_BEGIN = "<!-- AICM:BEGIN -->";
 const RULES_END = "<!-- AICM:END -->";
 const WARNING = "<!-- WARNING: Everything between these markers will be overwritten during installation -->";
+/**
+ * Remove the rules block from the content
+ */
+function removeRulesBlock(content) {
+    // Check if our markers exist
+    if (content.includes(RULES_BEGIN) && content.includes(RULES_END)) {
+        const parts = content.split(RULES_BEGIN);
+        const beforeMarker = parts[0];
+        const afterParts = parts[1].split(RULES_END);
+        const afterMarker = afterParts.slice(1).join(RULES_END); // In case RULES_END appears multiple times (unlikely but safe)
+        return (beforeMarker + afterMarker).trim();
+    }
+    return content;
+}
 /**
  * Create a formatted block of content with rules markers
  */

package/dist/utils/workspace-discovery.d.ts

@@ -0,0 +1,13 @@
+import { ResolvedConfig } from "./config";
+/**
+ * Discover all packages with aicm configurations using git ls-files
+ */
+export declare function findAicmFiles(rootDir: string): string[];
+/**
+ * Discover all packages with aicm configurations
+ */
+export declare function discoverPackagesWithAicm(rootDir: string): Promise<Array<{
+    relativePath: string;
+    absolutePath: string;
+    config: ResolvedConfig;
+}>>;

package/dist/utils/workspace-discovery.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAicmFiles = findAicmFiles;
+exports.discoverPackagesWithAicm = discoverPackagesWithAicm;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const config_1 = require("./config");
+/**
+ * Discover all packages with aicm configurations using git ls-files
+ */
+function findAicmFiles(rootDir) {
+    try {
+        const output = (0, child_process_1.execSync)("git ls-files --cached --others --exclude-standard aicm.json **/aicm.json", {
+            cwd: rootDir,
+            encoding: "utf8",
+        });
+        return output
+            .trim()
+            .split("\n")
+            .filter(Boolean)
+            .map((file) => path_1.default.resolve(rootDir, file));
+    }
+    catch (_a) {
+        // Fallback to manual search if git is not available
+        return [];
+    }
+}
+/**
+ * Discover all packages with aicm configurations
+ */
+async function discoverPackagesWithAicm(rootDir) {
+    const aicmFiles = findAicmFiles(rootDir);
+    const packages = [];
+    for (const aicmFile of aicmFiles) {
+        const packageDir = path_1.default.dirname(aicmFile);
+        const relativePath = path_1.default.relative(rootDir, packageDir);
+        // Normalize to forward slashes for cross-platform compatibility
+        const normalizedRelativePath = relativePath.replace(/\\/g, "/");
+        const config = await (0, config_1.loadConfig)(packageDir);
+        if (config) {
+            packages.push({
+                relativePath: normalizedRelativePath || ".",
+                absolutePath: packageDir,
+                config,
+            });
+        }
+    }
+    // Sort packages by relativePath for deterministic order
+    return packages.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicm",
-  "version": "0.17.1",
+  "version": "0.17.3",
   "description": "A TypeScript CLI tool for managing AI IDE rules across different projects and teams",
   "main": "dist/api.js",
   "types": "dist/api.d.ts",