pyoxidize 0.2.0__tar.gz

pyoxidize-0.2.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: pyoxidize
+Version: 0.2.0
+Summary: a version control system with semantic awareness built-in undo and interactive shell
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.1
+Requires-Dist: rich>=13.0
+Requires-Dist: prompt_toolkit>=3.0
+Requires-Dist: deepmerge>=1.1
+Provides-Extra: semantic
+Requires-Dist: py-tree-sitter>=0.21; extra == "semantic"
+Requires-Dist: tree-sitter-python>=0.21; extra == "semantic"
+Provides-Extra: notebook
+Requires-Dist: nbformat>=5.9; extra == "notebook"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Requires-Dist: mypy>=1.5; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+
+# oxidize
+
+a version control system built from scratch with semantic awareness built-in undo and an interactive shell
+
+[![ci](https://github.com/siddhant-bayas/oxidize/actions/workflows/ci.yml/badge.svg)](https://github.com/siddhant-bayas/oxidize/actions/workflows/ci.yml)
+[![pypi](https://img.shields.io/pypi/v/oxidize)](https://pypi.org/project/oxidize/)
+[![python](https://img.shields.io/pypi/pyversions/oxidize)](https://pypi.org/project/oxidize/)
+
+## what it does
+
+tracks file snapshots using content-addressable storage (sha-256) a commit dag and a staging index but unlike git it also understands your codes structure
+
+```bash
+# install
+pip install oxidize
+
+# or with extras
+pip install "oxidize[semantic]"
+pip install "oxidize[notebook]"
+pip install "oxidize[dev]"
+
+# usage
+oxidize init
+oxidize add file.py
+oxidize status
+oxidize commit -m "first commit"
+oxidize log
+
+# or use oxi as a shorter alias for everything
+oxi init
+oxi add file.py
+oxi status
+oxi commit -m "first commit"
+oxi log
+
+# interactive shell (no args launches the repl)
+oxi
+```
+
+both `oxidize` and `oxi` accept the same subcommands
+
+## features
+
+* content-addressable object store -- sha-256 zlib-compressed deduplicated
+* recursive tree objects -- proper nested directory tracking
+* interactive repl -- oxi launches a shell with tab completion live status bar command history
+* secret scanning -- detects api keys tokens and credentials before commit
+* structured data merge -- json/yaml/toml merge at the key level not text lines
+* notebook-aware versioning -- cell-level diffs for ipynb files auto-strip outputs
+* ai agent provenance -- track which agent/tool wrote what code
+* built-in undo -- every operation is safely reversible
+* semantic diffs (experimental) -- ast-aware diffs that understand function renames
+
+## how it works
+
+every file you add gets hashed using sha-256 and stored as a blob inside .oxidize/objects/
+
+a commit is just
+
+* a snapshot of the file tree (with proper subtrees for nested dirs)
+* metadata (author timestamp agent provenance)
+* a pointer to the previous commit
+
+```txt
+files -> blobs -> tree -> commit -> commit -> commit
+                                     ^
+                                    head
+```
+
+## structure
+
+```txt
+oxidize/
+  objects/       blob tree commit types and serialization
+  storage/       content-addressable object store
+  index/         staging area
+  core/          repo context refs config
+  diff/          myers diff engine
+  merge/         structured data merge (json/yaml/toml)
+  notebook/      ipynb cell-level support
+  semantic/      ast-aware diffs via tree-sitter
+  security/      secret scanning
+  provenance/    ai agent tracking
+  undo/          operation journal and reversal
+  cli/           click commands and prompt_toolkit repl
+```
+
+## contributing
+
+see [docs/contributing.md](docs/contributing.md)
+
+## license
+
+mit
+
+~ written by a guy who discovered hashing yesterday

pyoxidize-0.2.0/README.md

@@ -0,0 +1,96 @@
+# oxidize
+
+a version control system built from scratch with semantic awareness built-in undo and an interactive shell
+
+[![ci](https://github.com/siddhant-bayas/oxidize/actions/workflows/ci.yml/badge.svg)](https://github.com/siddhant-bayas/oxidize/actions/workflows/ci.yml)
+[![pypi](https://img.shields.io/pypi/v/oxidize)](https://pypi.org/project/oxidize/)
+[![python](https://img.shields.io/pypi/pyversions/oxidize)](https://pypi.org/project/oxidize/)
+
+## what it does
+
+tracks file snapshots using content-addressable storage (sha-256) a commit dag and a staging index but unlike git it also understands your codes structure
+
+```bash
+# install
+pip install oxidize
+
+# or with extras
+pip install "oxidize[semantic]"
+pip install "oxidize[notebook]"
+pip install "oxidize[dev]"
+
+# usage
+oxidize init
+oxidize add file.py
+oxidize status
+oxidize commit -m "first commit"
+oxidize log
+
+# or use oxi as a shorter alias for everything
+oxi init
+oxi add file.py
+oxi status
+oxi commit -m "first commit"
+oxi log
+
+# interactive shell (no args launches the repl)
+oxi
+```
+
+both `oxidize` and `oxi` accept the same subcommands
+
+## features
+
+* content-addressable object store -- sha-256 zlib-compressed deduplicated
+* recursive tree objects -- proper nested directory tracking
+* interactive repl -- oxi launches a shell with tab completion live status bar command history
+* secret scanning -- detects api keys tokens and credentials before commit
+* structured data merge -- json/yaml/toml merge at the key level not text lines
+* notebook-aware versioning -- cell-level diffs for ipynb files auto-strip outputs
+* ai agent provenance -- track which agent/tool wrote what code
+* built-in undo -- every operation is safely reversible
+* semantic diffs (experimental) -- ast-aware diffs that understand function renames
+
+## how it works
+
+every file you add gets hashed using sha-256 and stored as a blob inside .oxidize/objects/
+
+a commit is just
+
+* a snapshot of the file tree (with proper subtrees for nested dirs)
+* metadata (author timestamp agent provenance)
+* a pointer to the previous commit
+
+```txt
+files -> blobs -> tree -> commit -> commit -> commit
+                                     ^
+                                    head
+```
+
+## structure
+
+```txt
+oxidize/
+  objects/       blob tree commit types and serialization
+  storage/       content-addressable object store
+  index/         staging area
+  core/          repo context refs config
+  diff/          myers diff engine
+  merge/         structured data merge (json/yaml/toml)
+  notebook/      ipynb cell-level support
+  semantic/      ast-aware diffs via tree-sitter
+  security/      secret scanning
+  provenance/    ai agent tracking
+  undo/          operation journal and reversal
+  cli/           click commands and prompt_toolkit repl
+```
+
+## contributing
+
+see [docs/contributing.md](docs/contributing.md)
+
+## license
+
+mit
+
+~ written by a guy who discovered hashing yesterday

pyoxidize-0.2.0/oxidize/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

pyoxidize-0.2.0/oxidize/cli/__init__.py

@@ -0,0 +1,3 @@
+from .main import cli
+
+__all__ = ["cli"]

pyoxidize-0.2.0/oxidize/cli/commands/add.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+
+import click
+
+from oxidize.core.repository import Repository, RepositoryNotFound
+
+
+@click.command("add")
+@click.argument("paths", nargs=-1, required=True, type=click.Path(exists=True))
+def cmd_add(paths: tuple[str, ...]) -> None:
+    """Stage files for the next commit."""
+    try:
+        repo = Repository.discover()
+    except RepositoryNotFound as e:
+        raise click.ClickException(str(e))
+
+    for raw_path in paths:
+        target = Path(raw_path).resolve()
+        if target.is_dir():
+            files = [f for f in target.rglob("*") if f.is_file()]
+        else:
+            files = [target]
+
+        for file_path in files:
+            rel = file_path.relative_to(repo.work_tree).as_posix()
+            oid = repo.db.store_blob(file_path.read_bytes())
+            repo.index.add(rel, oid, file_path)
+            click.echo(f"  staged: {rel}")

pyoxidize-0.2.0/oxidize/cli/commands/commit.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import os
+from collections import defaultdict
+
+import click
+
+from oxidize.core.repository import Repository, RepositoryNotFound
+from oxidize.objects.types import Author, Commit, FileMode, Tree, TreeEntry
+
+
+def _build_tree(repo: Repository) -> Tree:
+    entries_by_dir: dict[str, list[tuple[str, str, FileMode]]] = defaultdict(list)
+    for entry in repo.index.entries():
+        parts = entry.path.split("/")
+        if len(parts) == 1:
+            entries_by_dir[""].append((parts[0], entry.oid, FileMode(entry.mode)))
+        else:
+            dir_name = parts[0]
+            file_name = parts[-1]
+            entries_by_dir[dir_name].append((file_name, entry.oid, FileMode(entry.mode)))
+
+    subtrees: dict[str, str] = {}
+    for dir_name, dir_entries in entries_by_dir.items():
+        if dir_name and len(dir_entries) == 1 and dir_entries[0][0] == "__subtree__":
+            continue
+        if not dir_name:
+            continue
+        sub_tree = Tree()
+        for fname, foid, fmode in dir_entries:
+            sub_tree.add(TreeEntry(name=fname, oid=foid, mode=fmode))
+        repo.db.store_tree(sub_tree)
+        subtrees[dir_name] = sub_tree.oid
+
+    root = Tree()
+    for fname, foid, fmode in entries_by_dir.get("", []):
+        root.add(TreeEntry(name=fname, oid=foid, mode=fmode))
+    for dir_name, subtree_oid in sorted(subtrees.items()):
+        root.add(TreeEntry(name=dir_name, oid=subtree_oid, mode=FileMode.DIRECTORY))
+    return root
+
+
+@click.command("commit")
+@click.option("-m", "--message", required=True, help="Commit message")
+@click.option("--agent", default=None, help="Agent that produced this change (e.g. claude-code)")
+def cmd_commit(message: str, agent: str | None = None) -> None:
+    """Record staged changes as a new commit."""
+    try:
+        repo = Repository.discover()
+    except RepositoryNotFound as e:
+        raise click.ClickException(str(e))
+
+    if len(repo.index) == 0:
+        raise click.ClickException("nothing staged -- use `oxidize add` first")
+
+    name = os.environ.get("OXIDE_AUTHOR_NAME") or repo.config.user_name
+    email = os.environ.get("OXIDE_AUTHOR_EMAIL") or repo.config.user_email
+    author = Author(name=name, email=email)
+
+    tree = _build_tree(repo)
+    repo.db.store_tree(tree)
+
+    parents: list[str] = []
+    head = repo.refs.head()
+    if head:
+        parents.append(head)
+
+    commit = Commit(
+        tree_oid=tree.oid,
+        author=author,
+        committer=author,
+        message=message,
+        parents=parents,
+        agent=agent,
+    )
+    repo.db.store_commit(commit)
+    repo.refs.update_head(commit.oid)
+    repo.index.clear()
+
+    short = commit.oid[:8]
+    branch = repo.refs.current_branch() or "HEAD"
+    agent_str = f" [{agent}]" if agent else ""
+    click.echo(f"[{branch} {short}]{agent_str} {message}")

pyoxidize-0.2.0/oxidize/cli/commands/diff.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from typing import Any, Mapping
+
+import click
+from rich.console import Console
+from rich.text import Text
+
+from oxidize.core.repository import Repository, RepositoryNotFound
+from oxidize.diff.engine import LineOp, diff_lines
+
+console = Console()
+
+
+@click.command("diff")
+@click.argument("paths", nargs=-1, type=click.Path(exists=True))
+@click.option("--cached", is_flag=True, help="Show staged changes (index vs HEAD)")
+def cmd_diff(paths: tuple[str, ...], cached: bool) -> None:
+    """Show changes between working tree and index (or staged vs HEAD)."""
+    try:
+        repo = Repository.discover()
+    except RepositoryNotFound as e:
+        raise click.ClickException(str(e))
+
+    if cached:
+        _diff_cached(repo, paths)
+    else:
+        _diff_working(repo, paths)
+
+
+def _diff_working(repo: Repository, paths: tuple[str, ...]) -> None:
+    indexed = {e.path: e for e in repo.index.entries()}
+    files = _resolve_paths(repo, paths, indexed)
+
+    for rel in sorted(files):
+        entry = indexed.get(rel)
+        if entry is None:
+            continue
+        disk = repo.work_tree / rel
+        if not disk.exists():
+            console.print(f"[red]deleted: {rel}[/]")
+            continue
+        new_text = disk.read_text(errors="replace")
+        old_blob = repo.db.load_blob(entry.oid)
+        old_text = old_blob.data.decode(errors="replace")
+        if old_text == new_text:
+            continue
+        _print_diff(rel, old_text, new_text)
+
+
+def _diff_cached(repo: Repository, paths: tuple[str, ...]) -> None:
+    head = repo.refs.head()
+    if not head:
+        console.print("[dim]no commits yet[/]")
+        return
+
+    commit = repo.db.load_commit(head)
+    head_tree = repo.db.load_tree(commit.tree_oid)
+    head_files = {e.name: e for e in head_tree}
+
+    indexed = {e.path: e for e in repo.index.entries()}
+    files = _resolve_paths(repo, paths, indexed)
+
+    for rel in sorted(files):
+        entry = indexed.get(rel)
+        head_entry = head_files.get(rel)
+        if entry and not head_entry:
+            console.print(f"[green]new file: {rel}[/]")
+        elif not entry and head_entry:
+            console.print(f"[red]deleted: {rel}[/]")
+        elif entry and head_entry:
+            old_blob = repo.db.load_blob(head_entry.oid)
+            new_blob = repo.db.load_blob(entry.oid)
+            if old_blob.data != new_blob.data:
+                _print_diff(
+                    rel,
+                    old_blob.data.decode(errors="replace"),
+                    new_blob.data.decode(errors="replace"),
+                )
+
+
+def _resolve_paths(
+    repo: Repository, paths: tuple[str, ...], indexed: Mapping[str, Any]
+) -> set[str]:
+    if paths:
+        result: set[str] = set()
+        for raw in paths:
+            p = Path(raw).resolve()
+            if p.is_dir():
+                for f in p.rglob("*"):
+                    rel = f.relative_to(repo.work_tree).as_posix()
+                    if rel in indexed:
+                        result.add(rel)
+            else:
+                rel = p.relative_to(repo.work_tree).as_posix()
+                result.add(rel)
+        return result
+    return set(indexed.keys())
+
+
+def _print_diff(path: str, old: str, new: str) -> None:
+    console.print(f"\n[bold]diff --a/a b/{path}[/]")
+    diff_result = diff_lines(old, new)
+    for dl in diff_result:
+        if dl.op == LineOp.EQUAL:
+            console.print(f" {dl.content}", end="")
+        elif dl.op == LineOp.INSERT:
+            line = Text(f"+{dl.content}")
+            line.stylize("green")
+            console.print(line, end="")
+        elif dl.op == LineOp.DELETE:
+            line = Text(f"-{dl.content}")
+            line.stylize("red")
+            console.print(line, end="")
+    if diff_result and not diff_result[-1].content.endswith("\n"):
+        console.print()

pyoxidize-0.2.0/oxidize/cli/commands/init.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+import click
+
+from oxidize.core.repository import Repository
+
+
+@click.command("init")
+@click.argument("path", default=".", type=click.Path())
+def cmd_init(path: str) -> None:
+    """Initialize a new oxidize repository."""
+    target = Path(path).resolve()
+    target.mkdir(parents=True, exist_ok=True)
+    try:
+        repo = Repository.init(target)
+        click.echo(f"Initialized empty oxidize repository in {repo.oxidize_dir}")
+    except FileExistsError as e:
+        raise click.ClickException(str(e))

pyoxidize-0.2.0/oxidize/cli/commands/log.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import datetime
+
+import click
+from rich.console import Console
+
+from oxidize.core.repository import Repository, RepositoryNotFound
+
+console = Console()
+
+
+@click.command("log")
+@click.option("-n", "--count", default=20, help="Max commits to show")
+def cmd_log(count: int) -> None:
+    """Show commit history."""
+    try:
+        repo = Repository.discover()
+    except RepositoryNotFound as e:
+        raise click.ClickException(str(e))
+
+    head = repo.refs.head()
+    if not head:
+        click.echo("No commits yet.")
+        return
+
+    oid: str | None = head
+    shown = 0
+    while oid and shown < count:
+        commit = repo.db.load_commit(oid)
+        dt = datetime.datetime.fromtimestamp(commit.author.timestamp)
+        date_str = dt.strftime("%a %b %d %H:%M:%S %Y")
+
+        console.print(f"[yellow]commit {oid}[/]")
+        console.print(f"Author: {commit.author.name} <{commit.author.email}>")
+        console.print(f"Date:   {date_str}\n")
+        console.print(f"    {commit.message}\n")
+
+        oid = commit.parents[0] if commit.parents else None
+        shown += 1

pyoxidize-0.2.0/oxidize/cli/commands/scan.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from oxidize.core.repository import Repository, RepositoryNotFound
+from oxidize.security.scanner import scan_directory, scan_file
+
+console = Console()
+
+
+@click.command("scan")
+@click.argument("paths", nargs=-1, type=click.Path(exists=True))
+@click.option("--staged", is_flag=True, help="Scan only staged files")
+def cmd_scan(paths: tuple[str, ...], staged: bool) -> None:
+    """Scan for secrets and credentials."""
+    try:
+        repo = Repository.discover()
+    except RepositoryNotFound as e:
+        raise click.ClickException(str(e))
+
+    findings: list[dict[str, str | int]] = []
+
+    if staged:
+        for entry in repo.index.entries():
+            full = repo.work_tree / entry.path
+            if full.exists():
+                findings.extend(scan_file(full, repo.work_tree))
+    elif paths:
+        for raw in paths:
+            p = Path(raw).resolve()
+            if p.is_dir():
+                findings.extend(scan_directory(p))
+            else:
+                findings.extend(scan_file(p, repo.work_tree))
+    else:
+        findings.extend(scan_directory(repo.work_tree))
+
+    if not findings:
+        console.print("[green]No secrets found.[/]")
+        return
+
+    console.print(f"\n[red bold]Found {len(findings)} potential secret(s):[/]\n")
+    for f in findings:
+        console.print(
+            f"  [yellow]{f['type']}[/] in [cyan]{f['file']}[/] line {f['line']}: {f['match']}"
+        )
+    console.print()

pyoxidize-0.2.0/oxidize/cli/commands/status.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from oxidize.core.repository import Repository, RepositoryNotFound
+
+console = Console()
+
+_IGNORE = {".oxidize", ".git", "__pycache__", ".DS_Store"}
+
+
+def _walk(root: Path) -> list[Path]:
+    result = []
+    for p in sorted(root.rglob("*")):
+        if any(part in _IGNORE for part in p.parts):
+            continue
+        if p.is_file():
+            result.append(p)
+    return result
+
+
+@click.command("status")
+def cmd_status() -> None:
+    """Show working tree status."""
+    try:
+        repo = Repository.discover()
+    except RepositoryNotFound as e:
+        raise click.ClickException(str(e))
+
+    branch = repo.refs.current_branch() or "(detached HEAD)"
+    console.print(f"On branch [bold cyan]{branch}[/]")
+
+    staged: list[str] = []
+    modified: list[str] = []
+    untracked: list[str] = []
+
+    indexed_paths = {e.path for e in repo.index.entries()}
+    disk_files = _walk(repo.work_tree)
+
+    for file_path in disk_files:
+        rel = file_path.relative_to(repo.work_tree).as_posix()
+        entry = repo.index.get(rel)
+        if entry is None:
+            untracked.append(rel)
+        elif entry.is_stale(file_path):
+            modified.append(rel)
+
+    for path in indexed_paths:
+        full = repo.work_tree / path
+        if not full.exists():
+            staged.append(f"deleted: {path}")
+        else:
+            staged.append(path)
+
+    if not staged and not modified and not untracked:
+        console.print("nothing to commit, working tree clean")
+        return
+
+    if staged:
+        console.print("\n[green]Changes staged for commit:[/]")
+        for p in staged:
+            console.print(f"        [green]{p}[/]")
+
+    if modified:
+        console.print("\n[yellow]Changes not staged for commit:[/]")
+        for p in modified:
+            console.print(f"        [yellow]modified: {p}[/]")
+
+    if untracked:
+        console.print("\n[dim]Untracked files:[/]")
+        for p in untracked:
+            console.print(f"        [dim]{p}[/]")