Repository

import { Repository } from 'wit';

static init(path?: string): Repository

// Initialize in current directory
const repo = Repository.init();

// Initialize in specific path
const repo = Repository.init('/path/to/project');

static open(path?: string): Repository

const repo = Repository.open('/path/to/repo');

static isRepository(path: string): boolean

if (Repository.isRepository('/some/path')) {
  const repo = Repository.open('/some/path');
}

add(path: string | string[]): void

repo.add('file.ts');
repo.add(['file1.ts', 'file2.ts']);
repo.add('.');  // Stage all

unstage(path: string | string[]): void

repo.unstage('file.ts');

commit(message: string, options?: CommitOptions): string

interface CommitOptions {
  all?: boolean;      // Stage all tracked files
  amend?: boolean;    // Amend last commit
  author?: string;    // Override author
  email?: string;     // Override email
}

const hash = repo.commit('Add feature');

// Stage all and commit
const hash = repo.commit('Update', { all: true });

// Amend last commit
repo.commit('Fixed message', { amend: true });

status(): Status

interface Status {
  branch: string;
  staged: FileStatus[];
  modified: FileStatus[];
  untracked: string[];
  ahead: number;
  behind: number;
}

const status = repo.status();

console.log('On branch:', status.branch);
console.log('Staged files:', status.staged.length);
console.log('Modified files:', status.modified.length);
console.log('Untracked:', status.untracked);

log(options?: LogOptions): Commit[]

interface LogOptions {
  limit?: number;     // Max commits to return
  since?: Date;       // Commits after this date
  until?: Date;       // Commits before this date
  author?: string;    // Filter by author
  path?: string;      // Filter by path
}

// All commits
const commits = repo.log();

// Last 10 commits
const recent = repo.log({ limit: 10 });

// Commits affecting a file
const fileHistory = repo.log({ path: 'src/index.ts' });

getCommit(ref: string): Commit

const commit = repo.getCommit('abc123');
const head = repo.getCommit('HEAD');
const parent = repo.getCommit('HEAD~1');

diff(options?: DiffOptions): DiffResult

interface DiffOptions {
  staged?: boolean;   // Diff staged vs HEAD
  from?: string;      // Start commit/ref
  to?: string;        // End commit/ref
  path?: string;      // Limit to path
}

// Unstaged changes
const unstaged = repo.diff();

// Staged changes
const staged = repo.diff({ staged: true });

// Between commits
const changes = repo.diff({ from: 'abc', to: 'def' });

branches(): Branch[]

interface Branch {
  name: string;
  hash: string;
  current: boolean;
  upstream?: string;
}

const branches = repo.branches();
for (const branch of branches) {
  console.log(branch.current ? '* ' : '  ', branch.name);
}

currentBranch(): string | null

createBranch(name: string, startPoint?: string): void

repo.createBranch('feature');
repo.createBranch('from-tag', 'v1.0.0');

deleteBranch(name: string, force?: boolean): void

switch(branch: string, options?: SwitchOptions): void

interface SwitchOptions {
  create?: boolean;   // Create branch if doesn't exist
}

repo.switch('main');
repo.switch('new-feature', { create: true });

merge(branch: string, options?: MergeOptions): MergeResult

interface MergeResult {
  success: boolean;
  hash?: string;           // Merge commit hash
  conflicts?: string[];    // Conflicting files
}

const result = repo.merge('feature');
if (!result.success) {
  console.log('Conflicts in:', result.conflicts);
}

undo(options?: UndoOptions): void

interface UndoOptions {
  steps?: number;    // Number of operations to undo
}

repo.undo();
repo.undo({ steps: 3 });

restore(path: string, options?: RestoreOptions): void

interface RestoreOptions {
  staged?: boolean;    // Unstage file
  source?: string;     // Restore from commit
}

getTree(hash: string): Tree

getBlob(hash: string): Blob

getFileContent(path: string, options?: { staged?: boolean }): string

import { Repository } from 'wit';

// Open or create repo
const repo = Repository.isRepository('.')
  ? Repository.open('.')
  : Repository.init('.');

// Make changes and stage
repo.add('src/feature.ts');
repo.add('tests/feature.test.ts');

// Check what's staged
const status = repo.status();
console.log('Staged:', status.staged.map(f => f.path));

// Review diff
const diff = repo.diff({ staged: true });
for (const file of diff.files) {
  console.log(`\n${file.path}:`);
  for (const hunk of file.hunks) {
    console.log(hunk.header);
  }
}

// Commit
const hash = repo.commit('Add new feature');
console.log('Created commit:', hash);

// View history
const commits = repo.log({ limit: 5 });
for (const commit of commits) {
  console.log(`${commit.hash.slice(0, 7)} ${commit.message}`);
}