markback 0.1.2__py3-none-any.whl → 0.1.5__py3-none-any.whl

markback/cli.py

@@ -1,435 +1,122 @@
 """MarkBack command-line interface."""
 
-import json
+import glob
+import os
+import shutil
+import subprocess
 import sys
 from pathlib import Path
-from typing import Annotated, Optional
+from typing import Annotated
 
 import typer
 from rich.console import Console
-from rich.table import Table
 
-from .config import Config, init_env, load_config, validate_config
-from .linter import format_diagnostics, lint_files, summarize_results
-from .parser import parse_file, parse_string
-from .types import Severity, parse_feedback
-from .writer import OutputMode, normalize_file, write_file, write_records_multi
+from .writer import write_file
 
-app = typer.Typer(
-    name="markback",
-    help="MarkBack: A compact format for content + feedback",
-    no_args_is_help=True,
-)
-
-console = Console()
 err_console = Console(stderr=True)
 
 
-@app.command()
-def init(
-    path: Annotated[
-        Path,
-        typer.Argument(help="Path to create .env file"),
-    ] = Path(".env"),
-    force: Annotated[
-        bool,
-        typer.Option("--force", "-f", help="Overwrite existing file"),
-    ] = False,
-):
-    """Initialize a .env configuration file."""
-    if init_env(path, force=force):
-        console.print(f"[green]Created {path}[/green]")
-    else:
-        console.print(f"[yellow]{path} already exists. Use --force to overwrite.[/yellow]")
-        raise typer.Exit(1)
-
-
-@app.command()
-def lint(
-    paths: Annotated[
-        list[Path],
-        typer.Argument(help="Files or directories to lint"),
-    ],
-    output_json: Annotated[
-        bool,
-        typer.Option("--json", "-j", help="Output as JSON"),
-    ] = False,
-    no_source_check: Annotated[
-        bool,
-        typer.Option("--no-source-check", help="Skip checking if @source files exist"),
-    ] = False,
-    no_canonical_check: Annotated[
-        bool,
-        typer.Option("--no-canonical-check", help="Skip canonical format check"),
-    ] = False,
-):
-    """Lint MarkBack files."""
-    results = lint_files(
-        paths,
-        check_sources=not no_source_check,
-        check_canonical=not no_canonical_check,
-    )
+def get_mb_path(target: Path) -> Path:
+    """Get the .mb file path for a target file."""
+    return target.with_suffix(target.suffix + ".mb")
 
-    summary = summarize_results(results)
 
-    # Collect all diagnostics
-    all_diagnostics = []
-    for result in results:
-        all_diagnostics.extend(result.diagnostics)
+def get_feedback_path(directory: Path) -> Path:
+    """Get a non-colliding feedback.mb path in the given directory."""
+    candidate = directory / "feedback.mb"
+    if not candidate.exists():
+        return candidate
+    counter = 1
+    while True:
+        candidate = directory / f"feedback-{counter}.mb"
+        if not candidate.exists():
+            return candidate
+        counter += 1
 
-    if output_json:
-        output = {
-            "summary": summary,
-            "diagnostics": [d.to_dict() for d in all_diagnostics],
-        }
-        console.print(json.dumps(output, indent=2))
-    else:
-        # Print diagnostics
-        for d in all_diagnostics:
-            if d.severity == Severity.ERROR:
-                err_console.print(f"[red]{d}[/red]")
-            else:
-                err_console.print(f"[yellow]{d}[/yellow]")
 
-        # Print summary
-        console.print()
-        console.print(f"Files: {summary['files']}")
-        console.print(f"Records: {summary['records']}")
-        console.print(f"Errors: {summary['errors']}")
-        console.print(f"Warnings: {summary['warnings']}")
+def collect_glob(pattern: str) -> None:
+    """Expand a glob pattern and write all matches into a single .mb file."""
+    from .types import Record, SourceRef
 
-    # Exit with error code if there were errors
-    if summary["errors"] > 0:
+    matches = sorted(glob.glob(pattern))
+    if not matches:
+        err_console.print(f"[red]No files match pattern: {pattern}[/red]")
         raise typer.Exit(1)
 
+    records = [Record(source=SourceRef(f), feedback="") for f in matches]
 
-@app.command()
-def normalize(
-    input_path: Annotated[
-        Path,
-        typer.Argument(help="Input MarkBack file"),
-    ],
-    output_path: Annotated[
-        Optional[Path],
-        typer.Argument(help="Output file (omit for in-place)"),
-    ] = None,
-    in_place: Annotated[
-        bool,
-        typer.Option("--in-place", "-i", help="Modify input file in place"),
-    ] = False,
-):
-    """Normalize a MarkBack file to canonical format."""
-    try:
-        content = normalize_file(
-            input_path,
-            output_path=output_path,
-            in_place=in_place or (output_path is None),
-        )
-
-        if output_path:
-            console.print(f"[green]Wrote {output_path}[/green]")
-        elif in_place:
-            console.print(f"[green]Normalized {input_path}[/green]")
-        else:
-            console.print(content)
-
-    except ValueError as e:
-        err_console.print(f"[red]Error: {e}[/red]")
-        raise typer.Exit(1)
+    # Determine output directory from the pattern's parent, defaulting to cwd
+    pattern_parent = Path(pattern).parent
+    output_dir = pattern_parent if pattern_parent != Path("") else Path(".")
+    output_path = get_feedback_path(output_dir)
 
+    write_file(output_path, records)
+    err_console.print(f"Created {output_path} with {len(records)} source(s)")
+    open_editor(output_path)
 
-@app.command("list")
-def list_records(
-    paths: Annotated[
-        list[Path],
-        typer.Argument(help="Files or directories to list"),
-    ],
-    output_json: Annotated[
-        bool,
-        typer.Option("--json", "-j", help="Output as JSON"),
-    ] = False,
-):
-    """List records in MarkBack files."""
-    all_records = []
 
-    for path in paths:
-        if path.is_dir():
-            for mb_file in path.glob("**/*.mb"):
-                result = parse_file(mb_file)
-                for record in result.records:
-                    all_records.append((mb_file, record))
-        else:
-            result = parse_file(path)
-            for record in result.records:
-                all_records.append((path, record))
+def open_editor(path: Path) -> None:
+    """Open the file in the user's editor."""
+    editor = os.environ.get("EDITOR") or os.environ.get("VISUAL")
 
-    if output_json:
-        output = []
-        for file_path, record in all_records:
-            output.append({
-                "file": str(file_path),
-                "uri": record.uri,
-                "source": str(record.source) if record.source else None,
-                "feedback": record.feedback,
-                "has_content": record.has_inline_content(),
-            })
-        console.print(json.dumps(output, indent=2))
+    if editor:
+        subprocess.run([editor, str(path)])
+    elif sys.platform == "win32":
+        os.startfile(path)
+    elif sys.platform == "darwin":
+        subprocess.run(["open", str(path)])
     else:
-        table = Table(show_header=True)
-        table.add_column("URI", style="cyan")
-        table.add_column("Source", style="green")
-        table.add_column("Feedback", style="white")
-
-        for file_path, record in all_records:
-            uri = record.uri or "-"
-            source = str(record.source) if record.source else "-"
-            # Truncate feedback for display
-            feedback = record.feedback
-            if len(feedback) > 50:
-                feedback = feedback[:47] + "..."
-
-            table.add_row(uri, source, feedback)
-
-        console.print(table)
-        console.print(f"\nTotal: {len(all_records)} records")
-
-
-@app.command()
-def convert(
-    input_path: Annotated[
-        Path,
-        typer.Argument(help="Input MarkBack file or directory"),
-    ],
-    output_path: Annotated[
-        Path,
-        typer.Argument(help="Output file or directory"),
-    ],
-    to: Annotated[
-        str,
-        typer.Option("--to", "-t", help="Output format: single, multi, compact, paired"),
-    ] = "multi",
-):
-    """Convert between MarkBack storage modes."""
-    # Parse input
-    if input_path.is_dir():
-        from .parser import parse_directory
-        result = parse_directory(input_path)
-    else:
-        result = parse_file(input_path)
-
-    if result.has_errors:
-        err_console.print("[red]Cannot convert file with errors[/red]")
-        for d in result.diagnostics:
-            if d.severity == Severity.ERROR:
-                err_console.print(f"[red]{d}[/red]")
-        raise typer.Exit(1)
-
-    records = result.records
-
-    # Convert to output format
-    mode_map = {
-        "single": OutputMode.SINGLE,
-        "multi": OutputMode.MULTI,
-        "compact": OutputMode.COMPACT,
-        "paired": OutputMode.PAIRED,
-    }
-
-    if to not in mode_map:
-        err_console.print(f"[red]Unknown format: {to}. Use: single, multi, compact, paired[/red]")
+        # Try xdg-open first, then fall back to common editors
+        if shutil.which("xdg-open"):
+            result = subprocess.run(["xdg-open", str(path)], capture_output=True)
+            if result.returncode == 0:
+                return
+        for fallback in ("nano", "vi"):
+            if shutil.which(fallback):
+                subprocess.run([fallback, str(path)])
+                return
+        err_console.print(
+            f"[red]No editor found. Set the EDITOR environment variable, e.g.:[/red]\n"
+            f"  export EDITOR=nano"
+        )
         raise typer.Exit(1)
 
-    mode = mode_map[to]
-
-    if mode == OutputMode.PAIRED:
-        # Paired mode: create output directory with label files
-        output_path.mkdir(parents=True, exist_ok=True)
-        from .writer import write_paired_files
-        for i, record in enumerate(records):
-            # Determine filename from URI or source or index
-            if record.source:
-                basename = Path(str(record.source)).stem
-            elif record.uri:
-                basename = record.uri.split("/")[-1].split(":")[-1]
-            else:
-                basename = f"record_{i:04d}"
-
-            label_path = output_path / f"{basename}.label.txt"
-            write_paired_files(label_path, None, record)
-
-        console.print(f"[green]Wrote {len(records)} label files to {output_path}[/green]")
-
-    elif mode == OutputMode.SINGLE:
-        if len(records) != 1:
-            err_console.print(f"[red]Single mode requires exactly 1 record, got {len(records)}[/red]")
-            raise typer.Exit(1)
-        write_file(output_path, records, mode=mode)
-        console.print(f"[green]Wrote {output_path}[/green]")
-
-    else:
-        write_file(output_path, records, mode=mode)
-        console.print(f"[green]Wrote {len(records)} records to {output_path}[/green]")
-
-
-# Workflow subcommand group
-workflow_app = typer.Typer(
-    name="workflow",
-    help="Editor/Operator LLM workflow commands",
-)
-app.add_typer(workflow_app, name="workflow")
 
-
-@workflow_app.command("run")
-def workflow_run(
-    dataset: Annotated[
-        Path,
-        typer.Argument(help="Path to MarkBack dataset file or directory"),
-    ],
-    prompt: Annotated[
+def main(
+    target: Annotated[
         str,
-        typer.Option("--prompt", "-p", help="Initial prompt (or path to prompt file)"),
-    ] = "",
-    output: Annotated[
-        Path,
-        typer.Option("--output", "-o", help="Output file for results"),
-    ] = Path("workflow_result.json"),
-    env_file: Annotated[
-        Optional[Path],
-        typer.Option("--env", "-e", help="Path to .env file"),
-    ] = None,
-):
-    """Run the editor/operator workflow on a dataset."""
-    from .workflow import run_workflow, save_workflow_result
-
-    # Load config
-    config = load_config(env_file)
-
-    # Validate config
-    issues = validate_config(config)
-    if issues:
-        for issue in issues:
-            err_console.print(f"[yellow]Config warning: {issue}[/yellow]")
-
-    if config.editor is None or config.operator is None:
-        err_console.print("[red]Editor and Operator LLMs must be configured in .env[/red]")
-        raise typer.Exit(1)
-
-    # Load initial prompt
-    initial_prompt = prompt
-    if prompt and Path(prompt).exists():
-        initial_prompt = Path(prompt).read_text(encoding="utf-8")
-
-    # Load dataset
-    if dataset.is_dir():
-        from .parser import parse_directory
-        result = parse_directory(dataset)
-    else:
-        result = parse_file(dataset)
-
-    if result.has_errors:
-        err_console.print("[red]Dataset has errors:[/red]")
-        for d in result.diagnostics:
-            if d.severity == Severity.ERROR:
-                err_console.print(f"[red]{d}[/red]")
-        raise typer.Exit(1)
-
-    if not result.records:
-        err_console.print("[red]No records found in dataset[/red]")
-        raise typer.Exit(1)
-
-    console.print(f"Loaded {len(result.records)} records from {dataset}")
-    console.print("Running workflow...")
-
-    try:
-        workflow_result = run_workflow(config, initial_prompt, result.records)
-
-        # Save result
-        output_file = save_workflow_result(workflow_result, output, config)
-        console.print(f"[green]Results saved to {output_file}[/green]")
-
-        # Print summary
-        console.print("\n[bold]Workflow Results:[/bold]")
-        console.print(f"Refined prompt length: {len(workflow_result.refined_prompt)} chars")
-        console.print(f"Outputs generated: {len(workflow_result.outputs)}")
-
-        eval_result = workflow_result.evaluation
-        console.print(f"\n[bold]Evaluation:[/bold]")
-        console.print(f"Total: {eval_result['total']}")
-        console.print(f"Correct: {eval_result['correct']}")
-        console.print(f"Incorrect: {eval_result['incorrect']}")
-        console.print(f"Accuracy: {eval_result['accuracy']:.1%}")
-
-    except Exception as e:
-        err_console.print(f"[red]Workflow error: {e}[/red]")
-        raise typer.Exit(1)
-
-
-@workflow_app.command("evaluate")
-def workflow_evaluate(
-    results_file: Annotated[
-        Path,
-        typer.Argument(help="Path to workflow results JSON"),
+        typer.Argument(help="Target file or glob pattern to manage feedback for"),
     ],
-    output_json: Annotated[
-        bool,
-        typer.Option("--json", "-j", help="Output as JSON"),
-    ] = False,
 ):
-    """Show evaluation details from a workflow run."""
-    if not results_file.exists():
-        err_console.print(f"[red]File not found: {results_file}[/red]")
-        raise typer.Exit(1)
-
-    data = json.loads(results_file.read_text(encoding="utf-8"))
-    evaluation = data.get("evaluation", {})
-
-    if output_json:
-        console.print(json.dumps(evaluation, indent=2))
-    else:
-        console.print("[bold]Evaluation Summary:[/bold]")
-        console.print(f"Total: {evaluation.get('total', 0)}")
-        console.print(f"Correct: {evaluation.get('correct', 0)}")
-        console.print(f"Incorrect: {evaluation.get('incorrect', 0)}")
-        console.print(f"Accuracy: {evaluation.get('accuracy', 0):.1%}")
-
-        details = evaluation.get("details", [])
-        if details:
-            console.print("\n[bold]Details:[/bold]")
-            for d in details:
-                status = "[green]PASS[/green]" if d.get("match") else "[red]FAIL[/red]"
-                uri = d.get("uri") or f"record {d.get('record_idx')}"
-                console.print(f"  {status} {uri}: expected={d.get('expected_label')}")
-
-
-@workflow_app.command("prompt")
-def workflow_prompt(
-    results_file: Annotated[
-        Path,
-        typer.Argument(help="Path to workflow results JSON"),
-    ],
-    output: Annotated[
-        Optional[Path],
-        typer.Option("--output", "-o", help="Save prompt to file"),
-    ] = None,
-):
-    """Extract the refined prompt from a workflow run."""
-    if not results_file.exists():
-        err_console.print(f"[red]File not found: {results_file}[/red]")
-        raise typer.Exit(1)
+    """MarkBack: Create or view feedback for a target file."""
+    # Check if target is a glob pattern
+    if any(c in target for c in ('*', '?', '[')):
+        collect_glob(target)
+        return
+
+    target = Path(target)
+    mb_path = get_mb_path(target)
+
+    if not mb_path.exists():
+        # Create new .mb file
+        if not target.exists():
+            err_console.print(f"[red]Target file not found: {target}[/red]")
+            raise typer.Exit(1)
 
-    data = json.loads(results_file.read_text(encoding="utf-8"))
-    prompt = data.get("refined_prompt", "")
+        from .types import Record
+        record = Record(
+            source=target,
+            feedback="",
+        )
+        write_file(mb_path, [record])
 
-    if output:
-        output.write_text(prompt, encoding="utf-8")
-        console.print(f"[green]Saved prompt to {output}[/green]")
-    else:
-        console.print(prompt)
+    open_editor(mb_path)
 
 
-def main():
+def cli():
     """Entry point for the CLI."""
-    app()
+    typer.run(main)
 
 
 if __name__ == "__main__":
-    main()
+    cli()

markback/linter.py

@@ -137,36 +137,61 @@ def lint_prior_exists(
     return diagnostics
 
 
+def _is_position_invalid(source_ref) -> tuple[bool, str]:
+    """Check if a SourceRef has an invalid position range.
+
+    Returns (is_invalid, error_message).
+    Position is invalid if:
+    - end_line < start_line
+    - end_line == start_line and end_column < start_column
+    """
+    if source_ref.start_line is None or source_ref.end_line is None:
+        return False, ""
+
+    if source_ref.end_line < source_ref.start_line:
+        return True, f"end line {source_ref.end_line} is less than start line {source_ref.start_line}"
+
+    if source_ref.end_line == source_ref.start_line:
+        if (source_ref.start_column is not None and
+            source_ref.end_column is not None and
+            source_ref.end_column < source_ref.start_column):
+            return True, f"end column {source_ref.end_column} is less than start column {source_ref.start_column} on line {source_ref.start_line}"
+
+    return False, ""
+
+
 def lint_line_range(
     record: Record,
     record_idx: int,
 ) -> list[Diagnostic]:
-    """Check if line ranges are valid (end >= start)."""
+    """Check if line/character ranges are valid (end position >= start position)."""
     diagnostics: list[Diagnostic] = []
 
-    # Check @source line range
+    # Check @source range
     if record.source and record.source.start_line is not None:
-        if record.source.end_line is not None and record.source.end_line < record.source.start_line:
+        is_invalid, error_msg = _is_position_invalid(record.source)
+        if is_invalid:
             diagnostics.append(Diagnostic(
                 file=record._source_file,
                 line=record._start_line,
                 column=None,
                 severity=Severity.ERROR,
                 code=ErrorCode.E011,
-                message=f"Invalid line range in @source: end line {record.source.end_line} is less than start line {record.source.start_line}",
+                message=f"Invalid range in @source: {error_msg}",
                 record_index=record_idx,
             ))
 
-    # Check @prior line range
+    # Check @prior range
     if record.prior and record.prior.start_line is not None:
-        if record.prior.end_line is not None and record.prior.end_line < record.prior.start_line:
+        is_invalid, error_msg = _is_position_invalid(record.prior)
+        if is_invalid:
             diagnostics.append(Diagnostic(
                 file=record._source_file,
                 line=record._start_line,
                 column=None,
                 severity=Severity.ERROR,
                 code=ErrorCode.E011,
-                message=f"Invalid line range in @prior: end line {record.prior.end_line} is less than start line {record.prior.start_line}",
+                message=f"Invalid range in @prior: {error_msg}",
                 record_index=record_idx,
             ))
 

markback/parser.py

@@ -17,7 +17,7 @@ from .types import (
 
 
 # Known header keywords
-KNOWN_HEADERS = {"uri", "source", "prior"}
+KNOWN_HEADERS = {"uri", "by", "source", "prior"}
 
 # Patterns
 HEADER_PATTERN = re.compile(r"^@([a-z]+)\s+(.+)$")
@@ -145,6 +145,7 @@ def parse_string(
         nonlocal pending_uri, in_content, had_blank_line
 
         uri = current_headers.get("uri") or pending_uri
+        by = current_headers.get("by")
         source_str = current_headers.get("source")
         source = SourceRef(source_str) if source_str else None
         prior_str = current_headers.get("prior")
@@ -164,6 +165,7 @@ def parse_string(
         record = Record(
             feedback=feedback,
             uri=uri,
+            by=by,
             source=source,
             prior=prior,
             content=content,
@@ -242,14 +244,16 @@ def parse_string(
                     line_num,
                 )
 
-            # Use any pending @uri from previous line and @prior if present
+            # Use any pending @uri from previous line and @by, @prior if present
             uri = pending_uri or current_headers.get("uri")
+            by = current_headers.get("by")
             prior_str = current_headers.get("prior")
             prior = SourceRef(prior_str) if prior_str else None
 
             record = Record(
                 feedback=feedback or "",
                 uri=uri,
+                by=by,
                 source=source,
                 prior=prior,
                 content=None,

markback/types.py

@@ -78,8 +78,9 @@ class Diagnostic:
         }
 
 
-# Regex to parse line range from a path: path:start or path:start-end
-_LINE_RANGE_PATTERN = re.compile(r'^(.+?):(\d+)(?:-(\d+))?$')
+# Regex to parse line/character range from a path
+# Supports: path:line, path:line:col, path:line-line, path:line:col-line:col
+_LINE_RANGE_PATTERN = re.compile(r'^(.+?):(\d+)(?::(\d+))?(?:-(\d+)(?::(\d+))?)?$')
 
 
 @dataclass
@@ -89,6 +90,8 @@ class SourceRef:
     is_uri: bool = False
     start_line: Optional[int] = None
     end_line: Optional[int] = None
+    start_column: Optional[int] = None
+    end_column: Optional[int] = None
     _path_only: str = ""
 
     def __post_init__(self):
@@ -102,16 +105,21 @@ class SourceRef:
             self.is_uri = bool(parsed.scheme) and len(parsed.scheme) > 1
 
     def _parse_line_range(self):
-        """Parse optional line range from value."""
+        """Parse optional line/character range from value."""
         match = _LINE_RANGE_PATTERN.match(self.value)
         if match:
             self._path_only = match.group(1)
             self.start_line = int(match.group(2))
             if match.group(3):
-                self.end_line = int(match.group(3))
+                self.start_column = int(match.group(3))
+            if match.group(4):
+                self.end_line = int(match.group(4))
+                if match.group(5):
+                    self.end_column = int(match.group(5))
             else:
-                # Single line reference: start and end are the same
+                # Single line/position reference: start and end are the same
                 self.end_line = self.start_line
+                self.end_column = self.start_column
         else:
             self._path_only = self.value
 
@@ -122,12 +130,27 @@ class SourceRef:
 
     @property
     def line_range_str(self) -> Optional[str]:
-        """Return formatted line range string, or None if no range."""
+        """Return formatted line/character range string, or None if no range."""
         if self.start_line is None:
             return None
-        if self.start_line == self.end_line:
-            return f":{self.start_line}"
-        return f":{self.start_line}-{self.end_line}"
+
+        # Build start position
+        if self.start_column is not None:
+            start = f":{self.start_line}:{self.start_column}"
+        else:
+            start = f":{self.start_line}"
+
+        # Check if end is the same as start (single position)
+        if self.start_line == self.end_line and self.start_column == self.end_column:
+            return start
+
+        # Build end position
+        if self.end_column is not None:
+            end = f"-{self.end_line}:{self.end_column}"
+        else:
+            end = f"-{self.end_line}"
+
+        return f"{start}{end}"
 
     def resolve(self, base_path: Optional[Path] = None) -> Path:
         """Resolve to a file path (relative paths resolved against base_path)."""
@@ -162,6 +185,7 @@ class Record:
     """A MarkBack record containing content and feedback."""
     feedback: str
     uri: Optional[str] = None
+    by: Optional[str] = None
     source: Optional[SourceRef] = None
     prior: Optional[SourceRef] = None
     content: Optional[str] = None
@@ -195,6 +219,7 @@ class Record:
         """Convert to JSON-serializable dict."""
         return {
             "uri": self.uri,
+            "by": self.by,
             "source": str(self.source) if self.source else None,
             "prior": str(self.prior) if self.prior else None,
             "content": self.content,

markback/writer.py

@@ -38,17 +38,21 @@ def write_record_canonical(
     )
 
     if use_compact:
-        # Compact format: @uri on its own line (if present), then @prior, then @source ... <<<
+        # Compact format: @uri, @by, @prior on own lines (if present), then @source ... <<<
         if record.uri:
             lines.append(f"@uri {record.uri}")
+        if record.by:
+            lines.append(f"@by {record.by}")
         if record.prior:
             lines.append(f"@prior {record.prior}")
         lines.append(f"@source {record.source} <<< {record.feedback}")
     else:
         # Full format
-        # Headers: @uri first, then @prior, then @source
+        # Headers: @uri first, then @by, then @prior, then @source
         if record.uri:
             lines.append(f"@uri {record.uri}")
+        if record.by:
+            lines.append(f"@by {record.by}")
         if record.prior:
             lines.append(f"@prior {record.prior}")
         if record.source:
@@ -151,7 +155,10 @@ def write_label_file(record: Record) -> str:
 
     if record.uri:
         lines.append(f"@uri {record.uri}")
-    
+
+    if record.by:
+        lines.append(f"@by {record.by}")
+
     if record.prior:
         lines.append(f"@prior {record.prior}")
 

{markback-0.1.2.dist-info → markback-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markback
-Version: 0.1.2
+Version: 0.1.5
 Summary: A compact, human-writable format for storing content paired with feedback/labels
 Project-URL: Homepage, https://github.com/dandriscoll/markback
 Project-URL: Repository, https://github.com/dandriscoll/markback
@@ -95,10 +95,17 @@ if result.has_errors:
 
 ## CLI Usage
 
+The CLI is available via two commands:
+- `markback` - Full command name
+- `mb` - Convenient shorthand (works on all platforms including Windows)
+
+Both commands are functionally identical. Examples below use `markback`, but you can substitute `mb` anywhere.
+
 ### Initialize configuration
 
 ```bash
 markback init
+# or: mb init
 ```
 
 Creates a `.env` file with all configuration options.

markback-0.1.5.dist-info/RECORD

@@ -0,0 +1,14 @@
+markback/__init__.py,sha256=B0-2dpUu5nkbnUI0hPz-x7PHiOl7M-tiRi6s3UCYJFk,1540
+markback/cli.py,sha256=DkqY5WlpIhbAJ9lp6Hja2ie9qzMumVqIWpALnkKzzXQ,3447
+markback/config.py,sha256=eTVhb7UwDER9FRYo8QUAvneLHSqXD2ZtLUgtBtnljUs,5455
+markback/linter.py,sha256=vKy5JHTEGspF4-lWRL9o4zDWieghqQWkah-bP_n8-kM,11977
+markback/llm.py,sha256=ON5_2C6v4KIk7_aIceulfWjEEI6hmallaPlLv-1-s_o,4692
+markback/parser.py,sha256=KHC1QKmN1wSnYgcobC36zXUqL6cdNsZajC6fHlhETZc,19016
+markback/types.py,sha256=t6HdFIWgBTlCfC2KRKKhSO4VBzfxZcP3Uq_zoh-bXZ4,11006
+markback/workflow.py,sha256=zC1RUm1i1wgiciFDqUilJKJ0-bgInvctxhQ0h5WSdoQ,10485
+markback/writer.py,sha256=HY_RYnEk27cIsodo9gGf_MvUb_Bvdmkz05S9kyq6Tdo,8093
+markback-0.1.5.dist-info/METADATA,sha256=dHKSIe4l5IxixOSII6s05lQbWGtL7OPwqyLR-VrhSgk,5405
+markback-0.1.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+markback-0.1.5.dist-info/entry_points.txt,sha256=o2T8WbdHx1yJPFm9nom7mAqKpldkHygGMGixZwm-1nc,68
+markback-0.1.5.dist-info/licenses/LICENSE,sha256=lLK1n13C_CXb0M10O-6itEIDY6dsXKutZYQH-09n6s0,1068
+markback-0.1.5.dist-info/RECORD,,

markback-0.1.5.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+markback = markback.cli:cli
+mb = markback.cli:cli

markback-0.1.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-markback/__init__.py,sha256=B0-2dpUu5nkbnUI0hPz-x7PHiOl7M-tiRi6s3UCYJFk,1540
-markback/cli.py,sha256=5wMk1OUG7W_voS9DxeFxRJrBTMabEdOK_s_o3Irxuu0,13639
-markback/config.py,sha256=eTVhb7UwDER9FRYo8QUAvneLHSqXD2ZtLUgtBtnljUs,5455
-markback/linter.py,sha256=IctgPEFNfGDo5DcELdo0Ni3d7Dp0bIWtlDw61ccWDOQ,11210
-markback/llm.py,sha256=ON5_2C6v4KIk7_aIceulfWjEEI6hmallaPlLv-1-s_o,4692
-markback/parser.py,sha256=P7GRjlwhy8j6Tnub7XAqILtZ4pFdkfdHhB-aIjLVRYU,18881
-markback/types.py,sha256=tFunBAoqUEVf9mi_4N1QwWmOsKt0nocZK7M7K_rybWg,10097
-markback/workflow.py,sha256=zC1RUm1i1wgiciFDqUilJKJ0-bgInvctxhQ0h5WSdoQ,10485
-markback/writer.py,sha256=3-LeupyuruGv4WZH9pV65hU4YDKuC5HgIIZ8YZ2SZnM,7896
-markback-0.1.2.dist-info/METADATA,sha256=d_xMmpicyEYeakJ4hA8SsrlGgj5Qxpd6fMv7tKf-eaI,5133
-markback-0.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-markback-0.1.2.dist-info/entry_points.txt,sha256=Bc9aXvtlPxVPuOJ9BWGngAVrkx5dMvRgujjVzXC-V5U,46
-markback-0.1.2.dist-info/licenses/LICENSE,sha256=lLK1n13C_CXb0M10O-6itEIDY6dsXKutZYQH-09n6s0,1068
-markback-0.1.2.dist-info/RECORD,,

markback-0.1.2.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-markback = markback.cli:app