@intellectronica/ruler 0.3.41 → 0.3.43

package/dist/core/GitignoreUtils.js

@@ -34,8 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateGitignore = updateGitignore;
+exports.resolveIgnoreFilePath = resolveIgnoreFilePath;
+exports.findCompleteRulerBlocks = findCompleteRulerBlocks;
+exports.removeCompleteRulerBlocks = removeCompleteRulerBlocks;
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
+const FileSystemUtils_1 = require("./FileSystemUtils");
 const RULER_START_MARKER = '# START Ruler Generated Files';
 const RULER_END_MARKER = '# END Ruler Generated Files';
 /**
@@ -47,7 +51,7 @@ const RULER_END_MARKER = '# END Ruler Generated Files';
  * @param ignoreFile Relative path to the ignore file from project root (defaults to .gitignore)
  */
 async function updateGitignore(projectRoot, paths, ignoreFile = '.gitignore') {
-    const gitignorePath = path.join(projectRoot, ignoreFile);
+    const gitignorePath = await resolveIgnoreFilePath(projectRoot, ignoreFile);
     // Read existing .gitignore or start with empty content
     let existingContent = '';
     try {
@@ -98,64 +102,122 @@ async function updateGitignore(projectRoot, paths, ignoreFile = '.gitignore') {
     // Create new content
     const newContent = updateGitignoreContent(existingContent, allRulerPaths);
     // Write the updated content
-    await fs_1.promises.mkdir(path.dirname(gitignorePath), { recursive: true });
-    await fs_1.promises.writeFile(gitignorePath, newContent);
+    await (0, FileSystemUtils_1.writeGeneratedFile)(gitignorePath, newContent);
+}
+/**
+ * Resolves ignore files Ruler manages. Linked worktrees store `.git` as a
+ * file containing a `gitdir:` pointer, so `.git/info/exclude` must be resolved
+ * through that pointer.
+ */
+async function resolveIgnoreFilePath(projectRoot, ignoreFile) {
+    if (ignoreFile !== '.git/info/exclude') {
+        return path.join(projectRoot, ignoreFile);
+    }
+    const dotGitPath = path.join(projectRoot, '.git');
+    try {
+        const dotGitStat = await fs_1.promises.lstat(dotGitPath);
+        if (dotGitStat.isFile()) {
+            const dotGitContent = await fs_1.promises.readFile(dotGitPath, 'utf8');
+            const gitDirMatch = dotGitContent.match(/^gitdir:\s*(.+)\s*$/m);
+            if (gitDirMatch) {
+                const gitDir = gitDirMatch[1];
+                const resolvedGitDir = path.isAbsolute(gitDir)
+                    ? gitDir
+                    : path.resolve(projectRoot, gitDir);
+                return path.join(resolvedGitDir, 'info', 'exclude');
+            }
+        }
+    }
+    catch {
+        // Fall back to the historical project-root path for non-git test fixtures
+        // and unusual repositories where `.git` cannot be inspected.
+    }
+    return path.join(projectRoot, ignoreFile);
 }
 /**
  * Gets all paths from .gitignore content excluding those in the Ruler block.
  */
 function getExistingPathsExcludingRulerBlock(content) {
     const lines = content.split('\n');
+    const rulerBlocks = findCompleteRulerBlocks(lines);
     const paths = [];
-    let inRulerBlock = false;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed === RULER_START_MARKER) {
-            inRulerBlock = true;
-            continue;
-        }
-        if (trimmed === RULER_END_MARKER) {
-            inRulerBlock = false;
+    for (const [index, line] of lines.entries()) {
+        if (rulerBlocks.some((block) => index >= block.start && index <= block.end)) {
             continue;
         }
-        if (!inRulerBlock && trimmed && !trimmed.startsWith('#')) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith('#')) {
             paths.push(trimmed);
         }
     }
     return paths;
 }
+function findCompleteRulerBlocks(lines) {
+    const ranges = [];
+    for (let index = 0; index < lines.length; index++) {
+        if (lines[index].trim() !== RULER_START_MARKER) {
+            continue;
+        }
+        for (let endIndex = index + 1; endIndex < lines.length; endIndex++) {
+            const trimmed = lines[endIndex].trim();
+            if (trimmed === RULER_START_MARKER) {
+                break;
+            }
+            if (trimmed === RULER_END_MARKER) {
+                ranges.push({ start: index, end: endIndex });
+                index = endIndex;
+                break;
+            }
+        }
+    }
+    return ranges;
+}
+function removeCompleteRulerBlocks(content) {
+    const lines = content.split('\n');
+    const rulerBlocks = findCompleteRulerBlocks(lines);
+    if (rulerBlocks.length === 0) {
+        return { content, removed: false };
+    }
+    const retainedLines = [];
+    for (let index = 0; index < lines.length; index++) {
+        const block = rulerBlocks.find((range) => range.start === index);
+        if (block) {
+            index = block.end;
+            continue;
+        }
+        retainedLines.push(lines[index]);
+    }
+    return {
+        content: retainedLines.join('\n').replace(/\n{3,}/g, '\n\n'),
+        removed: true,
+    };
+}
 /**
  * Updates the .gitignore content by replacing or adding the Ruler block.
  */
 function updateGitignoreContent(existingContent, rulerPaths) {
     const lines = existingContent.split('\n');
+    const rulerBlocks = findCompleteRulerBlocks(lines);
     const newLines = [];
-    let inFirstRulerBlock = false;
-    let hasRulerBlock = false;
-    let processedFirstBlock = false;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed === RULER_START_MARKER && !processedFirstBlock) {
-            inFirstRulerBlock = true;
-            hasRulerBlock = true;
-            newLines.push(line);
-            // Add the new Ruler paths
+    let replacedFirstBlock = false;
+    for (let index = 0; index < lines.length; index++) {
+        const block = rulerBlocks.find((range) => range.start === index);
+        if (block && !replacedFirstBlock) {
+            newLines.push(lines[block.start]);
             rulerPaths.forEach((p) => newLines.push(p));
+            newLines.push(lines[block.end]);
+            replacedFirstBlock = true;
+            index = block.end;
             continue;
         }
-        if (trimmed === RULER_END_MARKER && inFirstRulerBlock) {
-            inFirstRulerBlock = false;
-            processedFirstBlock = true;
-            newLines.push(line);
+        if (block) {
+            index = block.end;
             continue;
         }
-        if (!inFirstRulerBlock) {
-            newLines.push(line);
-        }
-        // Skip lines that are in the first Ruler block (they get replaced)
+        newLines.push(lines[index]);
     }
     // If no Ruler block exists, add one at the end
-    if (!hasRulerBlock) {
+    if (rulerBlocks.length === 0) {
         // Add blank line if content exists and doesn't end with blank line
         if (existingContent.trim() && !existingContent.endsWith('\n\n')) {
             newLines.push('');

package/dist/core/RuleProcessor.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Concatenates markdown rule files into a single string,
+ * marking each section with its source filename.
+ */
+export declare function concatenateRules(files: {
+    path: string;
+    content: string;
+}[], baseDir?: string): string;

package/dist/core/SkillsProcessor.d.ts

@@ -0,0 +1,127 @@
+import * as fs from 'fs/promises';
+import { SkillInfo } from '../types';
+import type { IAgent } from '../agents/IAgent';
+/**
+ * Discovers skills in the project's .ruler/skills directory.
+ * Returns discovered skills and any validation warnings.
+ */
+export declare function discoverSkills(projectRoot: string): Promise<{
+    skills: SkillInfo[];
+    warnings: string[];
+}>;
+/**
+ * Gets the paths that skills will generate, for gitignore purposes.
+ * Returns empty array if skills directory doesn't exist.
+ */
+export declare function getSkillsGitignorePaths(projectRoot: string, agents: IAgent[]): Promise<string[]>;
+type ReplaceSkillsFsOps = Pick<typeof fs, 'rename' | 'cp' | 'rm'>;
+export declare function replaceSkillsDirectory(tempDir: string, targetDir: string, fsOps?: ReplaceSkillsFsOps, containmentRoot?: string): Promise<void>;
+/**
+ * Propagates skills for agents that need them.
+ */
+export declare function propagateSkills(projectRoot: string, agents: IAgent[], skillsEnabled: boolean, verbose: boolean, dryRun: boolean): Promise<void>;
+/**
+ * Propagates skills for Claude Code by copying .ruler/skills to .claude/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForClaude(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for OpenAI Codex CLI by copying .ruler/skills to .agents/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForCodex(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for OpenCode by copying .ruler/skills to .opencode/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForOpenCode(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Pi Coding Agent by copying .ruler/skills to .pi/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForPi(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Goose by copying .ruler/skills to .agents/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForGoose(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Mistral Vibe by copying .ruler/skills to .vibe/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForVibe(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Roo Code by copying .ruler/skills to .roo/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForRoo(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Gemini CLI by copying .ruler/skills to .gemini/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForGemini(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Junie by copying .ruler/skills to .junie/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForJunie(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Cursor by copying .ruler/skills to .cursor/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForCursor(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Windsurf by copying .ruler/skills to .windsurf/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForWindsurf(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Factory Droid by copying .ruler/skills to .factory/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForFactory(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Antigravity by copying .ruler/skills to .agent/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForAntigravity(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+export {};