@supercorks/skills-installer 1.10.0 → 1.11.1

package/README.md

@@ -27,7 +27,7 @@ npx @supercorks/skills-installer install
    - `.claude/agents/` (Claude)
    - Custom path of your choice
 
-3. **Gitignore option** - Optionally add the installation path to `.gitignore`
+3. **Gitignore option** - If launched from inside a git repository, optionally add the installation path to `.gitignore`
 
 4. **Select skills/subagents** - Interactive checkbox to pick what to install:
    - Use `↑`/`↓` to navigate

package/bin/install.js

@@ -27,6 +27,7 @@ import { fetchAvailableSubagents, fetchSubagentMetadata } from '../lib/subagents
 import { 
   sparseCloneSkills, 
   isGitAvailable, 
+  isInsideGitWorkTree,
   listCheckedOutSkills, 
   updateSparseCheckout,
   sparseCloneSubagents,
@@ -279,8 +280,14 @@ async function runSkillsInstallForTarget(skills, existingInstalls, target) {
 
   // Ask about .gitignore (only for fresh installs and if not already in .gitignore)
   let shouldGitignore = false;
+  const isInGitWorkTree = isInsideGitWorkTree();
   const gitignorePath = resolveInstallPath('.gitignore');
-  if (!isManageMode && !isHomePath(installPath) && !isInGitignore(gitignorePath, installPath)) {
+  if (
+    isInGitWorkTree &&
+    !isManageMode &&
+    !isHomePath(installPath) &&
+    !isInGitignore(gitignorePath, installPath)
+  ) {
     shouldGitignore = await promptGitignore(installPath);
   }
 
@@ -433,8 +440,14 @@ async function runSubagentsInstallForTarget(subagents, existingInstalls, target)
 
   // Ask about .gitignore (only for fresh installs and if not already in .gitignore)
   let shouldGitignore = false;
+  const isInGitWorkTree = isInsideGitWorkTree();
   const gitignorePath = resolveInstallPath('.gitignore');
-  if (!isManageMode && !isHomePath(installPath) && !isInGitignore(gitignorePath, installPath)) {
+  if (
+    isInGitWorkTree &&
+    !isManageMode &&
+    !isHomePath(installPath) &&
+    !isInGitignore(gitignorePath, installPath)
+  ) {
     shouldGitignore = await promptGitignore(installPath);
   }
 

package/lib/git.js

@@ -5,9 +5,16 @@
 import { execSync, spawn } from 'child_process';
 import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync, appendFileSync, readdirSync } from 'fs';
 import { join, resolve } from 'path';
+import { homedir } from 'os';
 import { getRepoUrl } from './skills.js';
 import { getSubagentsRepoUrl } from './subagents.js';
 
+function resolvePath(path) {
+  if (path === '~') return homedir();
+  if (path.startsWith('~/')) return resolve(homedir(), path.slice(2));
+  return resolve(path);
+}
+
 /**
  * Check if git is available
  * @returns {boolean}
@@ -21,6 +28,24 @@ export function isGitAvailable() {
   }
 }
 
+/**
+ * Check whether a directory is inside a git work tree
+ * @param {string} path - Directory to check
+ * @returns {boolean}
+ */
+export function isInsideGitWorkTree(path = process.cwd()) {
+  const absolutePath = resolvePath(path);
+  try {
+    const output = execSync('git rev-parse --is-inside-work-tree', {
+      cwd: absolutePath,
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).toString().trim();
+    return output === 'true';
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Execute a git command and return the result
  * @param {string[]} args - Git command arguments
@@ -52,6 +77,44 @@ function runGitCommand(args, cwd) {
   });
 }
 
+async function getDefaultRemoteBranch(cwd) {
+  try {
+    const output = await runGitCommand(['ls-remote', '--symref', 'origin', 'HEAD'], cwd);
+    const match = output.match(/ref:\s+refs\/heads\/([^\s]+)\s+HEAD/);
+    return match?.[1] || 'main';
+  } catch {
+    return 'main';
+  }
+}
+
+async function configureSparseCheckout(cwd, patterns) {
+  await runGitCommand(['sparse-checkout', 'init', '--no-cone'], cwd);
+  const sparseCheckoutPath = join(cwd, '.git', 'info', 'sparse-checkout');
+  writeFileSync(sparseCheckoutPath, patterns + '\n');
+}
+
+async function initializeRepoInExistingDirectory(cwd, repoUrl, patterns, onProgress) {
+  onProgress('Initializing git repository in existing directory...');
+  await runGitCommand(['init'], cwd);
+
+  try {
+    await runGitCommand(['remote', 'set-url', 'origin', repoUrl], cwd);
+  } catch {
+    await runGitCommand(['remote', 'add', 'origin', repoUrl], cwd);
+  }
+
+  onProgress('Fetching repository...');
+  await runGitCommand(['fetch', 'origin'], cwd);
+
+  onProgress('Configuring sparse-checkout...');
+  await configureSparseCheckout(cwd, patterns);
+
+  const defaultBranch = await getDefaultRemoteBranch(cwd);
+
+  onProgress('Checking out files...');
+  await runGitCommand(['checkout', '-B', defaultBranch, `origin/${defaultBranch}`], cwd);
+}
+
 /**
  * Perform a sparse clone of the repository with only selected skills
  * This method preserves full git history and allows push capability
@@ -63,17 +126,20 @@ function runGitCommand(args, cwd) {
  */
 export async function sparseCloneSkills(targetPath, skillFolders, onProgress = () => {}) {
   const repoUrl = getRepoUrl();
-  const absolutePath = resolve(targetPath);
+  const absolutePath = resolvePath(targetPath);
+  const existedBefore = existsSync(absolutePath);
+  const patterns = skillFolders.map(folder => `/${folder}/`).join('\n');
+  let shouldAdoptExistingDirectory = false;
   
   // Check if target already exists and has content
-  if (existsSync(absolutePath)) {
+  if (existedBefore) {
     const gitDir = join(absolutePath, '.git');
     if (existsSync(gitDir)) {
       throw new Error(`Directory "${targetPath}" already contains a git repository. Please remove it first or choose a different path.`);
     }
     const entries = readdirSync(absolutePath).filter(name => name !== '.DS_Store');
     if (entries.length > 0) {
-      throw new Error(`Directory "${targetPath}" already exists and is not empty. Choose an empty directory or an existing managed installation.`);
+      shouldAdoptExistingDirectory = true;
     }
   }
 
@@ -81,43 +147,39 @@ export async function sparseCloneSkills(targetPath, skillFolders, onProgress = (
   mkdirSync(absolutePath, { recursive: true });
 
   try {
-    // Clone with blob filter for minimal download, no checkout yet
-    onProgress('Initializing sparse clone...');
-    await runGitCommand([
-      'clone',
-      '--filter=blob:none',
-      '--no-checkout',
-      '--sparse',
-      repoUrl,
-      '.'
-    ], absolutePath);
-
-    // Use non-cone mode for precise control over what's checked out
-    // This prevents root-level files (README.md, etc.) from being included
-    onProgress('Configuring sparse-checkout...');
-    await runGitCommand([
-      'sparse-checkout',
-      'init',
-      '--no-cone'
-    ], absolutePath);
-
-    // Write explicit patterns - only skill folders, no root files
-    // Format: /folder/* includes everything in that folder recursively
-    const sparseCheckoutPath = join(absolutePath, '.git', 'info', 'sparse-checkout');
-    const patterns = skillFolders.map(folder => `/${folder}/`).join('\n');
-    writeFileSync(sparseCheckoutPath, patterns + '\n');
-
-    // Checkout the files
-    onProgress('Checking out files...');
-    await runGitCommand(['checkout'], absolutePath);
+    if (shouldAdoptExistingDirectory) {
+      await initializeRepoInExistingDirectory(absolutePath, repoUrl, patterns, onProgress);
+    } else {
+      // Clone with blob filter for minimal download, no checkout yet
+      onProgress('Initializing sparse clone...');
+      await runGitCommand([
+        'clone',
+        '--filter=blob:none',
+        '--no-checkout',
+        '--sparse',
+        repoUrl,
+        '.'
+      ], absolutePath);
+
+      // Use non-cone mode for precise control over what's checked out
+      // This prevents root-level files (README.md, etc.) from being included
+      onProgress('Configuring sparse-checkout...');
+      await configureSparseCheckout(absolutePath, patterns);
+
+      // Checkout the files
+      onProgress('Checking out files...');
+      await runGitCommand(['checkout'], absolutePath);
+    }
 
     onProgress('Done!');
   } catch (error) {
     // Clean up on failure
-    try {
-      rmSync(absolutePath, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
+    if (!existedBefore) {
+      try {
+        rmSync(absolutePath, { recursive: true, force: true });
+      } catch {
+        // Ignore cleanup errors
+      }
     }
     throw error;
   }
@@ -132,7 +194,7 @@ export async function sparseCloneSkills(targetPath, skillFolders, onProgress = (
  * @returns {Promise<void>}
  */
 export async function updateSparseCheckout(repoPath, skillFolders, onProgress = () => {}) {
-  const absolutePath = resolve(repoPath);
+  const absolutePath = resolvePath(repoPath);
   
   if (!existsSync(join(absolutePath, '.git'))) {
     throw new Error(`"${repoPath}" is not a git repository`);
@@ -166,7 +228,7 @@ export async function updateSparseCheckout(repoPath, skillFolders, onProgress =
  * @returns {Promise<void>}
  */
 export async function addSkillsToSparseCheckout(repoPath, skillFolders) {
-  const absolutePath = resolve(repoPath);
+  const absolutePath = resolvePath(repoPath);
   
   if (!existsSync(join(absolutePath, '.git'))) {
     throw new Error(`"${repoPath}" is not a git repository`);
@@ -187,7 +249,7 @@ export async function addSkillsToSparseCheckout(repoPath, skillFolders) {
  * @returns {Promise<string[]>} List of skill folder names
  */
 export async function listCheckedOutSkills(repoPath) {
-  const absolutePath = resolve(repoPath);
+  const absolutePath = resolvePath(repoPath);
   
   if (!existsSync(join(absolutePath, '.git'))) {
     throw new Error(`"${repoPath}" is not a git repository`);
@@ -214,7 +276,7 @@ export async function listCheckedOutSkills(repoPath) {
  * @returns {Promise<string>}
  */
 export async function pullUpdates(repoPath) {
-  const absolutePath = resolve(repoPath);
+  const absolutePath = resolvePath(repoPath);
   return runGitCommand(['pull'], absolutePath);
 }
 
@@ -225,7 +287,7 @@ export async function pullUpdates(repoPath) {
  * @returns {Promise<Set<string>>} Set of skill folder names that need updates
  */
 export async function checkSkillsForUpdates(repoPath, skillFolders) {
-  const absolutePath = resolve(repoPath);
+  const absolutePath = resolvePath(repoPath);
   const needsUpdate = new Set();
   
   if (!existsSync(join(absolutePath, '.git'))) {
@@ -272,7 +334,7 @@ export async function checkSkillsForUpdates(repoPath, skillFolders) {
  * @returns {Promise<Set<string>>} Set of agent filenames that need updates
  */
 export async function checkSubagentsForUpdates(repoPath, agentFilenames) {
-  const absolutePath = resolve(repoPath);
+  const absolutePath = resolvePath(repoPath);
   const needsUpdate = new Set();
   
   if (!existsSync(join(absolutePath, '.git'))) {
@@ -324,17 +386,20 @@ export async function checkSubagentsForUpdates(repoPath, agentFilenames) {
  */
 export async function sparseCloneSubagents(targetPath, agentFilenames, onProgress = () => {}) {
   const repoUrl = getSubagentsRepoUrl();
-  const absolutePath = resolve(targetPath);
+  const absolutePath = resolvePath(targetPath);
+  const existedBefore = existsSync(absolutePath);
+  const patterns = agentFilenames.map(filename => `/${filename}`).join('\n');
+  let shouldAdoptExistingDirectory = false;
   
   // Check if target already exists and has content
-  if (existsSync(absolutePath)) {
+  if (existedBefore) {
     const gitDir = join(absolutePath, '.git');
     if (existsSync(gitDir)) {
       throw new Error(`Directory "${targetPath}" already contains a git repository. Please remove it first or choose a different path.`);
     }
     const entries = readdirSync(absolutePath).filter(name => name !== '.DS_Store');
     if (entries.length > 0) {
-      throw new Error(`Directory "${targetPath}" already exists and is not empty. Choose an empty directory or an existing managed installation.`);
+      shouldAdoptExistingDirectory = true;
     }
   }
 
@@ -342,41 +407,38 @@ export async function sparseCloneSubagents(targetPath, agentFilenames, onProgres
   mkdirSync(absolutePath, { recursive: true });
 
   try {
-    // Clone with blob filter for minimal download, no checkout yet
-    onProgress('Initializing sparse clone...');
-    await runGitCommand([
-      'clone',
-      '--filter=blob:none',
-      '--no-checkout',
-      '--sparse',
-      repoUrl,
-      '.'
-    ], absolutePath);
-
-    // Use non-cone mode for precise control over what's checked out
-    onProgress('Configuring sparse-checkout...');
-    await runGitCommand([
-      'sparse-checkout',
-      'init',
-      '--no-cone'
-    ], absolutePath);
-
-    // Write explicit patterns - only selected agent files
-    const sparseCheckoutPath = join(absolutePath, '.git', 'info', 'sparse-checkout');
-    const patterns = agentFilenames.map(filename => `/${filename}`).join('\n');
-    writeFileSync(sparseCheckoutPath, patterns + '\n');
-
-    // Checkout the files
-    onProgress('Checking out files...');
-    await runGitCommand(['checkout'], absolutePath);
+    if (shouldAdoptExistingDirectory) {
+      await initializeRepoInExistingDirectory(absolutePath, repoUrl, patterns, onProgress);
+    } else {
+      // Clone with blob filter for minimal download, no checkout yet
+      onProgress('Initializing sparse clone...');
+      await runGitCommand([
+        'clone',
+        '--filter=blob:none',
+        '--no-checkout',
+        '--sparse',
+        repoUrl,
+        '.'
+      ], absolutePath);
+
+      // Use non-cone mode for precise control over what's checked out
+      onProgress('Configuring sparse-checkout...');
+      await configureSparseCheckout(absolutePath, patterns);
+
+      // Checkout the files
+      onProgress('Checking out files...');
+      await runGitCommand(['checkout'], absolutePath);
+    }
 
     onProgress('Done!');
   } catch (error) {
     // Clean up on failure
-    try {
-      rmSync(absolutePath, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
+    if (!existedBefore) {
+      try {
+        rmSync(absolutePath, { recursive: true, force: true });
+      } catch {
+        // Ignore cleanup errors
+      }
     }
     throw error;
   }
@@ -390,7 +452,7 @@ export async function sparseCloneSubagents(targetPath, agentFilenames, onProgres
  * @returns {Promise<void>}
  */
 export async function updateSubagentsSparseCheckout(repoPath, agentFilenames, onProgress = () => {}) {
-  const absolutePath = resolve(repoPath);
+  const absolutePath = resolvePath(repoPath);
   
   if (!existsSync(join(absolutePath, '.git'))) {
     throw new Error(`"${repoPath}" is not a git repository`);
@@ -423,7 +485,7 @@ export async function updateSubagentsSparseCheckout(repoPath, agentFilenames, on
  * @returns {Promise<string[]>} List of agent filenames
  */
 export async function listCheckedOutSubagents(repoPath) {
-  const absolutePath = resolve(repoPath);
+  const absolutePath = resolvePath(repoPath);
   
   if (!existsSync(join(absolutePath, '.git'))) {
     throw new Error(`"${repoPath}" is not a git repository`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supercorks/skills-installer",
-  "version": "1.10.0",
+  "version": "1.11.1",
   "description": "Interactive CLI installer for AI agent skills and subagents",
   "type": "module",
   "bin": {