shadow-git 0.1.0 → 1.0.3

package/src/commands/track/destroy.ts

@@ -1,21 +1,68 @@
-import { join } from 'node:path';
-import { readFile, writeFile, rm } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { readFile, writeFile, rm, rmdir, unlink } from 'node:fs/promises';
 import { createInterface } from 'node:readline';
 import { findRoot, validateShadowRepo } from '../../core/repository.js';
 import { uninstallMainHook } from '../../core/hooks.js';
-import { SGIT_MARKER, SGIT_MANAGED_HEADER } from '../../core/exclude.js';
+import { execGit } from '../../core/git.js';
+import { SGIT_BLOCK_START, SGIT_BLOCK_END } from '../../core/exclude.js';
 import * as logger from '../../utils/logger.js';
 
 export async function trackDestroy(opts: {
   force?: boolean;
+  keepFiles?: boolean;
 }): Promise<void> {
   const root = await findRoot();
   await validateShadowRepo(root);
+  const sgitDir = join(root, '.sgit');
+
+  // Get list of tracked files (for deletion and status check)
+  let trackedFiles: string[] = [];
+  try {
+    const output = await execGit(['ls-tree', '-r', '--name-only', 'HEAD'], {
+      gitDir: sgitDir,
+      workTree: root,
+    });
+    if (output.trim()) {
+      trackedFiles = output.trim().split('\n').filter(f => f !== '.sgit.json');
+    }
+  } catch {
+    // Empty repo or no commits
+  }
+
+  // Check for uncommitted changes
+  let uncommittedStatus = '';
+  try {
+    uncommittedStatus = await execGit(['status', '--porcelain'], {
+      gitDir: sgitDir,
+      workTree: root,
+    });
+  } catch {
+    // Ignore
+  }
+  const hasUncommitted = uncommittedStatus.trim().length > 0;
 
   if (!opts.force) {
-    const confirmed = await confirm(
-      'This will permanently remove the shadow repository. Continue?',
-    );
+    // Show uncommitted changes warning if any
+    if (hasUncommitted) {
+      logger.warn('there are uncommitted changes in the shadow repository:');
+      for (const line of uncommittedStatus.trim().split('\n')) {
+        logger.info(`  ${line}`);
+      }
+      process.stdout.write('\n');
+    }
+
+    let message: string;
+    if (opts.keepFiles) {
+      message = hasUncommitted
+        ? 'This will remove the shadow repository. Tracked files remain on disk but shadow history will be lost. Continue?'
+        : 'This will remove the shadow repository. Tracked files will remain on disk. Continue?';
+    } else {
+      message = hasUncommitted
+        ? `This will permanently remove the shadow repository and delete ${trackedFiles.length} tracked file(s). Uncommitted changes will be lost. Continue?`
+        : `This will permanently remove the shadow repository and delete ${trackedFiles.length} tracked file(s). Continue?`;
+    }
+
+    const confirmed = await confirm(message);
     if (!confirmed) {
       logger.info('Aborted.');
       return;
@@ -28,24 +75,21 @@ export async function trackDestroy(opts: {
     const content = await readFile(excludePath, 'utf-8');
     const lines = content.split('\n');
     const result: string[] = [];
+    let insideBlock = false;
     let skipNext = false;
     for (const line of lines) {
-      if (line === SGIT_MANAGED_HEADER) {
-        skipNext = false;
-        continue;
-      }
-      if (line === SGIT_MARKER) {
-        skipNext = true;
-        continue;
-      }
-      // Strip legacy inline-comment format: "entry # sgit"
-      if (line.endsWith(` ${SGIT_MARKER}`)) {
+      if (line === SGIT_BLOCK_START || line === '# sgit-managed (do not edit below this line)') {
+        insideBlock = true;
         continue;
       }
-      if (skipNext) {
-        skipNext = false;
+      if (line === SGIT_BLOCK_END) {
+        insideBlock = false;
         continue;
       }
+      if (insideBlock) continue;
+      if (line === '# sgit') { skipNext = true; continue; }
+      if (skipNext) { skipNext = false; continue; }
+      if (line.endsWith(' # sgit')) continue;
       result.push(line);
     }
     const cleaned = result.join('\n');
@@ -58,13 +102,47 @@ export async function trackDestroy(opts: {
   // Uninstall main repo hook
   await uninstallMainHook(root);
 
+  // Delete tracked files if not keeping
+  if (!opts.keepFiles && trackedFiles.length > 0) {
+    for (const file of trackedFiles) {
+      try {
+        await unlink(join(root, file));
+      } catch {
+        // File might already be missing
+      }
+    }
+
+    // Clean up empty directories (bottom-up)
+    const dirs = new Set<string>();
+    for (const file of trackedFiles) {
+      let dir = dirname(file);
+      while (dir !== '.') {
+        dirs.add(dir);
+        dir = dirname(dir);
+      }
+    }
+    // Sort longest first so we delete deepest directories first
+    const sortedDirs = [...dirs].sort((a, b) => b.length - a.length);
+    for (const dir of sortedDirs) {
+      try {
+        await rmdir(join(root, dir));
+      } catch {
+        // Directory not empty or doesn't exist — skip
+      }
+    }
+  }
+
   // Delete .sgit/
   await rm(join(root, '.sgit'), { recursive: true, force: true });
 
   // Delete .sgit.json
   await rm(join(root, '.sgit.json'), { force: true });
 
-  logger.success('Shadow repository removed.');
+  if (opts.keepFiles) {
+    logger.success('Shadow repository removed. Tracked files kept on disk.');
+  } else {
+    logger.success('Shadow repository and tracked files removed.');
+  }
 }
 
 async function confirm(message: string): Promise<boolean> {

package/src/commands/track/ignore.ts

@@ -0,0 +1,55 @@
+import { join } from 'node:path';
+import { findRoot, validateShadowRepo } from '../../core/repository.js';
+import { execGit } from '../../core/git.js';
+import { normalizePath, isPathCoveredByManifest } from '../../core/paths.js';
+import { addIgnore, readManifest } from '../../core/manifest.js';
+import { syncExcludes } from './sync.js';
+import { PathNotTrackedError } from '../../core/errors.js';
+import * as logger from '../../utils/logger.js';
+
+export async function trackIgnore(paths: string[]): Promise<void> {
+  const root = await findRoot();
+  await validateShadowRepo(root);
+  const sgitDir = join(root, '.sgit');
+
+  const added: string[] = [];
+
+  for (const inputPath of paths) {
+    const normalized = await normalizePath(inputPath, root);
+
+    // Must be covered by a tracked path
+    const manifest = await readManifest(root);
+    if (!isPathCoveredByManifest(normalized, manifest.paths)) {
+      throw new PathNotTrackedError(normalized);
+    }
+
+    // Add to ignore list
+    const wasAdded = await addIgnore(root, normalized);
+    if (wasAdded) {
+      added.push(normalized);
+
+      // Untrack from shadow repo index if tracked
+      const rmPath = normalized.endsWith('/') ? normalized.slice(0, -1) : normalized;
+      try {
+        const rmArgs = normalized.endsWith('/')
+          ? ['rm', '--cached', '-r', rmPath]
+          : ['rm', '--cached', rmPath];
+        await execGit(rmArgs, { gitDir: sgitDir, workTree: root });
+      } catch {
+        // Not in index
+      }
+    }
+  }
+
+  // Sync exclude files
+  await syncExcludes(root);
+
+  if (added.length > 0) {
+    logger.success(`Ignoring ${added.length} path(s):`);
+    for (const p of added) {
+      logger.info(`  ${p}`);
+    }
+  } else {
+    logger.info('All paths already ignored.');
+  }
+}

package/src/commands/track/index.ts

@@ -7,7 +7,10 @@ import { trackAdd } from './add.js';
 import { trackRemove } from './remove.js';
 import { trackList } from './list.js';
 import { trackVerify } from './verify.js';
+import { trackClone } from './clone.js';
 import { trackDestroy } from './destroy.js';
+import { trackIgnore } from './ignore.js';
+import { trackUnignore } from './unignore.js';
 import { trackCompletion } from './completion.js';
 
 export function registerTrackCommands(program: Command): void {
@@ -20,6 +23,12 @@ export function registerTrackCommands(program: Command): void {
     .description('Initialize shadow repository')
     .action(wrapAction(trackInit));
 
+  track
+    .command('clone')
+    .description('Clone a shadow repository from a remote URL')
+    .argument('<url>')
+    .action(wrapAction(async (url: string) => trackClone(url)));
+
   track
     .command('add')
     .description('Start shadow-tracking paths')
@@ -54,12 +63,25 @@ export function registerTrackCommands(program: Command): void {
       ),
     );
 
+  track
+    .command('ignore')
+    .description('Ignore paths within tracked directories')
+    .argument('<paths...>')
+    .action(wrapAction(async (paths: string[]) => trackIgnore(paths)));
+
+  track
+    .command('unignore')
+    .description('Stop ignoring paths within tracked directories')
+    .argument('<paths...>')
+    .action(wrapAction(async (paths: string[]) => trackUnignore(paths)));
+
   track
     .command('destroy')
     .description('Remove shadow repository entirely')
     .option('--force', 'Skip confirmation prompt')
+    .option('--keep-files', 'Keep tracked files on disk (default: delete them)')
     .action(
-      wrapAction(async (opts: { force?: boolean }) => trackDestroy(opts)),
+      wrapAction(async (opts: { force?: boolean; keepFiles?: boolean }) => trackDestroy(opts)),
     );
 
   track

package/src/commands/track/init.ts

@@ -5,6 +5,7 @@ import {
   findRoot,
   validateNotWorktree,
   validateNotSubmodule,
+  validateGitIdentity,
 } from '../../core/repository.js';
 import { execGit } from '../../core/git.js';
 import { writeManifest } from '../../core/manifest.js';
@@ -12,7 +13,7 @@ import {
   generateMainExclude,
   generateShadowExclude,
 } from '../../core/exclude.js';
-import { installMainHook, installShadowHook } from '../../core/hooks.js';
+import { installMainHook, installShadowHook, installShadowSyncHooks } from '../../core/hooks.js';
 import { AlreadyInitializedError } from '../../core/errors.js';
 import * as logger from '../../utils/logger.js';
 
@@ -20,6 +21,7 @@ export async function trackInit(): Promise<void> {
   const root = await findRoot();
   await validateNotWorktree(root);
   await validateNotSubmodule(root);
+  await validateGitIdentity(root);
 
   const sgitDir = join(root, '.sgit');
 
@@ -63,7 +65,7 @@ export async function trackInit(): Promise<void> {
   );
 
   // Create .sgit.json
-  await writeManifest(root, { paths: [] });
+  await writeManifest(root, { paths: [], ignore: [] });
 
   // Update .git/info/exclude
   const mainExcludePath = join(root, '.git', 'info', 'exclude');
@@ -79,6 +81,7 @@ export async function trackInit(): Promise<void> {
   // Install hooks
   await installMainHook(root);
   await installShadowHook(sgitDir);
+  await installShadowSyncHooks(sgitDir);
 
   // Stage and commit .sgit.json
   await execGit(['add', '-f', '.sgit.json'], {

package/src/commands/track/sync.ts

@@ -29,7 +29,7 @@ export async function syncExcludes(root: string): Promise<void> {
   // Regenerate .sgit/info/exclude
   const sgitExcludePath = join(root, '.sgit', 'info', 'exclude');
   await mkdir(join(root, '.sgit', 'info'), { recursive: true });
-  await writeFile(sgitExcludePath, generateShadowExclude(manifest.paths));
+  await writeFile(sgitExcludePath, generateShadowExclude(manifest.paths, manifest.ignore));
 
   // Warn for missing paths
   for (const p of manifest.paths) {

package/src/commands/track/unignore.ts

@@ -0,0 +1,50 @@
+import { resolve, relative, sep } from 'node:path';
+import { findRoot, validateShadowRepo } from '../../core/repository.js';
+import { removeIgnore, readManifest } from '../../core/manifest.js';
+import { syncExcludes } from './sync.js';
+import { SgitError } from '../../core/errors.js';
+import * as logger from '../../utils/logger.js';
+
+export async function trackUnignore(paths: string[]): Promise<void> {
+  const root = await findRoot();
+  await validateShadowRepo(root);
+
+  const removed: string[] = [];
+
+  for (const inputPath of paths) {
+    // Normalize without stat (same approach as remove.ts)
+    const absolute = resolve(process.cwd(), inputPath);
+    let normalized = relative(root, absolute).split(sep).join('/');
+    if (inputPath.endsWith('/') && !normalized.endsWith('/')) {
+      normalized += '/';
+    }
+
+    // Find matching entry in ignore list (try exact, with/without trailing slash)
+    const manifest = await readManifest(root);
+    const exactPath =
+      manifest.ignore.find((p) => p === normalized) ||
+      manifest.ignore.find((p) => p === normalized + '/') ||
+      (normalized.endsWith('/')
+        ? manifest.ignore.find((p) => p === normalized.slice(0, -1))
+        : undefined);
+
+    if (!exactPath) {
+      throw new SgitError(`${normalized} is not in the ignore list`);
+    }
+
+    const wasRemoved = await removeIgnore(root, exactPath);
+    if (wasRemoved) {
+      removed.push(exactPath);
+    }
+  }
+
+  // Sync exclude files
+  await syncExcludes(root);
+
+  if (removed.length > 0) {
+    logger.success(`Unignored ${removed.length} path(s):`);
+    for (const p of removed) {
+      logger.info(`  ${p}`);
+    }
+  }
+}

package/src/commands/track/verify.ts

@@ -3,6 +3,7 @@ import { findRoot, validateShadowRepo } from '../../core/repository.js';
 import { execGit } from '../../core/git.js';
 import { readManifest } from '../../core/manifest.js';
 import { isPathCoveredByManifest } from '../../core/paths.js';
+import { findStaleGitignores, isGuardActive } from '../../core/gitignore.js';
 import { SgitError } from '../../core/errors.js';
 import * as logger from '../../utils/logger.js';
 
@@ -13,44 +14,116 @@ export interface VerifyResult {
 
 export async function verifyMain(root: string): Promise<VerifyResult> {
   const manifest = await readManifest(root);
-  let staged: string;
+  const violations: string[] = [];
+
+  // Check for stale .gitignore-sgit.bat (skip if a guard is active)
+  if (!isGuardActive(root)) {
+    const stale = findStaleGitignores(root, manifest.paths);
+    violations.push(
+      ...stale.map(
+        (f) => `${f} (stale .gitignore-sgit.bat — rename back to .gitignore)`,
+      ),
+    );
+  }
+
+  // Check staged files aren't shadow-tracked (exclude deletions — removing
+  // a shadow-tracked file from main git is correct behavior)
   try {
-    staged = await execGit(['diff', '--cached', '--name-only'], {
+    const staged = await execGit(['diff', '--cached', '--name-only', '--diff-filter=ACMR'], {
       gitDir: join(root, '.git'),
       workTree: root,
     });
+    if (staged.trim()) {
+      const stagedFiles = staged.trim().split('\n');
+      violations.push(
+        ...stagedFiles.filter((f) => isPathCoveredByManifest(f, manifest.paths, manifest.ignore)),
+      );
+    }
   } catch {
-    return { valid: true, violations: [] };
+    // No staged files
   }
 
-  if (!staged.trim()) return { valid: true, violations: [] };
-
-  const stagedFiles = staged.trim().split('\n');
-  const violations = stagedFiles.filter((f) =>
-    isPathCoveredByManifest(f, manifest.paths),
-  );
-
   return { valid: violations.length === 0, violations };
 }
 
 export async function verifyShadow(root: string): Promise<VerifyResult> {
-  const manifest = await readManifest(root);
-  let staged: string;
+  let manifest: { paths: string[]; ignore: string[] };
+  try {
+    manifest = await readManifest(root);
+  } catch {
+    // .sgit.json is missing or corrupt on disk — flag it
+    return {
+      valid: false,
+      violations: ['.sgit.json (missing or invalid on disk)'],
+    };
+  }
+  const sgitDir = join(root, '.sgit');
+  const violations: string[] = [];
+
+  // Check for stale .gitignore-sgit.bat (skip if a guard is active)
+  if (!isGuardActive(root)) {
+    const stale = findStaleGitignores(root, manifest.paths);
+    violations.push(
+      ...stale.map(
+        (f) => `${f} (stale .gitignore-sgit.bat — rename back to .gitignore)`,
+      ),
+    );
+  }
+
+  // Check .sgit.json is not staged for deletion
   try {
-    staged = await execGit(['diff', '--cached', '--name-only'], {
-      gitDir: join(root, '.sgit'),
+    const deleted = await execGit(['diff', '--cached', '--name-only', '--diff-filter=D'], {
+      gitDir: sgitDir,
       workTree: root,
     });
+    if (deleted.trim().split('\n').includes('.sgit.json')) {
+      violations.push('.sgit.json (cannot delete sgit manifest)');
+    }
   } catch {
-    return { valid: true, violations: [] };
+    // No deletions
   }
 
-  if (!staged.trim()) return { valid: true, violations: [] };
+  // If .sgit.json is staged with modifications, verify content is valid
+  try {
+    const modified = await execGit(['diff', '--cached', '--name-only', '--diff-filter=M'], {
+      gitDir: sgitDir,
+      workTree: root,
+    });
+    if (modified.trim().split('\n').includes('.sgit.json')) {
+      const content = await execGit(['show', ':0:.sgit.json'], {
+        gitDir: sgitDir,
+        workTree: root,
+      });
+      try {
+        const parsed = JSON.parse(content);
+        if (!Array.isArray(parsed.paths)) {
+          violations.push('.sgit.json (invalid: missing "paths" array)');
+        }
+      } catch {
+        violations.push('.sgit.json (invalid JSON)');
+      }
+    }
+  } catch {
+    // No modifications
+  }
 
-  const stagedFiles = staged.trim().split('\n');
-  const violations = stagedFiles.filter(
-    (f) => f !== '.sgit.json' && !isPathCoveredByManifest(f, manifest.paths),
-  );
+  // Check staged files are covered by manifest
+  try {
+    const staged = await execGit(['diff', '--cached', '--name-only'], {
+      gitDir: sgitDir,
+      workTree: root,
+    });
+    if (staged.trim()) {
+      const stagedFiles = staged.trim().split('\n');
+      violations.push(
+        ...stagedFiles.filter(
+          (f) => f !== '.sgit.json' && !isPathCoveredByManifest(f, manifest.paths, manifest.ignore),
+        ),
+      );
+    }
+  } catch {
+    // No staged files
+  }
 
   return { valid: violations.length === 0, violations };
 }

package/src/core/errors.ts

@@ -7,7 +7,15 @@ export class SgitError extends Error {
 
 export class NotGitRepoError extends SgitError {
   constructor() {
-    super('not a git repository');
+    super('not a git repository (no .git in current directory)');
+  }
+}
+
+export class NoGitIdentityError extends SgitError {
+  constructor() {
+    super(
+      'git user identity not configured; set user.name and user.email with \'git config\'',
+    );
   }
 }
 
@@ -19,7 +27,7 @@ export class AlreadyInitializedError extends SgitError {
 
 export class NotInitializedError extends SgitError {
   constructor() {
-    super('not a shadow git repository; run \'sgit track init\' first');
+    super('not a shadow git repository; run \'sgit track init\' or \'sgit track clone <url>\'');
   }
 }
 
@@ -40,3 +48,16 @@ export class PathNotTrackedError extends SgitError {
     super(`${path} is not tracked by sgit`);
   }
 }
+
+export class StaleGitignoreError extends SgitError {
+  constructor(files: string[]) {
+    super(
+      [
+        'found stale .gitignore-sgit.bat files (a previous sgit command did not complete cleanly):',
+        ...files.map((f) => `  ${f}`),
+        '',
+        'rename them back to .gitignore manually, then retry.',
+      ].join('\n'),
+    );
+  }
+}