skiller 0.4.3

package/dist/cli/handlers.js

@@ -0,0 +1,221 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyHandler = applyHandler;
+exports.initHandler = initHandler;
+exports.revertHandler = revertHandler;
+const lib_1 = require("../lib");
+const revert_1 = require("../revert");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs/promises"));
+const constants_1 = require("../constants");
+const ConfigLoader_1 = require("../core/ConfigLoader");
+/**
+ * Handler for the 'apply' command.
+ */
+async function applyHandler(argv) {
+    const projectRoot = argv['project-root'];
+    const agents = argv.agents
+        ? argv.agents.split(',').map((a) => a.trim())
+        : undefined;
+    const configPath = argv.config;
+    const mcpEnabled = argv.mcp;
+    const mcpStrategy = argv['mcp-overwrite']
+        ? 'overwrite'
+        : undefined;
+    const verbose = argv.verbose;
+    const dryRun = argv['dry-run'];
+    const localOnly = argv['local-only'];
+    // Determine backup preference: CLI > TOML > Default (enabled)
+    // yargs handles --no-backup by setting backup to false
+    let backupPreference;
+    if (argv.backup !== undefined) {
+        backupPreference = argv.backup;
+    }
+    else {
+        backupPreference = undefined; // Let TOML/default decide
+    }
+    // Determine gitignore preference: CLI > TOML > Default (enabled)
+    // yargs handles --no-gitignore by setting gitignore to false
+    let gitignorePreference;
+    if (argv.gitignore !== undefined) {
+        gitignorePreference = argv.gitignore;
+    }
+    else {
+        gitignorePreference = undefined; // Let TOML/default decide
+    }
+    // Determine nested preference: CLI > TOML > Default (false)
+    let nested;
+    if (argv.nested !== undefined) {
+        // CLI explicitly set nested (either --nested or --no-nested)
+        nested = argv.nested;
+    }
+    else {
+        // CLI didn't set nested, check TOML configuration
+        try {
+            const config = await (0, ConfigLoader_1.loadConfig)({
+                projectRoot,
+                configPath,
+            });
+            // Use TOML setting if available, otherwise default to false
+            nested = config.nested ?? false;
+        }
+        catch {
+            // If config loading fails, use default (false)
+            nested = false;
+        }
+    }
+    // Determine skills preference: CLI > TOML > Default (enabled)
+    let skillsEnabled;
+    if (argv.skills !== undefined) {
+        skillsEnabled = argv.skills;
+    }
+    else {
+        skillsEnabled = undefined; // Let config/default decide
+    }
+    try {
+        await (0, lib_1.applyAllAgentConfigs)(projectRoot, agents, configPath, mcpEnabled, mcpStrategy, gitignorePreference, verbose, dryRun, localOnly, nested, backupPreference, skillsEnabled);
+        console.log('Ruler apply completed successfully.');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`${constants_1.ERROR_PREFIX} ${message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Handler for the 'init' command.
+ */
+async function initHandler(argv) {
+    const projectRoot = argv['project-root'];
+    const isGlobal = argv['global'];
+    const useClaude = argv['claude'] ?? false;
+    const folderName = useClaude ? '.claude' : '.ruler';
+    const rulerDir = isGlobal
+        ? path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'ruler')
+        : path.join(projectRoot, folderName);
+    await fs.mkdir(rulerDir, { recursive: true });
+    const instructionsPath = path.join(rulerDir, constants_1.DEFAULT_RULES_FILENAME); // .ruler/AGENTS.md or .claude/AGENTS.md
+    const tomlPath = path.join(rulerDir, 'ruler.toml');
+    const exists = async (p) => {
+        try {
+            await fs.access(p);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const DEFAULT_INSTRUCTIONS = `# AGENTS.md\n\nCentralised AI agent instructions. Add coding guidelines, style guides, and project context here.\n\nRuler concatenates all .md files in this directory (and subdirectories), starting with AGENTS.md (if present), then remaining files in sorted order.\n`;
+    const DEFAULT_TOML = `# Ruler Configuration File
+# See https://ai.intellectronica.net/ruler for documentation.
+
+# To specify which agents are active by default when --agents is not used,
+# uncomment and populate the following line. If omitted, all agents are active.
+# default_agents = ["copilot", "claude"]
+${useClaude ? '\n# Root folder for ruler files\nroot_folder = ".claude"\n' : ''}
+# Enable nested rule loading from nested ${folderName} directories
+# When enabled, ruler will search for and process ${folderName} directories throughout the project hierarchy
+# nested = false
+
+# --- Agent Specific Configurations ---
+# You can enable/disable agents and override their default output paths here.
+# Use lowercase agent identifiers: amp, copilot, claude, codex, cursor, windsurf, cline, aider, kilocode
+
+# [agents.copilot]
+# enabled = true
+# output_path = ".github/copilot-instructions.md"
+
+# [agents.aider]
+# enabled = true
+# output_path_instructions = "AGENTS.md"
+# output_path_config = ".aider.conf.yml"
+
+# [agents.gemini-cli]
+# enabled = true
+
+# --- MCP Servers ---
+# Define Model Context Protocol servers here. Two examples:
+# 1. A stdio server (local executable)
+# 2. A remote server (HTTP-based)
+
+# [mcp_servers.example_stdio]
+# command = "node"
+# args = ["scripts/your-mcp-server.js"]
+# env = { API_KEY = "replace_me" }
+
+# [mcp_servers.example_remote]
+# url = "https://api.example.com/mcp"
+# headers = { Authorization = "Bearer REPLACE_ME" }
+`;
+    if (!(await exists(instructionsPath))) {
+        // Create new AGENTS.md regardless of legacy presence.
+        await fs.writeFile(instructionsPath, DEFAULT_INSTRUCTIONS);
+        console.log(`[ruler] Created ${instructionsPath}`);
+    }
+    else {
+        console.log(`[ruler] ${constants_1.DEFAULT_RULES_FILENAME} already exists, skipping`);
+    }
+    if (!(await exists(tomlPath))) {
+        await fs.writeFile(tomlPath, DEFAULT_TOML);
+        console.log(`[ruler] Created ${tomlPath}`);
+    }
+    else {
+        console.log(`[ruler] ruler.toml already exists, skipping`);
+    }
+}
+/**
+ * Handler for the 'revert' command.
+ */
+async function revertHandler(argv) {
+    const projectRoot = argv['project-root'];
+    const agents = argv.agents
+        ? argv.agents.split(',').map((a) => a.trim())
+        : undefined;
+    const configPath = argv.config;
+    const keepBackups = argv['keep-backups'];
+    const verbose = argv.verbose;
+    const dryRun = argv['dry-run'];
+    const localOnly = argv['local-only'];
+    try {
+        await (0, revert_1.revertAllAgentConfigs)(projectRoot, agents, configPath, keepBackups, verbose, dryRun, localOnly);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`${constants_1.ERROR_PREFIX} ${message}`);
+        process.exit(1);
+    }
+}

package/dist/cli/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_1 = require("./commands");
+(0, commands_1.run)();

package/dist/constants.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SKILLZ_MCP_SERVER_NAME = exports.SKILL_MD_FILENAME = exports.SKILLZ_DIR = exports.CLAUDE_SKILLS_PATH = exports.RULER_SKILLS_PATH = exports.SKILLS_DIR = exports.DEFAULT_RULES_FILENAME = exports.ERROR_PREFIX = void 0;
+exports.actionPrefix = actionPrefix;
+exports.createRulerError = createRulerError;
+exports.logVerbose = logVerbose;
+exports.logInfo = logInfo;
+exports.logWarn = logWarn;
+exports.logError = logError;
+exports.logVerboseInfo = logVerboseInfo;
+exports.ERROR_PREFIX = '[ruler]';
+// Centralized default rules filename. Now points to 'AGENTS.md'.
+// Legacy '.ruler/instructions.md' is still supported as a fallback with a warning.
+exports.DEFAULT_RULES_FILENAME = 'AGENTS.md';
+function actionPrefix(dry) {
+    return dry ? '[ruler:dry-run]' : '[ruler]';
+}
+function createRulerError(message, context) {
+    const fullMessage = context
+        ? `${exports.ERROR_PREFIX} ${message} (Context: ${context})`
+        : `${exports.ERROR_PREFIX} ${message}`;
+    return new Error(fullMessage);
+}
+function logVerbose(message, isVerbose) {
+    if (isVerbose) {
+        console.error(`[ruler:verbose] ${message}`);
+    }
+}
+/**
+ * Centralized logging functions with consistent output streams and prefixing.
+ * - info/verbose go to stdout (user-visible progress)
+ * - warn/error go to stderr (problems)
+ */
+function logInfo(message, dryRun = false) {
+    const prefix = actionPrefix(dryRun);
+    console.log(`${prefix} ${message}`);
+}
+function logWarn(message, dryRun = false) {
+    const prefix = actionPrefix(dryRun);
+    console.warn(`${prefix} ${message}`);
+}
+function logError(message, dryRun = false) {
+    const prefix = actionPrefix(dryRun);
+    console.error(`${prefix} ${message}`);
+}
+function logVerboseInfo(message, isVerbose, dryRun = false) {
+    if (isVerbose) {
+        const prefix = actionPrefix(dryRun);
+        console.log(`${prefix} ${message}`);
+    }
+}
+// Skills-related constants
+exports.SKILLS_DIR = 'skills';
+exports.RULER_SKILLS_PATH = '.ruler/skills';
+exports.CLAUDE_SKILLS_PATH = '.claude/skills';
+exports.SKILLZ_DIR = '.skillz';
+exports.SKILL_MD_FILENAME = 'SKILL.md';
+exports.SKILLZ_MCP_SERVER_NAME = 'skillz';

package/dist/core/ConfigLoader.js

@@ -0,0 +1,274 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const toml_1 = require("@iarna/toml");
+const zod_1 = require("zod");
+const constants_1 = require("../constants");
+const mcpConfigSchema = zod_1.z
+    .object({
+    enabled: zod_1.z.boolean().optional(),
+    merge_strategy: zod_1.z.enum(['merge', 'overwrite']).optional(),
+})
+    .optional();
+const agentConfigSchema = zod_1.z
+    .object({
+    enabled: zod_1.z.boolean().optional(),
+    output_path: zod_1.z.string().optional(),
+    output_path_instructions: zod_1.z.string().optional(),
+    output_path_config: zod_1.z.string().optional(),
+    mcp: mcpConfigSchema,
+})
+    .optional();
+const rulerConfigSchema = zod_1.z.object({
+    default_agents: zod_1.z.array(zod_1.z.string()).optional(),
+    root_folder: zod_1.z.string().optional(),
+    agents: zod_1.z.record(zod_1.z.string(), agentConfigSchema).optional(),
+    mcp: zod_1.z
+        .object({
+        enabled: zod_1.z.boolean().optional(),
+        merge_strategy: zod_1.z.enum(['merge', 'overwrite']).optional(),
+    })
+        .optional(),
+    gitignore: zod_1.z
+        .object({
+        enabled: zod_1.z.boolean().optional(),
+    })
+        .optional(),
+    backup: zod_1.z
+        .object({
+        enabled: zod_1.z.boolean().optional(),
+    })
+        .optional(),
+    skills: zod_1.z
+        .object({
+        enabled: zod_1.z.boolean().optional(),
+    })
+        .optional(),
+    rules: zod_1.z
+        .object({
+        include: zod_1.z.array(zod_1.z.string()).optional(),
+        exclude: zod_1.z.array(zod_1.z.string()).optional(),
+        merge_strategy: zod_1.z.enum(['all', 'cursor']).optional(),
+    })
+        .optional(),
+    nested: zod_1.z.boolean().optional(),
+});
+/**
+ * Recursively creates a new object with only enumerable string keys,
+ * effectively excluding Symbol properties.
+ * The @iarna/toml parser adds Symbol properties (Symbol(type), Symbol(declared))
+ * for metadata, which Zod v4+ validates and rejects as invalid record keys.
+ * By rebuilding the object structure using Object.keys(), we create clean objects
+ * that only contain the actual data without Symbol metadata.
+ */
+function stripSymbols(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(stripSymbols);
+    }
+    const result = {};
+    for (const key of Object.keys(obj)) {
+        result[key] = stripSymbols(obj[key]);
+    }
+    return result;
+}
+/**
+ * Loads and parses the ruler TOML configuration file, applying defaults.
+ * If the file is missing or invalid, returns empty/default config.
+ */
+async function loadConfig(options) {
+    const { projectRoot, configPath, cliAgents } = options;
+    let configFile;
+    if (configPath) {
+        configFile = path.resolve(configPath);
+    }
+    else {
+        // Try local .ruler/ruler.toml first
+        const localConfigFile = path.join(projectRoot, '.ruler', 'ruler.toml');
+        try {
+            await fs_1.promises.access(localConfigFile);
+            configFile = localConfigFile;
+        }
+        catch {
+            // If .ruler config doesn't exist, try .claude/ruler.toml
+            const claudeConfigFile = path.join(projectRoot, '.claude', 'ruler.toml');
+            try {
+                await fs_1.promises.access(claudeConfigFile);
+                configFile = claudeConfigFile;
+            }
+            catch {
+                // If neither local config exists, try global config
+                const xdgConfigDir = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+                configFile = path.join(xdgConfigDir, 'ruler', 'ruler.toml');
+            }
+        }
+    }
+    let raw = {};
+    try {
+        const text = await fs_1.promises.readFile(configFile, 'utf8');
+        const parsed = text.trim() ? (0, toml_1.parse)(text) : {};
+        // Strip Symbol properties added by @iarna/toml (required for Zod v4+)
+        raw = stripSymbols(parsed);
+        // Validate the configuration with zod
+        const validationResult = rulerConfigSchema.safeParse(raw);
+        if (!validationResult.success) {
+            throw (0, constants_1.createRulerError)('Invalid configuration file format', `File: ${configFile}, Errors: ${validationResult.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join(', ')}`);
+        }
+    }
+    catch (err) {
+        if (err instanceof Error && err.code !== 'ENOENT') {
+            if (err.message.includes('[ruler]')) {
+                throw err; // Re-throw validation errors
+            }
+            console.warn(`[ruler] Warning: could not read config file at ${configFile}: ${err.message}`);
+        }
+        raw = {};
+    }
+    const defaultAgents = Array.isArray(raw.default_agents)
+        ? raw.default_agents.map((a) => String(a))
+        : undefined;
+    const rootFolder = typeof raw.root_folder === 'string' ? raw.root_folder : undefined;
+    const agentsSection = raw.agents && typeof raw.agents === 'object' && !Array.isArray(raw.agents)
+        ? raw.agents
+        : {};
+    const agentConfigs = {};
+    for (const [name, section] of Object.entries(agentsSection)) {
+        if (section && typeof section === 'object') {
+            const sectionObj = section;
+            const cfg = {};
+            if (typeof sectionObj.enabled === 'boolean') {
+                cfg.enabled = sectionObj.enabled;
+            }
+            if (typeof sectionObj.output_path === 'string') {
+                cfg.outputPath = path.resolve(projectRoot, sectionObj.output_path);
+            }
+            if (typeof sectionObj.output_path_instructions === 'string') {
+                cfg.outputPathInstructions = path.resolve(projectRoot, sectionObj.output_path_instructions);
+            }
+            if (typeof sectionObj.output_path_config === 'string') {
+                cfg.outputPathConfig = path.resolve(projectRoot, sectionObj.output_path_config);
+            }
+            if (sectionObj.mcp && typeof sectionObj.mcp === 'object') {
+                const m = sectionObj.mcp;
+                const mcpCfg = {};
+                if (typeof m.enabled === 'boolean') {
+                    mcpCfg.enabled = m.enabled;
+                }
+                if (typeof m.merge_strategy === 'string') {
+                    const ms = m.merge_strategy;
+                    if (ms === 'merge' || ms === 'overwrite') {
+                        mcpCfg.strategy = ms;
+                    }
+                }
+                cfg.mcp = mcpCfg;
+            }
+            agentConfigs[name] = cfg;
+        }
+    }
+    const rawMcpSection = raw.mcp && typeof raw.mcp === 'object' && !Array.isArray(raw.mcp)
+        ? raw.mcp
+        : {};
+    const globalMcpConfig = {};
+    if (typeof rawMcpSection.enabled === 'boolean') {
+        globalMcpConfig.enabled = rawMcpSection.enabled;
+    }
+    if (typeof rawMcpSection.merge_strategy === 'string') {
+        const strat = rawMcpSection.merge_strategy;
+        if (strat === 'merge' || strat === 'overwrite') {
+            globalMcpConfig.strategy = strat;
+        }
+    }
+    const rawGitignoreSection = raw.gitignore &&
+        typeof raw.gitignore === 'object' &&
+        !Array.isArray(raw.gitignore)
+        ? raw.gitignore
+        : {};
+    const gitignoreConfig = {};
+    if (typeof rawGitignoreSection.enabled === 'boolean') {
+        gitignoreConfig.enabled = rawGitignoreSection.enabled;
+    }
+    const rawBackupSection = raw.backup && typeof raw.backup === 'object' && !Array.isArray(raw.backup)
+        ? raw.backup
+        : {};
+    const backupConfig = {};
+    if (typeof rawBackupSection.enabled === 'boolean') {
+        backupConfig.enabled = rawBackupSection.enabled;
+    }
+    const rawSkillsSection = raw.skills && typeof raw.skills === 'object' && !Array.isArray(raw.skills)
+        ? raw.skills
+        : {};
+    const skillsConfig = {};
+    if (typeof rawSkillsSection.enabled === 'boolean') {
+        skillsConfig.enabled = rawSkillsSection.enabled;
+    }
+    if (typeof rawSkillsSection.generate_from_rules === 'boolean') {
+        skillsConfig.generate_from_rules = rawSkillsSection.generate_from_rules;
+    }
+    const rawRulesSection = raw.rules && typeof raw.rules === 'object' && !Array.isArray(raw.rules)
+        ? raw.rules
+        : {};
+    const rulesConfig = {};
+    if (Array.isArray(rawRulesSection.include)) {
+        rulesConfig.include = rawRulesSection.include.map((p) => String(p));
+    }
+    if (Array.isArray(rawRulesSection.exclude)) {
+        rulesConfig.exclude = rawRulesSection.exclude.map((p) => String(p));
+    }
+    if (rawRulesSection.merge_strategy === 'all' ||
+        rawRulesSection.merge_strategy === 'cursor') {
+        rulesConfig.merge_strategy = rawRulesSection.merge_strategy;
+    }
+    const nestedDefined = typeof raw.nested === 'boolean';
+    const nested = nestedDefined ? raw.nested : false;
+    return {
+        defaultAgents,
+        rootFolder,
+        agentConfigs,
+        cliAgents,
+        mcp: globalMcpConfig,
+        gitignore: gitignoreConfig,
+        backup: backupConfig,
+        skills: skillsConfig,
+        rules: rulesConfig,
+        nested,
+        nestedDefined,
+    };
+}