shadow-git 0.1.0 → 1.0.2

package/src/core/exclude.ts

@@ -1,31 +1,29 @@
-export const SGIT_MARKER = '# sgit';
-export const SGIT_MANAGED_HEADER = '# sgit-managed (do not edit below this line)';
+export const SGIT_BLOCK_START = '# sgit-managed';
+export const SGIT_BLOCK_END = '# end: sgit-managed';
 
 export function generateMainExclude(
   existingContent: string,
   manifestPaths: string[],
 ): string {
-  // Preserve non-sgit lines, stripping marker lines and their associated entries
+  // Preserve lines outside the managed block, stripping legacy formats too
   const lines = existingContent.split('\n');
   const preserved: string[] = [];
+  let insideBlock = false;
   let skipNext = false;
   for (const line of lines) {
-    if (line === SGIT_MANAGED_HEADER) {
-      skipNext = false;
+    if (line === SGIT_BLOCK_START || line === '# sgit-managed (do not edit below this line)') {
+      insideBlock = true;
       continue;
     }
-    if (line === SGIT_MARKER) {
-      skipNext = true;
-      continue;
-    }
-    // Strip legacy inline-comment format: "entry # sgit"
-    if (line.endsWith(` ${SGIT_MARKER}`)) {
-      continue;
-    }
-    if (skipNext) {
-      skipNext = false;
+    if (line === SGIT_BLOCK_END) {
+      insideBlock = false;
       continue;
     }
+    if (insideBlock) continue;
+    // Strip legacy per-line marker and the entry that follows it
+    if (line === '# sgit') { skipNext = true; continue; }
+    if (skipNext) { skipNext = false; continue; }
+    if (line.endsWith(' # sgit')) continue;
     preserved.push(line);
   }
 
@@ -34,68 +32,67 @@ export function generateMainExclude(
     preserved.pop();
   }
 
-  const sgitEntries = ['.sgit', '.sgit.json', ...manifestPaths];
-  const sgitLines = sgitEntries.flatMap((entry) => [SGIT_MARKER, entry]);
+  const sgitEntries = ['.sgit', '.sgit.json', '.gitignore-sgit.bat', ...manifestPaths];
 
-  const sections = [
+  return [
     ...preserved,
     '',
-    SGIT_MANAGED_HEADER,
-    ...sgitLines,
-  ];
-
-  return sections.join('\n') + '\n';
+    SGIT_BLOCK_START,
+    ...sgitEntries,
+    SGIT_BLOCK_END,
+  ].join('\n') + '\n';
 }
 
-export function generateShadowExclude(manifestPaths: string[]): string {
-  const lines: string[] = [
-    '# Exclude everything by default',
-    '*',
-    '',
-    '# .sgit.json (always tracked)',
-    '!.sgit.json',
-  ];
-
+export function generateShadowExclude(manifestPaths: string[], ignorePaths: string[] = []): string {
   const emitted = new Set<string>();
+  const entryLines: string[] = [];
 
   for (const trackedPath of manifestPaths) {
-    const pathLines: string[] = [];
     const ancestors = getAncestors(trackedPath);
 
     for (const ancestor of ancestors) {
       const unignore = `!${ancestor}/`;
       const reignore = `${ancestor}/*`;
       if (!emitted.has(unignore)) {
-        pathLines.push(unignore);
+        entryLines.push(unignore);
         emitted.add(unignore);
       }
       if (!emitted.has(reignore)) {
-        pathLines.push(reignore);
+        entryLines.push(reignore);
         emitted.add(reignore);
       }
     }
 
     const target = `!${trackedPath}`;
     if (!emitted.has(target)) {
-      pathLines.push(target);
+      entryLines.push(target);
       emitted.add(target);
     }
 
-    if (pathLines.length > 0) {
-      lines.push('');
-      lines.push(`# ${trackedPath}`);
-      lines.push(...pathLines);
+    // For directory entries, recursively include all contents
+    if (trackedPath.endsWith('/')) {
+      const recursive = `!${trackedPath}**`;
+      if (!emitted.has(recursive)) {
+        entryLines.push(recursive);
+        emitted.add(recursive);
+      }
     }
   }
 
-  return lines.join('\n') + '\n';
+  return [
+    SGIT_BLOCK_START,
+    '*',
+    '!.sgit.json',
+    ...entryLines,
+    ...ignorePaths,
+    '.gitignore-sgit.bat',
+    SGIT_BLOCK_END,
+  ].join('\n') + '\n';
 }
 
 function getAncestors(path: string): string[] {
-  // Remove trailing slash for directories
   const cleanPath = path.endsWith('/') ? path.slice(0, -1) : path;
   const parts = cleanPath.split('/');
-  // Remove the last part (the file/dir itself)
   parts.pop();
 
   const ancestors: string[] = [];

package/src/core/gitignore.ts

@@ -0,0 +1,242 @@
+import {
+  readdirSync,
+  renameSync,
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+} from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import { StaleGitignoreError } from './errors.js';
+import * as logger from '../utils/logger.js';
+
+const DISABLED_NAME = '.gitignore-sgit.bat';
+const LOCK_FILE = '.gitignore-guard';
+
+// --- Public API ---
+
+export function disableGitignores(
+  root: string,
+  manifestPaths: string[],
+): string[] {
+  const gitignores = findInTrackedDirs(root, manifestPaths, '.gitignore');
+  if (gitignores.length === 0) return [];
+
+  const stale = findInTrackedDirs(root, manifestPaths, DISABLED_NAME);
+  if (stale.length > 0) {
+    throw new StaleGitignoreError(stale);
+  }
+
+  const disabled: string[] = [];
+  for (const relPath of gitignores) {
+    const absPath = join(root, relPath);
+    const dir = absPath.substring(0, absPath.length - '.gitignore'.length);
+    renameSync(absPath, dir + DISABLED_NAME);
+    disabled.push(relPath);
+  }
+  return disabled;
+}
+
+export function enableGitignores(
+  root: string,
+  manifestPaths: string[],
+): string[] {
+  const disabled = findInTrackedDirs(root, manifestPaths, DISABLED_NAME);
+  const enabled: string[] = [];
+  for (const relPath of disabled) {
+    const absPath = join(root, relPath);
+    const restoredPath =
+      absPath.substring(0, absPath.length - DISABLED_NAME.length) +
+      '.gitignore';
+    renameSync(absPath, restoredPath);
+    enabled.push(relPath);
+  }
+  return enabled;
+}
+
+export function findStaleGitignores(
+  root: string,
+  manifestPaths: string[],
+): string[] {
+  return findInTrackedDirs(root, manifestPaths, DISABLED_NAME);
+}
+
+export function isGuardActive(root: string): boolean {
+  const lockPath = join(root, '.sgit', LOCK_FILE);
+  try {
+    const pid = parseInt(readFileSync(lockPath, 'utf-8').trim(), 10);
+    if (isNaN(pid)) return false;
+    process.kill(pid, 0); // signal 0 checks existence without sending
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function setupGitignoreGuard(
+  root: string,
+  manifestPaths: string[],
+): () => void {
+  const lockPath = join(root, '.sgit', LOCK_FILE);
+
+  // Nested invocation — another sgit process owns the guard
+  if (isGuardActive(root)) {
+    return () => {};
+  }
+
+  // Clean up stale state from a crashed process
+  const stale = findInTrackedDirs(root, manifestPaths, DISABLED_NAME);
+  if (stale.length > 0) {
+    logger.warn(
+      'found stale .gitignore-sgit.bat files from a previous crash; restoring',
+    );
+    enableGitignores(root, manifestPaths);
+  }
+  cleanStaleLock(lockPath);
+
+  // Disable gitignores
+  const gitignores = findInTrackedDirs(root, manifestPaths, '.gitignore');
+  if (gitignores.length === 0) {
+    return () => {};
+  }
+
+  for (const relPath of gitignores) {
+    const absPath = join(root, relPath);
+    const dir = absPath.substring(0, absPath.length - '.gitignore'.length);
+    renameSync(absPath, dir + DISABLED_NAME);
+  }
+
+  // Write lock with our PID
+  try {
+    writeFileSync(lockPath, String(process.pid));
+  } catch {
+    // .sgit dir may be missing in edge cases — non-fatal
+  }
+
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    try {
+      enableGitignores(root, manifestPaths);
+    } catch {
+      // best effort
+    }
+    try {
+      unlinkSync(lockPath);
+    } catch {
+      // best effort
+    }
+  };
+
+  const onSigint = () => {
+    cleanup();
+    process.exit(130);
+  };
+  const onSigterm = () => {
+    cleanup();
+    process.exit(143);
+  };
+
+  process.on('SIGINT', onSigint);
+  process.on('SIGTERM', onSigterm);
+  process.on('exit', cleanup);
+
+  return () => {
+    process.removeListener('SIGINT', onSigint);
+    process.removeListener('SIGTERM', onSigterm);
+    process.removeListener('exit', cleanup);
+    cleanup();
+  };
+}
+
+// --- Internal helpers ---
+
+/**
+ * Find files named `targetName` in all directories relevant to the manifest:
+ *  1. Ancestor directories of every manifest path (including repo root)
+ *  2. Recursive walk inside every directory-type manifest entry
+ */
+function findInTrackedDirs(
+  root: string,
+  manifestPaths: string[],
+  targetName: string,
+): string[] {
+  const found = new Set<string>();
+
+  for (const mPath of manifestPaths) {
+    // 1. Check ancestor directories (including root) for every path
+    for (const ancestor of getAncestorDirs(mPath)) {
+      const dirAbs = ancestor === '' ? root : join(root, ancestor);
+      const targetPath = join(dirAbs, targetName);
+      if (existsSync(targetPath)) {
+        found.add(targetPath);
+      }
+    }
+
+    // 2. For directory entries, also recursively walk inside
+    if (mPath.endsWith('/')) {
+      const dirAbs = join(root, mPath);
+      if (existsSync(dirAbs)) {
+        walkSync(dirAbs, targetName, found);
+      }
+    }
+  }
+
+  return [...found].map((abs) => relative(root, abs).split(sep).join('/'));
+}
+
+/**
+ * Return ancestor directory paths for a manifest path.
+ * '' represents the repo root.
+ *
+ *   'rec1/rec2/test'  → ['', 'rec1', 'rec1/rec2']
+ *   'temp2/'          → ['']
+ *   'README.md'       → ['']
+ */
+function getAncestorDirs(path: string): string[] {
+  const clean = path.endsWith('/') ? path.slice(0, -1) : path;
+  const parts = clean.split('/');
+  parts.pop(); // drop the leaf (file or dir name)
+
+  const ancestors: string[] = [''];
+  for (let i = 1; i <= parts.length; i++) {
+    ancestors.push(parts.slice(0, i).join('/'));
+  }
+  return ancestors;
+}
+
+function walkSync(
+  dir: string,
+  targetName: string,
+  results: Set<string>,
+): void {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (
+      entry.isDirectory() &&
+      (entry.name === '.git' || entry.name === '.sgit')
+    ) {
+      continue;
+    }
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkSync(fullPath, targetName, results);
+    } else if (entry.name === targetName) {
+      results.add(fullPath);
+    }
+  }
+}
+
+function cleanStaleLock(lockPath: string): void {
+  try {
+    unlinkSync(lockPath);
+  } catch {
+    // no lock to clean
+  }
+}

package/src/core/hooks.ts

@@ -43,6 +43,18 @@ else
 fi
 `;
 
+const SHADOW_POST_MERGE_HOOK = `#!/bin/sh
+if command -v sgit >/dev/null 2>&1; then
+  sgit track sync
+fi
+`;
+
+const SHADOW_POST_CHECKOUT_HOOK = `#!/bin/sh
+if command -v sgit >/dev/null 2>&1; then
+  sgit track sync
+fi
+`;
+
 export async function getHookDir(root: string): Promise<string> {
   try {
     const hookPath = await execGit(['config', 'core.hooksPath'], {
@@ -101,6 +113,13 @@ export async function installShadowHook(sgitDir: string): Promise<void> {
   await writeFile(join(hooksDir, 'pre-commit'), SHADOW_HOOK, { mode: 0o755 });
 }
 
+export async function installShadowSyncHooks(sgitDir: string): Promise<void> {
+  const hooksDir = join(sgitDir, 'hooks');
+  await mkdir(hooksDir, { recursive: true });
+  await writeFile(join(hooksDir, 'post-merge'), SHADOW_POST_MERGE_HOOK, { mode: 0o755 });
+  await writeFile(join(hooksDir, 'post-checkout'), SHADOW_POST_CHECKOUT_HOOK, { mode: 0o755 });
+}
+
 export async function uninstallMainHook(root: string): Promise<void> {
   const hookDir = await getHookDir(root);
   const preCommitPath = join(hookDir, 'pre-commit');

package/src/core/manifest.ts

@@ -3,12 +3,17 @@ import { join } from 'node:path';
 
 export interface Manifest {
   paths: string[];
+  ignore: string[];
   [key: string]: unknown;
 }
 
 export async function readManifest(root: string): Promise<Manifest> {
   const content = await readFile(join(root, '.sgit.json'), 'utf-8');
-  return JSON.parse(content) as Manifest;
+  const data = JSON.parse(content) as Manifest;
+  if (!Array.isArray(data.ignore)) {
+    data.ignore = [];
+  }
+  return data;
 }
 
 export async function writeManifest(
@@ -47,3 +52,30 @@ export async function removePath(
   await writeManifest(root, manifest);
   return true;
 }
+
+export async function addIgnore(
+  root: string,
+  normalizedPath: string,
+): Promise<boolean> {
+  const manifest = await readManifest(root);
+  if (manifest.ignore.includes(normalizedPath)) {
+    return false;
+  }
+  manifest.ignore.push(normalizedPath);
+  await writeManifest(root, manifest);
+  return true;
+}
+
+export async function removeIgnore(
+  root: string,
+  normalizedPath: string,
+): Promise<boolean> {
+  const manifest = await readManifest(root);
+  const index = manifest.ignore.indexOf(normalizedPath);
+  if (index === -1) {
+    return false;
+  }
+  manifest.ignore.splice(index, 1);
+  await writeManifest(root, manifest);
+  return true;
+}

package/src/core/paths.ts

@@ -36,6 +36,7 @@ export async function normalizePath(
 export function isPathCoveredByManifest(
   filePath: string,
   manifestPaths: string[],
+  ignorePaths: string[] = [],
 ): boolean {
   const caseInsensitive = process.platform === 'darwin';
   const normalize = caseInsensitive
@@ -44,15 +45,32 @@ export function isPathCoveredByManifest(
 
   const normalizedFile = normalize(filePath);
 
+  let covered = false;
   for (const mPath of manifestPaths) {
     const normalizedManifest = normalize(mPath);
-    if (normalizedManifest === normalizedFile) return true;
+    if (normalizedManifest === normalizedFile) { covered = true; break; }
     if (
       normalizedManifest.endsWith('/') &&
       normalizedFile.startsWith(normalizedManifest)
     ) {
-      return true;
+      covered = true;
+      break;
     }
   }
-  return false;
+
+  if (!covered) return false;
+
+  // Check if the path is excluded by ignore list
+  for (const iPath of ignorePaths) {
+    const normalizedIgnore = normalize(iPath);
+    if (normalizedIgnore === normalizedFile) return false;
+    if (
+      normalizedIgnore.endsWith('/') &&
+      normalizedFile.startsWith(normalizedIgnore)
+    ) {
+      return false;
+    }
+  }
+
+  return true;
 }

package/src/core/repository.ts

@@ -2,14 +2,29 @@ import { access, lstat } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { execGit } from './git.js';
-import { NotGitRepoError, NotInitializedError, SgitError } from './errors.js';
+import { NoGitIdentityError, NotGitRepoError, NotInitializedError, SgitError } from './errors.js';
 
 export async function findRoot(): Promise<string> {
+  const cwd = process.cwd();
   try {
-    return await execGit(['rev-parse', '--show-toplevel']);
+    await access(join(cwd, '.git'), constants.F_OK);
   } catch {
     throw new NotGitRepoError();
   }
+  return cwd;
+}
+
+export async function validateGitIdentity(root: string): Promise<void> {
+  try {
+    await execGit(['config', 'user.name'], { cwd: root });
+  } catch {
+    throw new NoGitIdentityError();
+  }
+  try {
+    await execGit(['config', 'user.email'], { cwd: root });
+  } catch {
+    throw new NoGitIdentityError();
+  }
 }
 
 export async function validateShadowRepo(root: string): Promise<void> {

package/tests/commands/track/add.test.ts

@@ -45,7 +45,7 @@ describe('track add', () => {
       join(tempDir, '.git', 'info', 'exclude'),
       'utf-8',
     );
-    expect(mainExclude).toContain('# sgit\nnotes/todo.md\n');
+    expect(mainExclude).toContain('notes/todo.md\n');
   });
 
   it('adds a directory with trailing slash', async () => {
@@ -135,6 +135,36 @@ describe('track add', () => {
     await access(join(tempDir, 'secrets', 'key.pem'), constants.F_OK);
   });
 
+  it('rejects .gitignore files', async () => {
+    await writeFile(join(tempDir, '.gitignore'), '*.log\n');
+    await expect(trackAdd(['.gitignore'])).rejects.toThrow(
+      '.gitignore files are managed by sgit',
+    );
+  });
+
+  it('rejects nested .gitignore files', async () => {
+    await mkdir(join(tempDir, 'docs'), { recursive: true });
+    await writeFile(join(tempDir, 'docs', '.gitignore'), 'stuff\n');
+    await expect(trackAdd(['docs/.gitignore'])).rejects.toThrow(
+      '.gitignore files are managed by sgit',
+    );
+  });
+
+  it('rejects .gitignore-sgit.bat files', async () => {
+    await writeFile(join(tempDir, '.gitignore-sgit.bat'), 'stale\n');
+    await expect(trackAdd(['.gitignore-sgit.bat'])).rejects.toThrow(
+      '.gitignore files are managed by sgit',
+    );
+  });
+
+  it('rejects nested .gitignore-sgit.bat files', async () => {
+    await mkdir(join(tempDir, 'docs'), { recursive: true });
+    await writeFile(join(tempDir, 'docs', '.gitignore-sgit.bat'), 'stale\n');
+    await expect(trackAdd(['docs/.gitignore-sgit.bat'])).rejects.toThrow(
+      '.gitignore files are managed by sgit',
+    );
+  });
+
   it('adds multiple paths at once', async () => {
     await writeFile(join(tempDir, 'a.txt'), 'a');
     await writeFile(join(tempDir, 'b.txt'), 'b');