obris-cli 0.7.0__tar.gz → 0.7.3__tar.gz

{obris_cli-0.7.0 → obris_cli-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: obris-cli
-Version: 0.7.0
+Version: 0.7.3
 Summary: Save, organize, and access your knowledge from the command line
 Project-URL: Homepage, https://obris.ai
 Project-URL: Repository, https://github.com/obris-dev/obris

{obris_cli-0.7.0 → obris_cli-0.7.3}/README.md

@@ -43,6 +43,7 @@ Opens a browser to log in. The CLI waits, you authorize, done. Works from any ma
 | `obris sync [path]` | Sync a directory with an Obris topic |
 | `obris sync add <file>` | Add a local file to a synced topic |
 | `obris sync link <file> -i <id>` | Relink a renamed file |
+| `obris sync unlink <file-or-id>` | Break the local-to-remote sync link |
 | `obris topic list` | List all topics |
 | `obris topic view <id>` | View a topic and its knowledge items |
 | `obris knowledge view <id>` | View a knowledge item |

{obris_cli-0.7.0 → obris_cli-0.7.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "obris-cli"
-version = "0.7.0"
+version = "0.7.3"
 description = "Save, organize, and access your knowledge from the command line"
 
 requires-python = ">=3.10"

{obris_cli-0.7.0 → obris_cli-0.7.3}/src/obris/commands/sync.py

@@ -7,8 +7,9 @@ from obris.commands.sync_config import register as _register_config_subcommands
 from obris.commands.sync_conflicts import register as _register_conflicts_subgroup
 from obris.output import as_json, is_json
 from obris.sync.commands import add_file, link_file
+from obris.sync.preview import preview_first_sync
 from obris.sync.resolver import assert_all_roots, find_root_id, resolve_targets
-from obris.sync.runner import preview_first_sync, run_sync_pass
+from obris.sync.runner import run_sync_pass
 from obris.sync.state import SyncState
 
 
@@ -68,6 +69,15 @@ def sync(ctx, path, topic_id, item_ids, include_patterns, dry_run, add_all_files
 
     targets = resolve_targets(sync_dir, topic_id, no_create=no_create, dry_run=dry_run)
 
+    if add_all_files and len(targets) > 1:
+        topic_ids = [t[1] for t in targets]
+        raise click.UsageError(
+            "--add-all is ambiguous when multiple topics are linked to this "
+            "directory. Pass --topic <id> to scope it to one topic, or use "
+            "'obris sync add <file> -t <id>' to add files one at a time.\n"
+            f"  Linked topics: {', '.join(topic_ids)}"
+        )
+
     if not targets:
         # dry-run + no state + no --topic: preview the bootstrap +
         # initial-add locally without creating a phantom server topic.
@@ -102,6 +112,7 @@ def sync(ctx, path, topic_id, item_ids, include_patterns, dry_run, add_all_files
                 "symlinks": totals["symlinks"],
                 "conflicts_pending": totals["conflicts_pending"],
                 "missing_local": totals["missing_local"],
+                "skipped_by_include": totals.get("skipped_by_include", []),
             }
         )
 
@@ -213,7 +224,7 @@ def sync_link(file, item_id, topic_id):
     click.echo(f'Linked "{filepath.name}" to item {item_id}')
 
 
-# Per-checkout configuration subcommands (exclude / include / untrack)
+# Per-checkout configuration subcommands (exclude / include / unlink)
 # and the conflicts subgroup live in separate modules to keep this
 # file under the 300-line cap.
 _register_config_subcommands(sync)

{obris_cli-0.7.0 → obris_cli-0.7.3}/src/obris/commands/sync_config.py

@@ -1,6 +1,6 @@
 """Per-checkout sync configuration subcommands.
 
-Hosts ``exclude`` / ``include`` / ``untrack`` — commands that modify
+Hosts ``exclude`` / ``include`` / ``unlink`` — commands that modify
 state-file metadata for a synced directory. Kept out of
 ``commands.sync`` so the sync group definition + invocation logic
 stays under the 300-line cap and these subcommands stay together
@@ -88,26 +88,26 @@ def register(sync):
         results = _apply_pattern_action(states, patterns, action="include", sync_dir=sync_dir)
         _emit_outcomes(sync_dir, results, action="include")
 
-    @sync.command("untrack")
+    @sync.command("unlink")
     @click.argument("targets", nargs=-1, required=True)
     @click.option("--path", "-p", default=".", help="Sync directory (defaults to current directory)")
-    def sync_untrack(targets, path):
-        """Stop syncing items without deleting either side.
+    def sync_unlink(targets, path):
+        """Break the local-to-remote sync link without deleting either side.
 
-        Each TARGET is a knowledge ID or a tracked filename (basename).
+        Each TARGET is a knowledge ID or a linked filename (basename).
         Removes the sync link; both the local file and the remote item stay
         in place. Subsequent 'obris sync' calls will not re-pull these items.
 
         \b
-          obris sync untrack abc123
-          obris sync untrack notes.md draft.md
+          obris sync unlink abc123
+          obris sync unlink notes.md draft.md
 
         Re-link later with 'obris sync link <file> -i <id>' or 'obris sync add'.
         Permanently delete the remote with 'obris knowledge delete <id>'.
         """
         sync_dir, states = _states_for_current_dir(path)
 
-        untracked = []
+        unlinked = []
         not_found = []
         for target in targets:
             matches = _resolve_target(target, states)
@@ -115,7 +115,7 @@ def register(sync):
                 not_found.append(target)
                 continue
             if len(matches) > 1:
-                click.echo(f"Ambiguous: '{target}' matches multiple tracked items:")
+                click.echo(f"Ambiguous: '{target}' matches multiple linked items:")
                 for state, kid in matches:
                     entry = state.get(kid)
                     click.echo(f"  {kid}  ({entry.filename})")
@@ -126,15 +126,15 @@ def register(sync):
             state.untrack(kid)
             state.mark_unlinked(kid)
             state.save()
-            untracked.append((kid, entry.filename))
+            unlinked.append((kid, entry.filename))
 
-        if untracked:
-            click.echo(f"Untracked {len(untracked)} item(s):")
-            for kid, name in untracked:
+        if unlinked:
+            click.echo(f"Unlinked {len(unlinked)} item(s):")
+            for kid, name in unlinked:
                 click.echo(f"  {name}  ({kid})")
             click.echo(f"  Local files and remote items unchanged in {sync_dir}/.")
         if not_found:
-            click.echo(f"Not tracked: {', '.join(not_found)}", err=True)
+            click.echo(f"Not linked: {', '.join(not_found)}", err=True)
             raise SystemExit(1)
 
 

{obris_cli-0.7.0 → obris_cli-0.7.3}/src/obris/sync/engine/run.py

@@ -128,7 +128,7 @@ def run_sync(
             continue
         seen_ids.add(item.id)
         if state.is_unlinked(item.id):
-            # User ran 'obris sync untrack' on this id. Leave the
+            # User ran 'obris sync unlink' on this id. Leave the
             # remote alone, don't pull, don't surface — they
             # explicitly opted out of syncing this item.
             continue

{obris_cli-0.7.0 → obris_cli-0.7.3}/src/obris/sync/engine/tracked.py

@@ -78,7 +78,7 @@ def sync_tracked_item(topic_id, item, entry, state, sync_dir, desired_rel, *, dr
         click.echo(f"  Missing locally: {display}  (knowledge_id {item.id})")
         click.echo("    Options:")
         click.echo(f"      obris sync link <new-path> -i {item.id}    # moved or renamed")
-        click.echo(f"      obris sync untrack {item.id}               # keep both copies, stop syncing")
+        click.echo(f"      obris sync unlink {item.id}                 # keep both copies, break the link")
         click.echo(f"      obris knowledge delete {item.id}           # remove the remote item")
         return MISSING
 

obris_cli-0.7.3/src/obris/sync/preview.py

@@ -0,0 +1,109 @@
+"""Local-only dry-run preview for first-time syncs.
+
+Used when the user runs ``obris sync --dry-run`` against a directory
+that has no linked topic yet — ``resolve_targets`` returns an empty
+target list rather than creating a phantom topic on the server, and
+the sync command falls through to this preview helper instead of
+the regular ``run_sync_pass``.
+
+Side-effect free: walks the dir using a synthetic ``SyncState`` so
+the same exclusion + symlink + tracked-name logic runs as on a real
+sync. Reports what ``create_topic``, ``_ensure_subtopic_path``, and
+``add_all`` *would* do without touching the server.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+
+import click
+
+from obris.sync.scanner import find_untracked
+from obris.sync.state import SyncState
+
+
+def preview_first_sync(sync_dir: Path, *, add_all_files: bool, allow_subtopics: bool) -> dict:
+    """Render a local-only preview of what a first sync would create.
+
+    Output sections (each only emitted when non-empty):
+
+    - the would-be root topic name
+    - the subtopic structure that would be mirrored from local subdirs
+    - untracked files (gated on ``--add-all`` and ``--no-subtopics``)
+    - ignored files (always shown — user explicitly asked for the full picture)
+    - symlinks (always shown)
+
+    Returns the same totals dict shape as ``run_sync_pass`` so the
+    JSON output stays consistent across both code paths.
+    """
+    sync_dir = Path(sync_dir).resolve()
+    topic_name = sync_dir.name
+    click.echo("  (dry run — no changes will be made)")
+    click.echo(f'  Would create topic "{topic_name}" at {sync_dir}/')
+
+    synthetic = SyncState("__preview__", str(sync_dir))
+    scan = find_untracked(sync_dir, [(synthetic, "__preview__")])
+
+    # Subtopic projection: every directory segment under sync_dir that
+    # contains an untracked file would become a subtopic level. Mirrors
+    # the cache walk in ``scanner._ensure_subtopic_path``.
+    subdirs: set[str] = set()
+    skipped_subdir = 0
+    if allow_subtopics:
+        for rel in scan.untracked:
+            rel_dir = str(PurePosixPath(rel).parent)
+            if rel_dir == ".":
+                continue
+            walked = ""
+            for seg in rel_dir.split("/"):
+                walked = f"{walked}/{seg}" if walked else seg
+                subdirs.add(walked)
+    else:
+        skipped_subdir = sum(1 for rel in scan.untracked if "/" in rel)
+
+    if subdirs:
+        click.echo(f"\nWould create {len(subdirs)} subtopic(s):")
+        for sd in sorted(subdirs):
+            click.echo(f"  {sd}/")
+
+    if scan.untracked:
+        if not add_all_files:
+            click.echo(f"\n{len(scan.untracked)} untracked file(s) (would NOT add — re-run with --add-all):")
+            _print_all(scan.untracked)
+        elif not allow_subtopics:
+            top_level = [r for r in scan.untracked if "/" not in r]
+            click.echo(f"\nWould add {len(top_level)} top-level file(s):")
+            _print_all(top_level)
+            if skipped_subdir:
+                click.echo(f"\nWould skip {skipped_subdir} file(s) in subdirs (--no-subtopics):")
+                _print_all([r for r in scan.untracked if "/" in r])
+        else:
+            click.echo(f"\nWould add {len(scan.untracked)} file(s):")
+            _print_all(scan.untracked)
+
+    if scan.excluded:
+        click.echo(f"\n{len(scan.excluded)} file(s) matched ignore rules:")
+        _print_all(scan.excluded)
+
+    if scan.symlinks:
+        click.echo(f"\n{len(scan.symlinks)} symlink(s) skipped:")
+        _print_all([f"{p} -> {t}" for p, t in scan.symlinks])
+
+    return {
+        "pulled": 0,
+        "pushed": 0,
+        "conflicts": 0,
+        "errors": 0,
+        "untracked": list(scan.untracked),
+        "excluded_count": len(scan.excluded),
+        "symlinks": [{"path": p, "target": t} for p, t in scan.symlinks],
+        "conflicts_pending": [],
+        "missing_local": [],
+        "skipped_by_include": [],
+    }
+
+
+def _print_all(items):
+    """Print every item, one per line, indented."""
+    for line in items:
+        click.echo(f"  {line}")

{obris_cli-0.7.0 → obris_cli-0.7.3}/src/obris/sync/runner.py

@@ -8,6 +8,7 @@ import click
 
 from obris.api.topics import get_topic
 from obris.sync.engine import run_sync
+from obris.sync.engine.filters import any_match
 from obris.sync.resolver import find_root
 from obris.sync.scanner import add_all, find_untracked
 from obris.sync.state import SyncState
@@ -47,6 +48,7 @@ def run_sync_pass(
         "symlinks": [],
         "conflicts_pending": [],
         "missing_local": [],
+        "skipped_by_include": [],
     }
 
     if dry_run:
@@ -98,9 +100,23 @@ def run_sync_pass(
     if not fresh_states:
         return totals
     scan = find_untracked(sync_dir, fresh_states)
+
+    # When --add-all is combined with --include, the bulk-add should
+    # honor the same scope the rest of the sync uses — pull, push,
+    # tracked-item dispatch, remote-deleted detection all already
+    # respect ``patterns``. ``find_untracked`` doesn't see the patterns,
+    # so we partition its result here. Files outside the include scope
+    # are surfaced separately so the user knows they were skipped on
+    # purpose, not silently dropped.
+    out_of_include_scope: list[str] = []
+    if add_all_files and patterns and scan.untracked:
+        in_scope, out_of_include_scope = _partition_by_include(scan.untracked, patterns)
+        scan.untracked = in_scope
+
     totals["untracked"] = list(scan.untracked)
     totals["excluded_count"] = len(scan.excluded)
     totals["symlinks"] = [{"path": p, "target": t} for p, t in scan.symlinks]
+    totals["skipped_by_include"] = list(out_of_include_scope)
     for state, _tid in fresh_states:
         for kid, meta in state.conflicts.items():
             entry = state.get(kid)
@@ -117,14 +133,20 @@ def run_sync_pass(
             )
     _emit_scan(scan, sync_dir, add_all_files, dry_run=dry_run, verbose=verbose)
 
+    if out_of_include_scope:
+        cap = None if verbose else _LIST_PREVIEW
+        click.echo(f"\nSkipped {len(out_of_include_scope)} untracked file(s) outside --include scope:")
+        _print_capped(out_of_include_scope, cap)
+
     if add_all_files and scan.untracked and not dry_run:
-        # All targets share the same sync_dir; bulk-add against the
-        # first state's root. Multi-root dirs are an edge case we
-        # don't optimize for here.
-        first_state, root_id = fresh_states[0]
+        # Bulk-add into the resolved target. The CLI rejects --add-all
+        # in multi-topic directories without an explicit --topic, so by
+        # the time we get here ``targets`` has exactly one entry.
+        target_tid = targets[0][1]
+        target_state = next(s for s, tid in fresh_states if tid == target_tid)
         counts = add_all(
-            first_state,
-            root_id,
+            target_state,
+            target_tid,
             sync_dir,
             scan.untracked,
             allow_subtopics=allow_subtopics,
@@ -176,6 +198,29 @@ def _emit_scan(scan, sync_dir, add_all_files, *, dry_run=False, verbose=False):
         _print_capped(scan.excluded, cap)
 
 
+def _partition_by_include(rels: list[str], patterns: list[str]) -> tuple[list[str], list[str]]:
+    """Split untracked rel-paths by whether their parent dir is in --include scope.
+
+    A file's parent directory becomes (or maps to) a subtopic name path
+    when ``--add-all`` runs; we test the same name path against the
+    patterns the engine already evaluates against the remote subtree.
+    Root-level files (parent is ``"."``) test against an empty segment
+    list — patterns like ``Projects/**`` won't match, which mirrors
+    the engine's own behaviour where the root topic isn't in
+    ``matched_ids`` when patterns are set.
+    """
+    in_scope: list[str] = []
+    out_of_scope: list[str] = []
+    for rel in rels:
+        rel_dir = str(PurePosixPath(rel).parent)
+        segments = [] if rel_dir == "." else [s for s in rel_dir.split("/") if s]
+        if any_match(segments, patterns):
+            in_scope.append(rel)
+        else:
+            out_of_scope.append(rel)
+    return in_scope, out_of_scope
+
+
 def _print_capped(items, cap):
     """Print at most ``cap`` items, then a "... N more" line. None = no cap."""
     shown = items if cap is None else items[:cap]
@@ -183,84 +228,3 @@ def _print_capped(items, cap):
         click.echo(f"  {line}")
     if cap is not None and len(items) > cap:
         click.echo(f"  ... ({len(items) - cap} more)")
-
-
-def preview_first_sync(sync_dir: Path, *, add_all_files: bool, allow_subtopics: bool) -> dict:
-    """Local-only dry-run preview for a fresh directory.
-
-    Called when ``resolve_targets`` returned ``[]`` (dry-run + no
-    state + no ``--topic``). Side-effect free: walks the dir using a
-    synthetic empty ``SyncState`` so ``find_untracked`` reuses the
-    same exclusion + symlink logic the live path uses, then prints
-    what create_topic / _ensure_subtopic_path / add_all would do.
-
-    Ignored files are surfaced unconditionally — the user explicitly
-    asked for the full picture before committing to a real sync.
-
-    Returns the same totals dict shape as ``run_sync_pass`` so the
-    JSON output stays consistent.
-    """
-    sync_dir = Path(sync_dir).resolve()
-    topic_name = sync_dir.name
-    click.echo("  (dry run — no changes will be made)")
-    click.echo(f'  Would create topic "{topic_name}" at {sync_dir}/')
-
-    synthetic = SyncState("__preview__", str(sync_dir))
-    scan = find_untracked(sync_dir, [(synthetic, "__preview__")])
-
-    # Subtopic projection: every directory segment under sync_dir that
-    # contains an untracked file would become a subtopic level. Mirrors
-    # the cache walk in ``scanner._ensure_subtopic_path``.
-    subdirs: set[str] = set()
-    skipped_subdir = 0
-    if allow_subtopics:
-        for rel in scan.untracked:
-            rel_dir = str(PurePosixPath(rel).parent)
-            if rel_dir == ".":
-                continue
-            walked = ""
-            for seg in rel_dir.split("/"):
-                walked = f"{walked}/{seg}" if walked else seg
-                subdirs.add(walked)
-    else:
-        skipped_subdir = sum(1 for rel in scan.untracked if "/" in rel)
-
-    if subdirs:
-        click.echo(f"\nWould create {len(subdirs)} subtopic(s):")
-        for sd in sorted(subdirs):
-            click.echo(f"  {sd}/")
-
-    if scan.untracked:
-        if not add_all_files:
-            click.echo(f"\n{len(scan.untracked)} untracked file(s) (would NOT add — re-run with --add-all):")
-            _print_capped(scan.untracked, None)
-        elif not allow_subtopics:
-            top_level = [r for r in scan.untracked if "/" not in r]
-            click.echo(f"\nWould add {len(top_level)} top-level file(s):")
-            _print_capped(top_level, None)
-            if skipped_subdir:
-                click.echo(f"\nWould skip {skipped_subdir} file(s) in subdirs (--no-subtopics):")
-                _print_capped([r for r in scan.untracked if "/" in r], None)
-        else:
-            click.echo(f"\nWould add {len(scan.untracked)} file(s):")
-            _print_capped(scan.untracked, None)
-
-    if scan.excluded:
-        click.echo(f"\n{len(scan.excluded)} file(s) matched ignore rules:")
-        _print_capped(scan.excluded, None)
-
-    if scan.symlinks:
-        click.echo(f"\n{len(scan.symlinks)} symlink(s) skipped:")
-        _print_capped([f"{p} -> {t}" for p, t in scan.symlinks], None)
-
-    return {
-        "pulled": 0,
-        "pushed": 0,
-        "conflicts": 0,
-        "errors": 0,
-        "untracked": list(scan.untracked),
-        "excluded_count": len(scan.excluded),
-        "symlinks": [{"path": p, "target": t} for p, t in scan.symlinks],
-        "conflicts_pending": [],
-        "missing_local": [],
-    }

{obris_cli-0.7.0 → obris_cli-0.7.3}/src/obris/sync/state.py

@@ -237,7 +237,7 @@ class SyncState:
     def mark_unlinked(self, knowledge_id):
         """Record that ``knowledge_id`` should not be auto-re-pulled.
 
-        Used by ``obris sync untrack`` so subsequent syncs don't yank
+        Used by ``obris sync unlink`` so subsequent syncs don't yank
         the remote copy back down. Cleared automatically by ``track``.
         """
         if knowledge_id and knowledge_id not in self._unlinked_ids:

{obris_cli-0.7.0 → obris_cli-0.7.3}/uv.lock

@@ -141,7 +141,7 @@ wheels = [
 
 [[package]]
 name = "obris-cli"
-version = "0.7.0"
+version = "0.7.3"
 source = { editable = "." }
 dependencies = [
     { name = "click" },