openpets 1.0.11 → 1.0.12

package/dist/src/sdk/plugin-factory.js

@@ -3,6 +3,7 @@ import { readFileSync, existsSync } from "fs";
 import { resolve, dirname, join } from "path";
 import { createLogger } from "./logger";
 import { config } from "dotenv";
+import { ensurePromptsFolder } from "./prompts-manager";
 import * as zodRuntime from "zod";
 /**
  * Find the git root directory by walking up from the current directory
@@ -23,6 +24,103 @@ function findGitRoot(startDir) {
     }
     return null;
 }
+/**
+ * Find all directories containing .env files by traversing up from startDir
+ * Returns array of directories sorted from closest to furthest
+ */
+function findEnvDirs(startDir) {
+    const envDirs = [];
+    let currentDir = resolve(startDir);
+    const root = resolve("/");
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    while (currentDir !== root) {
+        // Stop at home directory to avoid going too far up
+        if (currentDir === homeDir) {
+            // Still check home directory for .env
+            if (existsSync(join(currentDir, ".env"))) {
+                envDirs.push(currentDir);
+            }
+            break;
+        }
+        // Check if this directory has a .env file
+        if (existsSync(join(currentDir, ".env"))) {
+            envDirs.push(currentDir);
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir)
+            break;
+        currentDir = parentDir;
+    }
+    return envDirs;
+}
+/**
+ * Find all directories containing .pets/config.json by traversing up from startDir
+ * Returns array of directories sorted from closest to furthest
+ */
+function findPetsConfigDirs(startDir) {
+    const configDirs = [];
+    let currentDir = resolve(startDir);
+    const root = resolve("/");
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    while (currentDir !== root) {
+        // Stop at home directory
+        if (currentDir === homeDir) {
+            if (existsSync(join(currentDir, ".pets", "config.json"))) {
+                configDirs.push(currentDir);
+            }
+            break;
+        }
+        // Check if this directory has a .pets/config.json file
+        if (existsSync(join(currentDir, ".pets", "config.json"))) {
+            configDirs.push(currentDir);
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir)
+            break;
+        currentDir = parentDir;
+    }
+    return configDirs;
+}
+/**
+ * Find potential project roots by looking for common project indicators
+ * Returns directories containing opencode.json, package.json, or .git
+ */
+function findProjectRoots(startDir) {
+    const projectRoots = [];
+    let currentDir = resolve(startDir);
+    const root = resolve("/");
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    // Project indicators to look for
+    const projectIndicators = [
+        "opencode.json",
+        ".opencode",
+        "package.json",
+        ".git",
+        "Cargo.toml",
+        "go.mod",
+        "pyproject.toml",
+        "Gemfile"
+    ];
+    while (currentDir !== root) {
+        // Stop at home directory
+        if (currentDir === homeDir)
+            break;
+        // Check if this directory has any project indicator
+        for (const indicator of projectIndicators) {
+            if (existsSync(join(currentDir, indicator))) {
+                if (!projectRoots.includes(currentDir)) {
+                    projectRoots.push(currentDir);
+                }
+                break;
+            }
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir)
+            break;
+        currentDir = parentDir;
+    }
+    return projectRoots;
+}
 // ============================================================================
 // CRITICAL: SCHEMA FORMAT REQUIREMENTS
 // ============================================================================
@@ -61,6 +159,8 @@ export { tool };
 export { zodRuntime as z };
 const logger = createLogger("plugin-factory");
 export function createPlugin(tools) {
+    // Ensure prompts folder is available before any tools are run
+    ensurePromptsFolder();
     const toolRecord = {};
     for (const toolDef of tools) {
         const schema = toolDef.schema;
@@ -188,29 +288,64 @@ export function loadEnv(petId) {
     const envVars = {};
     try {
         const cwd = resolve(process.cwd());
+        // Find all directories with .env files by traversing up from cwd
+        // This handles the case where plugins run from ~/.config/opencode
+        // but the user's project is elsewhere
+        const envDirs = findEnvDirs(cwd);
+        const petsConfigDirs = findPetsConfigDirs(cwd);
+        const projectRoots = findProjectRoots(cwd);
         const gitRoot = findGitRoot(cwd);
-        // Determine paths to check - prioritize cwd, fall back to git root
-        const cwdDotenvPath = resolve(cwd, '.env');
-        const cwdPetsConfigPath = resolve(cwd, '.pets', 'config.json');
-        const gitRootDotenvPath = gitRoot ? resolve(gitRoot, '.env') : null;
-        const gitRootPetsConfigPath = gitRoot ? resolve(gitRoot, '.pets', 'config.json') : null;
+        // Ensure .pets/ is in .git/info/exclude (local excludes, not tracked)
+        if (gitRoot) {
+            ensurePetsInGitExclude(gitRoot);
+        }
         logger.debug(`Loading env vars for pet: ${petId || 'global'}`, {
             cwd,
             gitRoot,
-            cwdDotenvExists: existsSync(cwdDotenvPath),
-            gitRootDotenvExists: gitRootDotenvPath ? existsSync(gitRootDotenvPath) : false
+            envDirsFound: envDirs.length,
+            petsConfigDirsFound: petsConfigDirs.length,
+            projectRootsFound: projectRoots.length
         });
-        // Load from .pets/config.json - check git root first, then cwd (cwd takes precedence)
-        const petsConfigPaths = [gitRootPetsConfigPath, cwdPetsConfigPath].filter(Boolean);
-        for (const petsConfigPath of petsConfigPaths) {
-            if (petId && existsSync(petsConfigPath)) {
+        // Build list of all directories to check for .pets/config.json
+        // Priority: closest first (cwd), then parent dirs, then git root
+        const allConfigDirs = new Set();
+        // Add petsConfigDirs in reverse order (furthest first, so closest overwrites)
+        for (let i = petsConfigDirs.length - 1; i >= 0; i--) {
+            allConfigDirs.add(petsConfigDirs[i]);
+        }
+        // Add project roots in reverse order
+        for (let i = projectRoots.length - 1; i >= 0; i--) {
+            allConfigDirs.add(projectRoots[i]);
+        }
+        // Add git root
+        if (gitRoot) {
+            allConfigDirs.add(gitRoot);
+        }
+        // Add cwd last so it takes highest priority
+        allConfigDirs.add(cwd);
+        // Load from .pets/config.json files - furthest first, closest last (closest takes precedence)
+        // Load order within each file: _global first, then pet-specific (pet-specific overrides _global)
+        for (const configDir of allConfigDirs) {
+            const petsConfigPath = resolve(configDir, '.pets', 'config.json');
+            if (existsSync(petsConfigPath)) {
                 try {
                     const petsConfig = JSON.parse(readFileSync(petsConfigPath, 'utf-8'));
-                    const petEnvConfig = petsConfig.envConfig?.[petId] || {};
-                    for (const [key, value] of Object.entries(petEnvConfig)) {
+                    // First load _global config (applies to all pets)
+                    const globalEnvConfig = petsConfig.envConfig?.["_global"] || {};
+                    for (const [key, value] of Object.entries(globalEnvConfig)) {
                         if (typeof value === 'string' && value.length > 0) {
                             envVars[key] = value;
-                            logger.debug(`Loaded from ${petsConfigPath}: ${key}`);
+                            logger.debug(`Loaded from ${petsConfigPath} (_global): ${key}`);
+                        }
+                    }
+                    // Then load pet-specific config (overrides _global)
+                    if (petId) {
+                        const petEnvConfig = petsConfig.envConfig?.[petId] || {};
+                        for (const [key, value] of Object.entries(petEnvConfig)) {
+                            if (typeof value === 'string' && value.length > 0) {
+                                envVars[key] = value;
+                                logger.debug(`Loaded from ${petsConfigPath} (${petId}): ${key}`);
+                            }
                         }
                     }
                 }
@@ -219,9 +354,26 @@ export function loadEnv(petId) {
                 }
             }
         }
-        // Load from .env files - check git root first, then cwd (cwd takes precedence)
-        const dotenvPaths = [gitRootDotenvPath, cwdDotenvPath].filter(Boolean);
-        for (const dotenvPath of dotenvPaths) {
+        // Build list of all directories to check for .env files
+        // Priority: furthest first, closest last (closest takes precedence)
+        const allEnvDirs = new Set();
+        // Add envDirs in reverse order (furthest first)
+        for (let i = envDirs.length - 1; i >= 0; i--) {
+            allEnvDirs.add(envDirs[i]);
+        }
+        // Add project roots in reverse order
+        for (let i = projectRoots.length - 1; i >= 0; i--) {
+            allEnvDirs.add(projectRoots[i]);
+        }
+        // Add git root
+        if (gitRoot) {
+            allEnvDirs.add(gitRoot);
+        }
+        // Add cwd last so it takes highest priority
+        allEnvDirs.add(cwd);
+        // Load from .env files - furthest first, closest last (closest takes precedence)
+        for (const envDir of allEnvDirs) {
+            const dotenvPath = resolve(envDir, '.env');
             if (existsSync(dotenvPath)) {
                 const dotenvResult = config({ path: dotenvPath });
                 if (dotenvResult.parsed) {
@@ -264,6 +416,8 @@ export function setEnv(petId, envVars, projectDir) {
             mkdirSync(petsDir, { recursive: true });
             logger.debug(`Created .pets directory at ${petsDir}`);
         }
+        // Ensure .pets/ is in .git/info/exclude (local excludes, not tracked)
+        ensurePetsInGitExclude(projectRoot);
         // Load existing config or create new one
         let petsConfig = {
             enabled: [],
@@ -379,7 +533,6 @@ export function syncEnvToConfig(projectDir) {
         const dotenvPath = resolve(projectRoot, '.env');
         const petsDir = resolve(projectRoot, ".pets");
         const petsConfigPath = resolve(petsDir, "config.json");
-        const gitignorePath = resolve(projectRoot, ".gitignore");
         const opencodeJsonPath = resolve(projectRoot, "opencode.json");
         logger.info(`Syncing .env to .pets/config.json in ${projectRoot}`);
         // Ensure .pets directory exists
@@ -387,8 +540,8 @@ export function syncEnvToConfig(projectDir) {
             mkdirSync(petsDir, { recursive: true });
             logger.debug(`Created .pets directory at ${petsDir}`);
         }
-        // Ensure .pets/ is in .gitignore
-        ensurePetsInGitignore(gitignorePath);
+        // Ensure .pets/ is in .git/info/exclude (local excludes, not tracked)
+        ensurePetsInGitExclude(projectRoot);
         // Load existing pets config or create new one
         let petsConfig = {
             enabled: [],
@@ -456,34 +609,22 @@ export function syncEnvToConfig(projectDir) {
         let syncedCount = 0;
         const syncedPets = [];
         // Create a "global" env config that applies to all pets
+        // We ONLY store in _global - pet-specific configs are for pet-specific overrides only
         if (!petsConfig.envConfig["_global"]) {
             petsConfig.envConfig["_global"] = {};
         }
-        // Sync all .env variables to the global config
+        // Sync all .env variables to the global config only
+        // Do NOT copy to each pet - that causes massive duplication
         for (const [key, value] of Object.entries(envVars)) {
             if (value && value.length > 0) {
                 petsConfig.envConfig["_global"][key] = value;
                 syncedCount++;
-                logger.debug(`Synced global: ${key}`);
+                logger.debug(`Synced to _global: ${key}`);
             }
         }
-        // Also sync to each configured pet's specific config
-        for (const petId of configuredPets) {
-            if (!petsConfig.envConfig[petId]) {
-                petsConfig.envConfig[petId] = {};
-            }
-            // Merge global config into pet-specific config
-            // Pet-specific values (if any) take precedence over global
-            const globalConfig = petsConfig.envConfig["_global"] || {};
-            const petConfig = petsConfig.envConfig[petId] || {};
-            petsConfig.envConfig[petId] = {
-                ...globalConfig,
-                ...petConfig,
-                // .env values override everything
-                ...envVars
-            };
-            syncedPets.push(petId);
-        }
+        // Note: We no longer copy _global to each pet's config
+        // The loadEnv() function handles merging _global with pet-specific at runtime
+        syncedPets.push("_global");
         // Update timestamp
         petsConfig.last_updated = new Date().toISOString();
         // Write config
@@ -501,21 +642,277 @@ export function syncEnvToConfig(projectDir) {
         return { success: false, message: `Failed to sync: ${error.message}`, synced: 0, pets: [] };
     }
 }
+// ============================================================================
+// READ-ONLY MODE FUNCTIONALITY
+// ============================================================================
+// Read-only mode prevents write operations from being registered for a pet.
+// This provides safety when users want to use a pet for read operations only.
+//
+// Configuration sources (in priority order, highest first):
+// 1. Environment variable: {PETNAME}_READ_ONLY=true (e.g., ASANA_READ_ONLY=true)
+// 2. Pet-specific config: .pets/config.json → petConfig.{petId}.readOnly: true
+// 3. Global config: .pets/config.json → petConfig._global.readOnly: true
+// ============================================================================
+/**
+ * Check if a pet is configured in read-only mode.
+ *
+ * Read-only mode prevents write tools from being registered for the pet.
+ * This is useful when users want to ensure they can only read data, not modify it.
+ *
+ * Configuration is checked in the following order (first match wins):
+ * 1. Environment variable: {PETNAME}_READ_ONLY=true (e.g., ASANA_READ_ONLY=true)
+ * 2. Pet-specific config in .pets/config.json: petConfig.{petId}.readOnly
+ * 3. Global config in .pets/config.json: petConfig._global.readOnly
+ *
+ * @param petId - The pet identifier (e.g., "asana", "jira", "github")
+ * @returns true if read-only mode is enabled for this pet
+ *
+ * @example
+ * ```typescript
+ * import { isReadOnly, createPlugin, type ToolDefinition } from "openpets-sdk"
+ *
+ * export const MyPlugin = async () => {
+ *   const readOnly = isReadOnly("my-plugin")
+ *
+ *   const readTools: ToolDefinition[] = [
+ *     { name: "my-plugin-list", ... },
+ *     { name: "my-plugin-get", ... }
+ *   ]
+ *
+ *   const writeTools: ToolDefinition[] = [
+ *     { name: "my-plugin-create", ... },
+ *     { name: "my-plugin-update", ... }
+ *   ]
+ *
+ *   // Only include write tools if not in read-only mode
+ *   const tools = readOnly ? readTools : [...readTools, ...writeTools]
+ *
+ *   return createPlugin(tools)
+ * }
+ * ```
+ */
+export function isReadOnly(petId) {
+    // 1. Check environment variable (highest priority)
+    // Normalize pet ID to uppercase with underscores for env var name
+    const envVarName = `${petId.toUpperCase().replace(/-/g, '_')}_READ_ONLY`;
+    const envValue = process.env[envVarName];
+    if (envValue !== undefined) {
+        const isEnabled = envValue.toLowerCase() === 'true' || envValue === '1';
+        logger.debug(`Read-only check for ${petId}: ENV ${envVarName}=${envValue} → ${isEnabled}`);
+        return isEnabled;
+    }
+    // 2. Check .pets/config.json (pet-specific, then global)
+    const petsConfig = loadPetsConfigForReadOnly();
+    if (petsConfig?.petConfig) {
+        // Check pet-specific setting first
+        const petSettings = petsConfig.petConfig[petId];
+        if (petSettings?.readOnly !== undefined) {
+            logger.debug(`Read-only check for ${petId}: petConfig.${petId}.readOnly=${petSettings.readOnly}`);
+            return petSettings.readOnly === true;
+        }
+        // Check global setting
+        const globalSettings = petsConfig.petConfig["_global"];
+        if (globalSettings?.readOnly !== undefined) {
+            logger.debug(`Read-only check for ${petId}: petConfig._global.readOnly=${globalSettings.readOnly}`);
+            return globalSettings.readOnly === true;
+        }
+    }
+    logger.debug(`Read-only check for ${petId}: no configuration found → false`);
+    return false;
+}
+/**
+ * Set read-only mode for a pet in .pets/config.json
+ *
+ * @param petId - The pet identifier (e.g., "asana", "jira"). Use "_global" for all pets.
+ * @param enabled - Whether read-only mode should be enabled
+ * @param projectDir - Optional project directory (defaults to cwd)
+ * @returns Result object with success status and message
+ */
+export function setReadOnly(petId, enabled, projectDir) {
+    const { writeFileSync, existsSync, mkdirSync } = require("fs");
+    try {
+        const projectRoot = projectDir || resolve(process.cwd());
+        const petsDir = resolve(projectRoot, ".pets");
+        const petsConfigPath = resolve(petsDir, "config.json");
+        // Ensure .pets directory exists
+        if (!existsSync(petsDir)) {
+            mkdirSync(petsDir, { recursive: true });
+            logger.debug(`Created .pets directory at ${petsDir}`);
+        }
+        // Ensure .pets/ is in .git/info/exclude
+        ensurePetsInGitExclude(projectRoot);
+        // Load existing config or create new one
+        let petsConfig = {
+            enabled: [],
+            disabled: [],
+            envConfig: {},
+            petConfig: {}
+        };
+        if (existsSync(petsConfigPath)) {
+            try {
+                const existing = JSON.parse(readFileSync(petsConfigPath, "utf-8"));
+                petsConfig = {
+                    enabled: existing.enabled || [],
+                    disabled: existing.disabled || [],
+                    envConfig: existing.envConfig || {},
+                    petConfig: existing.petConfig || {},
+                    ...existing
+                };
+            }
+            catch (error) {
+                logger.warn(`Could not parse existing .pets/config.json: ${error.message}`);
+            }
+        }
+        // Ensure petConfig structure exists
+        if (!petsConfig.petConfig) {
+            petsConfig.petConfig = {};
+        }
+        // Create or update pet-specific config
+        if (!petsConfig.petConfig[petId]) {
+            petsConfig.petConfig[petId] = {};
+        }
+        // Set the read-only value
+        petsConfig.petConfig[petId].readOnly = enabled;
+        // Update timestamp
+        petsConfig.last_updated = new Date().toISOString();
+        // Write config
+        writeFileSync(petsConfigPath, JSON.stringify(petsConfig, null, 2));
+        const modeStr = enabled ? "enabled" : "disabled";
+        const targetStr = petId === "_global" ? "all pets (global)" : `pet '${petId}'`;
+        logger.info(`Read-only mode ${modeStr} for ${targetStr}`);
+        return {
+            success: true,
+            message: `Read-only mode ${modeStr} for ${targetStr}`
+        };
+    }
+    catch (error) {
+        logger.error(`Failed to set read-only mode: ${error.message}`);
+        return { success: false, message: `Failed to set read-only mode: ${error.message}` };
+    }
+}
+/**
+ * Get read-only status for a pet or all pets
+ *
+ * @param petId - Optional pet identifier. If not provided, returns status for all configured pets.
+ * @param projectDir - Optional project directory (defaults to cwd)
+ * @returns Object with read-only status information
+ */
+export function getReadOnlyStatus(petId, projectDir) {
+    const projectRoot = projectDir || resolve(process.cwd());
+    const petsConfig = loadPetsConfigForReadOnly(projectRoot);
+    const result = {
+        global: petsConfig?.petConfig?.["_global"]?.readOnly,
+        pets: {},
+        envOverrides: {}
+    };
+    // Get all configured pet IDs
+    const petIds = [];
+    if (petId) {
+        petIds.push(petId);
+    }
+    else if (petsConfig?.petConfig) {
+        petIds.push(...Object.keys(petsConfig.petConfig).filter(k => k !== "_global"));
+    }
+    // Check each pet's status
+    for (const pid of petIds) {
+        // Check config
+        const petSettings = petsConfig?.petConfig?.[pid];
+        if (petSettings?.readOnly !== undefined) {
+            result.pets[pid] = petSettings.readOnly;
+        }
+        // Check env override
+        const envVarName = `${pid.toUpperCase().replace(/-/g, '_')}_READ_ONLY`;
+        const envValue = process.env[envVarName];
+        if (envValue !== undefined) {
+            result.envOverrides[pid] = envValue.toLowerCase() === 'true' || envValue === '1';
+        }
+    }
+    return result;
+}
+/**
+ * Helper to filter tools based on read-only mode.
+ * Use this in your pet's plugin factory to easily filter out write tools.
+ *
+ * @param tools - Array of tool definitions
+ * @param writePatterns - Array of patterns that identify write operations (e.g., ['create', 'update', 'delete'])
+ * @param isReadOnlyMode - Whether read-only mode is enabled
+ * @param logger - Optional logger for debug output
+ * @returns Filtered array of tools
+ *
+ * @example
+ * ```typescript
+ * const WRITE_PATTERNS = ['create', 'update', 'delete', 'add-comment']
+ * const filteredTools = filterToolsForReadOnly(allTools, WRITE_PATTERNS, isReadOnly('my-pet'))
+ * ```
+ */
+export function filterToolsForReadOnly(tools, writePatterns, isReadOnlyMode, debugLogger) {
+    if (!isReadOnlyMode) {
+        return tools;
+    }
+    const isWriteOperation = (toolName) => {
+        return writePatterns.some(pattern => toolName.includes(pattern));
+    };
+    const filteredTools = tools.filter(tool => !isWriteOperation(tool.name));
+    const excludedTools = tools.filter(tool => isWriteOperation(tool.name));
+    if (excludedTools.length > 0 && debugLogger) {
+        debugLogger.debug("Excluded write tools in read-only mode", {
+            excluded: excludedTools.map(t => t.name)
+        });
+    }
+    return filteredTools;
+}
 /**
- * Ensure .pets/ is in .gitignore
+ * Internal helper to load .pets/config.json for read-only checks.
+ * This is separate from the main loadEnv to avoid circular dependencies.
  */
-function ensurePetsInGitignore(gitignorePath) {
-    const { writeFileSync, existsSync, appendFileSync } = require("fs");
+function loadPetsConfigForReadOnly(projectDir) {
+    try {
+        const cwd = projectDir || resolve(process.cwd());
+        const petsConfigDirs = findPetsConfigDirs(cwd);
+        // Check from closest to furthest
+        for (const configDir of petsConfigDirs) {
+            const petsConfigPath = resolve(configDir, '.pets', 'config.json');
+            if (existsSync(petsConfigPath)) {
+                const config = JSON.parse(readFileSync(petsConfigPath, 'utf-8'));
+                return config;
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        logger.debug(`Could not load .pets/config.json: ${error.message}`);
+        return null;
+    }
+}
+/**
+ * Ensure .pets/ is in .git/info/exclude (local git excludes, not tracked)
+ * This avoids modifying .gitignore which would show up as a change
+ */
+function ensurePetsInGitExclude(projectRoot) {
+    const { writeFileSync, existsSync, mkdirSync } = require("fs");
     const petsIgnorePattern = ".pets/";
+    const gitDir = join(projectRoot, ".git");
+    const gitInfoDir = join(gitDir, "info");
+    const excludePath = join(gitInfoDir, "exclude");
     try {
-        if (!existsSync(gitignorePath)) {
-            // Create .gitignore with .pets/
-            writeFileSync(gitignorePath, `# OpenPets configuration (contains sensitive env vars)\n${petsIgnorePattern}\n`);
-            logger.info("Created .gitignore with .pets/ entry");
+        // Only proceed if this is a git repository
+        if (!existsSync(gitDir)) {
+            logger.debug("Not a git repository, skipping exclude setup");
+            return;
+        }
+        // Ensure .git/info directory exists
+        if (!existsSync(gitInfoDir)) {
+            mkdirSync(gitInfoDir, { recursive: true });
+            logger.debug("Created .git/info directory");
+        }
+        if (!existsSync(excludePath)) {
+            // Create exclude file with .pets/
+            writeFileSync(excludePath, `# git ls-files --others --exclude-from=.git/info/exclude\n# Lines that start with '#' are comments.\n\n# OpenPets configuration (contains sensitive env vars)\n${petsIgnorePattern}\n`);
+            logger.info("Created .git/info/exclude with .pets/ entry");
             return;
         }
-        // Check if .pets/ is already in .gitignore
-        const content = readFileSync(gitignorePath, "utf-8");
+        // Check if .pets/ is already in exclude
+        const content = readFileSync(excludePath, "utf-8");
         const lines = content.split('\n');
         // Check for various patterns that would ignore .pets
         const petsPatterns = ['.pets/', '.pets', '/.pets/', '/.pets', '**/.pets/', '**/.pets'];
@@ -524,17 +921,17 @@ function ensurePetsInGitignore(gitignorePath) {
             return petsPatterns.includes(trimmed) || trimmed === '.pets' || trimmed === '.pets/';
         });
         if (!isIgnored) {
-            // Append .pets/ to .gitignore
+            // Append .pets/ to exclude
             const newContent = content.endsWith('\n') ? content : content + '\n';
-            writeFileSync(gitignorePath, newContent + `\n# OpenPets configuration (contains sensitive env vars)\n${petsIgnorePattern}\n`);
-            logger.info("Added .pets/ to .gitignore");
+            writeFileSync(excludePath, newContent + `\n# OpenPets configuration (contains sensitive env vars)\n${petsIgnorePattern}\n`);
+            logger.info("Added .pets/ to .git/info/exclude");
         }
         else {
-            logger.debug(".pets/ already in .gitignore");
+            logger.debug(".pets/ already in .git/info/exclude");
         }
     }
     catch (error) {
-        logger.warn(`Could not update .gitignore: ${error.message}`);
+        logger.warn(`Could not update .git/info/exclude: ${error.message}`);
     }
 }
 //# sourceMappingURL=plugin-factory.js.map