kash-shell 0.3.28__py3-none-any.whl → 0.3.33__py3-none-any.whl

kash/exec/fetch_url_items.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 
 from kash.config.logger import get_logger
 from kash.exec.preconditions import is_url_resource
-from kash.model.items_model import Item, ItemType
+from kash.model.items_model import Format, Item, ItemType
 from kash.model.paths_model import StorePath
 from kash.utils.common.format_utils import fmt_loc
 from kash.utils.common.url import Url, is_url
@@ -36,7 +36,15 @@ def fetch_url_item(
     save_content: bool = True,
     refetch: bool = False,
     cache: bool = True,
+    overwrite: bool = True,
 ) -> FetchItemResult:
+    """
+    Fetch or load an URL or path. For a URL, will fetch the content and metadata and save
+    as an item in the workspace.
+
+    Returns:
+        The fetched or loaded item, already saved to the workspace.
+    """
     from kash.workspaces import current_ws
 
     ws = current_ws()
@@ -51,11 +59,22 @@ def fetch_url_item(
     else:
         raise InvalidInput(f"Not a URL or URL resource: {fmt_loc(locator)}")
 
-    return fetch_url_item_content(item, save_content=save_content, refetch=refetch, cache=cache)
+    return fetch_url_item_content(
+        item,
+        save_content=save_content,
+        refetch=refetch,
+        cache=cache,
+        overwrite=overwrite,
+    )
 
 
 def fetch_url_item_content(
-    item: Item, *, save_content: bool = True, refetch: bool = False, cache: bool = True
+    item: Item,
+    *,
+    save_content: bool = True,
+    refetch: bool = False,
+    cache: bool = True,
+    overwrite: bool = True,
 ) -> FetchItemResult:
     """
     Fetch content and metadata for a URL using a media service if we
@@ -67,8 +86,11 @@ def fetch_url_item_content(
 
     If `cache` is true, the content is also cached in the local file cache.
 
-    The content item is returned if content was saved. Otherwise, the updated
-    URL item is returned.
+    If `overwrite` is true, the item is saved at the same location every time.
+    This is useful to keep resource filenames consistent.
+
+    Returns:
+        The fetched or loaded item, already saved to the workspace.
     """
     from kash.media_base.media_services import get_media_metadata
     from kash.web_content.canon_url import canonicalize_url
@@ -76,9 +98,11 @@ def fetch_url_item_content(
     from kash.workspaces import current_ws
 
     ws = current_ws()
-    if not refetch and item.title and item.description and item.body:
+    # We could check for description too, but many pages don't have one.
+    has_key_content = item.title and (not item.has_body or item.body)
+    if not refetch and has_key_content:
         log.info(
-            "Already have title, description, and body, will not fetch: %s",
+            "Already have title so assuming metadata is up to date, will not fetch: %s",
             item.fmt_loc(),
         )
         return FetchItemResult(item, was_cached=True)
@@ -109,7 +133,10 @@ def fetch_url_item_content(
         url_item = item.merged_copy(url_item)
     else:
         page_data = fetch_page_content(url, refetch=refetch, cache=cache)
-        url_item = item.new_copy_with(
+        url_item = Item(
+            type=ItemType.resource,
+            format=Format.url,
+            url=url,
             title=page_data.title or item.title,
             description=page_data.description or item.description,
             thumbnail_url=page_data.thumbnail_url or item.thumbnail_url,
@@ -128,10 +155,10 @@ def fetch_url_item_content(
         log.warning("Failed to fetch page data: title is missing: %s", item.url)
 
     # Now save the updated URL item and also the content item if we have one.
-    ws.save(url_item)
+    ws.save(url_item, overwrite=overwrite)
     assert url_item.store_path
     if content_item:
-        ws.save(content_item)
+        ws.save(content_item, overwrite=overwrite)
         assert content_item.store_path
         log.info(
             "Saved both URL and content item: %s, %s",
@@ -144,4 +171,6 @@ def fetch_url_item_content(
     was_cached = bool(
         not page_data or (page_data.cache_result and page_data.cache_result.was_cached)
     )
-    return FetchItemResult(content_item or url_item, was_cached=was_cached, page_data=page_data)
+    return FetchItemResult(
+        item=content_item or url_item, was_cached=was_cached, page_data=page_data
+    )

kash/exec/llm_transforms.py

@@ -1,4 +1,5 @@
 from dataclasses import replace
+from typing import Unpack
 
 from chopdiff.docs import DiffFilter, TextDoc
 from chopdiff.transforms import WindowSettings, filtered_transform
@@ -12,7 +13,7 @@ from kash.llm_utils.fuzzy_parsing import strip_markdown_fence
 from kash.llm_utils.llm_completion import llm_template_completion
 from kash.llm_utils.llm_messages import Message, MessageTemplate
 from kash.model.actions_model import LLMOptions
-from kash.model.items_model import Item
+from kash.model.items_model import Item, ItemType, ItemUpdateOptions
 from kash.utils.errors import InvalidInput
 from kash.utils.file_utils.file_formats_model import Format
 from kash.utils.text_handling.doc_normalization import normalize_formatting
@@ -88,10 +89,11 @@ def llm_transform_str(options: LLMOptions, input_str: str, check_no_results: boo
 def llm_transform_item(
     item: Item,
     model: LLMName | None = None,
+    *,
     normalize: bool = True,
     strip_fence: bool = True,
     check_no_results: bool = True,
-    format: Format | None = None,
+    **updates: Unpack[ItemUpdateOptions],
 ) -> Item:
     """
     Main function for running an LLM action on an item.
@@ -99,6 +101,14 @@ def llm_transform_item(
     Model may be overridden by an explicit model parameter.
     Also by default cleans up and normalizes output as Markdown.
     """
+    # Default to Markdown docs.
+    if "format" not in updates:
+        updates["format"] = Format.markdown
+    if "type" not in updates:
+        updates["type"] = ItemType.doc
+    if "body" not in updates:
+        updates["body"] = None
+
     if not item.context:
         raise InvalidInput(f"LLM actions expect a context on input item: {item}")
     action = item.context.action
@@ -112,13 +122,12 @@ def llm_transform_item(
     log.message("LLM transform from action `%s` on item: %s", action.name, item)
     log.message("LLM options: %s", action.llm_options)
 
-    format = format or item.format or Format.markdown
-    result_item = item.derived_copy(body=None, format=format)
+    result_item = item.derived_copy(**updates)
     result_str = llm_transform_str(llm_options, item.body, check_no_results=check_no_results)
     if strip_fence:
         result_str = strip_markdown_fence(result_str)
     if normalize:
-        result_str = normalize_formatting(result_str, format=format)
+        result_str = normalize_formatting(result_str, format=updates["format"])
 
     result_item.body = result_str
     return result_item

kash/exec/preconditions.py

@@ -69,7 +69,7 @@ def is_instructions(item: Item) -> bool:
 
 @kash_precondition
 def is_url_resource(item: Item) -> bool:
-    return bool(item.type == ItemType.resource and item.url)
+    return bool(item.type == ItemType.resource and item.format == Format.url and item.url)
 
 
 @kash_precondition
@@ -126,7 +126,7 @@ def has_markdown_with_html_body(item: Item) -> bool:
 
 @kash_precondition
 def has_fullpage_html_body(item: Item) -> bool:
-    return bool(has_html_body(item) and item.body and is_fullpage_html(item.body))
+    return bool(has_html_compatible_body(item) and item.body and is_fullpage_html(item.body))
 
 
 @kash_precondition

kash/exec/resolve_args.py

@@ -118,10 +118,13 @@ def import_locator_args(
     *locators_or_strs: UnresolvedLocator,
     as_type: ItemType = ItemType.resource,
     reimport: bool = False,
+    with_sidematter: bool = False,
 ) -> list[StorePath]:
     """
     Import locators into the current workspace.
     """
     locators = [resolve_locator_arg(loc) for loc in locators_or_strs]
     ws = current_ws()
-    return ws.import_items(*locators, as_type=as_type, reimport=reimport)
+    return ws.import_items(
+        *locators, as_type=as_type, reimport=reimport, with_sidematter=with_sidematter
+    )

kash/exec/runtime_settings.py

@@ -102,9 +102,11 @@ def kash_runtime(
     override_state: State | None = None,
     tmp_output: bool = False,
     no_format: bool = False,
+    sync_to_s3: bool = False,
 ) -> RuntimeSettingsManager:
     """
     Set a specific kash execution context for a with block.
+
     This allows defining a workspace and other execution settings as the ambient
     context within the block.
 
@@ -130,5 +132,6 @@ def kash_runtime(
         override_state=override_state,
         tmp_output=tmp_output,
         no_format=no_format,
+        sync_to_s3=sync_to_s3,
     )
     return RuntimeSettingsManager(settings=settings)

kash/file_storage/file_store.py

@@ -1,5 +1,6 @@
 import functools
 import os
+import shutil
 import threading
 import time
 from collections.abc import Callable, Generator
@@ -9,25 +10,21 @@ from typing import Concatenate, ParamSpec, TypeVar
 
 from funlog import format_duration, log_calls
 from prettyfmt import fmt_lines, fmt_path
-from strif import copyfile_atomic, hash_file, move_file
+from sidematter_format import copy_sidematter, move_sidematter, remove_sidematter
+from strif import copyfile_atomic, hash_file
 from typing_extensions import override
 
 from kash.config.logger import get_log_settings, get_logger
 from kash.config.text_styles import EMOJI_SAVED
-from kash.file_storage.item_file_format import read_item, write_item
+from kash.file_storage.item_id_index import ItemIdIndex
 from kash.file_storage.metadata_dirs import MetadataDirs
-from kash.file_storage.store_filenames import (
-    folder_for_type,
-    join_suffix,
-    parse_item_filename,
-)
-from kash.model.items_model import Item, ItemId, ItemType
+from kash.file_storage.store_filenames import folder_for_type, join_suffix
+from kash.model.items_model import Item, ItemType
 from kash.model.paths_model import StorePath
 from kash.shell.output.shell_output import PrintHooks
 from kash.utils.common.format_utils import fmt_loc
-from kash.utils.common.uniquifier import Uniquifier
 from kash.utils.common.url import Locator, UnresolvedLocator, Url, is_url
-from kash.utils.errors import FileExists, FileNotFound, InvalidFilename, SkippableError
+from kash.utils.errors import FileExists, FileNotFound
 from kash.utils.file_utils.file_formats_model import Format
 from kash.utils.file_utils.file_walk import walk_by_dir
 from kash.utils.file_utils.ignore_files import IgnoreChecker, add_to_ignore
@@ -83,11 +80,6 @@ class FileStore(Workspace):
     def base_dir(self) -> Path:
         return self.base_dir_path
 
-    @property
-    @override
-    def assets_dir(self) -> Path:
-        return self.base_dir / "assets"
-
     @synchronized
     @log_calls(level="warning", if_slower_than=2.0)
     def reload(self, auto_init: bool = True):
@@ -98,9 +90,8 @@ class FileStore(Workspace):
         self.info_logged = False
         self.warnings: list[str] = []
 
-        # TODO: Move this to its own IdentifierIndex class, and make it exactly mirror disk state.
-        self.uniquifier = Uniquifier()
-        self.id_map: dict[ItemId, StorePath] = {}
+        # Index of item identifiers and unique slug history
+        self.id_index = ItemIdIndex()
 
         self.dirs = MetadataDirs(base_dir=self.base_dir, is_global_ws=self.is_global_ws)
         if not auto_init and not self.dirs.is_initialized():
@@ -137,7 +128,7 @@ class FileStore(Workspace):
     def _id_index_init(self):
         num_dups = 0
         for store_path in self.walk_items():
-            dup_path = self._id_index_item(store_path)
+            dup_path = self.id_index.index_item(store_path, self.load)
             if dup_path:
                 num_dups += 1
 
@@ -146,62 +137,6 @@ class FileStore(Workspace):
                 f"Found {num_dups} duplicate items in store. See `logs` for details."
             )
 
-    @synchronized
-    def _id_index_item(self, store_path: StorePath) -> StorePath | None:
-        """
-        Update metadata index with a new item.
-        """
-        name, item_type, _format, file_ext = parse_item_filename(store_path)
-        if not file_ext:
-            log.debug(
-                "Skipping file with unrecognized name or extension: %s",
-                fmt_path(store_path),
-            )
-            return None
-
-        full_suffix = join_suffix(item_type.name, file_ext.name) if item_type else file_ext.name
-        self.uniquifier.add(name, full_suffix)
-
-        dup_path = None
-
-        try:
-            item = self.load(store_path)
-            item_id = item.item_id()
-            if item_id:
-                old_path = self.id_map.get(item_id)
-                if old_path and old_path != store_path:
-                    dup_path = old_path
-                    log.info(
-                        "Duplicate items (%s):\n%s",
-                        item_id,
-                        fmt_lines([old_path, store_path]),
-                    )
-                self.id_map[item_id] = store_path
-        except (ValueError, SkippableError) as e:
-            log.warning(
-                "Could not load file, skipping from store index: %s: %s",
-                fmt_path(store_path),
-                e,
-            )
-
-        return dup_path
-
-    @synchronized
-    def _id_unindex_item(self, store_path: StorePath):
-        """
-        Remove an item from the metadata index.
-        """
-        try:
-            item = self.load(store_path)
-            item_id = item.item_id()
-            if item_id:
-                try:
-                    self.id_map.pop(item_id, None)
-                except KeyError:
-                    pass  # If we happen to reload a store it might no longer be in memory.
-        except (FileNotFoundError, InvalidFilename):
-            pass
-
     def resolve_to_store_path(self, path: Path | StorePath) -> StorePath | None:
         """
         Return a StorePath if the given path is within the store, otherwise None.
@@ -236,7 +171,6 @@ class FileStore(Workspace):
         """
         return (self.base_dir / store_path).exists()
 
-    @synchronized
     def _pick_filename_for(self, item: Item, *, overwrite: bool = False) -> tuple[str, str | None]:
         """
         Get a suitable filename for this item. If `overwrite` is true, use the the slugified
@@ -255,7 +189,7 @@ class FileStore(Workspace):
         slug = item.slug_name()
         full_suffix = item.get_full_suffix()
         # Get a unique name per item type.
-        unique_slug, old_slugs = self.uniquifier.uniquify_historic(slug, full_suffix)
+        unique_slug, old_slugs = self.id_index.uniquify_slug(slug, full_suffix)
 
         # Suffix files with both item type and a suitable file extension.
         new_unique_filename = join_suffix(unique_slug, full_suffix)
@@ -278,24 +212,34 @@ class FileStore(Workspace):
         Best effort to see if an item with the same identity is already in the store.
         """
         item_id = item.item_id()
-        log.info("Looking for item by id: %s", item_id)
+        log.info("Looking for item by id:\n%s", fmt_lines([item, item_id]))
         if not item_id:
             return None
         else:
-            store_path = self.id_map.get(item_id)
+            store_path = self.id_index.find_store_path_by_id(item_id)
             if not store_path:
-                # Just in case the id_map is not complete, check the default path too.
-                default_path = self.default_path_for(item)
-                if self.exists(default_path):
-                    old_item = self.load(default_path)
-                    if old_item.item_id() == item_id:
-                        log.info(
-                            "Item with the same id already saved (disk check):\n%s",
-                            fmt_lines([fmt_loc(default_path), item_id]),
-                        )
-                        store_path = default_path
-                        self.id_map[item_id] = default_path
-                        return default_path
+                # Just in case the index is not complete, check the other paths too
+                possible_paths = [
+                    p
+                    for p in [
+                        item.store_path,
+                        self.store_path_for(item)[0],
+                        self.default_path_for(item),
+                    ]
+                    if p
+                ]
+                for p in possible_paths:
+                    if self.exists(p):
+                        old_item = self.load(p)
+                        if old_item.item_id() == item_id:
+                            log.info(
+                                "Item with the same id already saved (disk check):\n%s",
+                                fmt_lines([fmt_loc(p), item_id]),
+                            )
+                            # Ensure index is updated consistently and with logging
+                            self.id_index.index_item(p, self.load)
+                            return p
+                log.info("Also checked paths but no id match:\n%s", fmt_lines(possible_paths))
             if store_path and self.exists(store_path):
                 log.info(
                     "Item with the same id already saved (disk check):\n%s",
@@ -325,9 +269,13 @@ class FileStore(Workspace):
             return self._tmp_path_for(item), None
         elif item.store_path:
             return StorePath(item.store_path), None
-        elif item_id in self.id_map and self.exists(self.id_map[item_id]):
+        elif (
+            item_id
+            and (existing := self.id_index.find_store_path_by_id(item_id))
+            and self.exists(existing)
+        ):
             # If this item has an identity and we've saved under that id before, use the same store path.
-            store_path = self.id_map[item_id]
+            store_path = existing
             log.info(
                 "When picking a store path, found an existing item with same id:\n%s",
                 fmt_lines([fmt_loc(store_path), item_id]),
@@ -345,16 +293,23 @@ class FileStore(Workspace):
 
             return StorePath(store_path), old_store_path
 
-    def target_path_for(self, item: Item) -> Path:
+    @synchronized
+    def assign_store_path(self, item: Item) -> Path:
         """
-        Get an the absolute path for an item. Use this if you need to work around the
-        usual save mechanism and write directly to the store yourself, at the location
-        the item usually would be saved.
+        Pick a new store path for the item and mutate `item.store_path`.
+
+        This is useful if you need to write to the store yourself, at the location
+        the item usually would be saved, and also want the path to be fixed.
 
-        If you write to this path, then set the item's `external_path` to indicate it's
-        already saved.
+        This is idempotent. If you also write to the file, call `mark_as_saved()`
+        to indicate that the file is now saved. Otherwise the item should be saved
+        with `save()`.
+
+        Returns the absolute path, for convenience if you wish to write to the file
+        directly.
         """
         store_path, _old_store_path = self.store_path_for(item)
+        item.store_path = str(store_path)
         return self.base_dir / store_path
 
     def _tmp_path_for(self, item: Item) -> StorePath:
@@ -412,6 +367,8 @@ class FileStore(Workspace):
             # Indicate this is an item with a store path, not an external path.
             # Keep external_path set so we know body is in that file.
             item.store_path = str(rel_path)
+            # Ensure index is updated for items written directly into the store.
+            self.id_index.index_item(StorePath(rel_path), self.load)
             return StorePath(rel_path)
         else:
             # Otherwise it's still in memory or in a file outside the workspace and we need to save it.
@@ -455,6 +412,8 @@ class FileStore(Workspace):
                     # Save as a text item with frontmatter.
                     if item.external_path:
                         item.body = Path(item.external_path).read_text()
+                    from kash.file_storage.item_file_format import write_item
+
                     write_item(item, full_path, normalize=not no_format)
             except OSError as e:
                 log.error("Error saving item: %s", e)
@@ -485,7 +444,7 @@ class FileStore(Workspace):
 
         # Update in-memory store_path only after successful save.
         item.store_path = str(store_path)
-        self._id_index_item(store_path)
+        self.id_index.index_item(store_path, self.load)
 
         if not skipped_save:
             log.message("%s Saved item: %s", EMOJI_SAVED, fmt_loc(store_path))
@@ -499,6 +458,8 @@ class FileStore(Workspace):
         """
         Load item at the given path.
         """
+        from kash.file_storage.item_file_format import read_item
+
         return read_item(self.base_dir / store_path, self.base_dir)
 
     def hash(self, store_path: StorePath) -> str:
@@ -513,6 +474,7 @@ class FileStore(Workspace):
         *,
         as_type: ItemType | None = None,
         reimport: bool = False,
+        with_sidematter: bool = False,
     ) -> StorePath:
         """
         Add resources from files or URLs. If a locator is a path, copy it into the store.
@@ -520,11 +482,15 @@ class FileStore(Workspace):
         are not imported again and the existing store path is returned.
         If `as_type` is specified, it will be used to override the item type, otherwise
         we go with our best guess.
+        If `with_sidematter` is true, will copy any sidematter files (metadata/assets) to
+        the destination.
         """
+        from kash.file_storage.item_file_format import read_item
         from kash.web_content.canon_url import canonicalize_url
 
         if isinstance(locator, StorePath) and not reimport:
             log.info("Store path already imported: %s", fmt_loc(locator))
+            self.id_index.index_item(locator, self.load)
             return locator
         elif is_url(locator):
             # Import a URL as a resource.
@@ -580,6 +546,9 @@ class FileStore(Workspace):
                 # we'll pick a new store path.
                 store_path = self.save(item)
                 log.info("Imported text file: %s", item.as_str())
+                # If requested, also copy any sidematter files (metadata/assets) to match destination.
+                if with_sidematter:
+                    copy_sidematter(path, self.base_dir / store_path, copy_original=False)
             else:
                 # Binary or other files we just copy over as-is, preserving the name.
                 # We know the extension is recognized.
@@ -588,7 +557,10 @@ class FileStore(Workspace):
                     raise FileExists(f"Resource already in store: {fmt_loc(store_path)}")
 
                 log.message("Importing resource: %s", fmt_loc(path))
-                copyfile_atomic(path, self.base_dir / store_path, make_parents=True)
+                if with_sidematter:
+                    copy_sidematter(path, self.base_dir / store_path)
+                else:
+                    copyfile_atomic(path, self.base_dir / store_path, make_parents=True)
 
                 # Optimization: Don't import an identical file twice.
                 if old_store_path:
@@ -599,7 +571,10 @@ class FileStore(Workspace):
                             "Imported resource is identical to the previous import: %s",
                             fmt_loc(old_store_path),
                         )
-                        os.unlink(self.base_dir / store_path)
+                        if with_sidematter:
+                            remove_sidematter(self.base_dir / store_path)
+                        else:
+                            os.unlink(self.base_dir / store_path)
                         store_path = old_store_path
                 log.message("Imported resource: %s", fmt_loc(store_path))
             return store_path
@@ -609,16 +584,20 @@ class FileStore(Workspace):
         *locators: Locator,
         as_type: ItemType | None = None,
         reimport: bool = False,
+        with_sidematter: bool = False,
     ) -> list[StorePath]:
         return [
-            self.import_item(locator, as_type=as_type, reimport=reimport) for locator in locators
+            self.import_item(
+                locator, as_type=as_type, reimport=reimport, with_sidematter=with_sidematter
+            )
+            for locator in locators
         ]
 
-    def import_and_load(self, locator: UnresolvedLocator) -> Item:
+    def import_and_load(self, locator: UnresolvedLocator, with_sidematter: bool = False) -> Item:
         """
         Import a locator and return the item.
         """
-        store_path = self.import_item(locator)
+        store_path = self.import_item(locator, with_sidematter=with_sidematter)
         return self.load(store_path)
 
     def _filter_selection_paths(self):
@@ -645,7 +624,7 @@ class FileStore(Workspace):
         """
         self.selections.remove_values(store_paths)
         for store_path in store_paths:
-            self._id_unindex_item(store_path)
+            self.id_index.unindex_item(store_path, self.load)
         # TODO: Update metadata of all relations that point to this path too.
 
     @synchronized
@@ -655,12 +634,17 @@ class FileStore(Workspace):
         """
         self.selections.replace_values(replacements)
         for store_path, new_store_path in replacements:
-            self._id_unindex_item(store_path)
-            self._id_index_item(new_store_path)
+            self.id_index.unindex_item(store_path, self.load)
+            self.id_index.index_item(new_store_path, self.load)
         # TODO: Update metadata of all relations that point to this path too.
 
     def archive(
-        self, store_path: StorePath, *, missing_ok: bool = False, quiet: bool = False
+        self,
+        store_path: StorePath,
+        *,
+        missing_ok: bool = False,
+        quiet: bool = False,
+        with_sidematter: bool = False,
     ) -> StorePath:
         """
         Archive the item by moving it into the archive directory.
@@ -672,20 +656,25 @@ class FileStore(Workspace):
                 fmt_loc(self.dirs.archive_dir),
             )
         orig_path = self.base_dir / store_path
-        archive_path = self.dirs.archive_dir / store_path
+        full_archive_path = self.base_dir / self.dirs.archive_dir / store_path
         if missing_ok and not orig_path.exists():
             log.message("Item to archive not found so moving on: %s", fmt_loc(orig_path))
             return store_path
         if not orig_path.exists():
             log.warning("Item to archive not found: %s", fmt_loc(orig_path))
             return store_path
-        move_file(orig_path, archive_path)
+        # Remove references (including id_map) before moving so we can load the item to compute id.
         self._remove_references([store_path])
+        if with_sidematter:
+            move_sidematter(orig_path, full_archive_path)
+        else:
+            os.makedirs(full_archive_path.parent, exist_ok=True)
+            shutil.move(orig_path, full_archive_path)
 
         archive_path = StorePath(self.dirs.archive_dir / store_path)
         return archive_path
 
-    def unarchive(self, store_path: StorePath) -> StorePath:
+    def unarchive(self, store_path: StorePath, with_sidematter: bool = False) -> StorePath:
         """
         Unarchive the item by moving back out of the archive directory.
         Path may be with or without the archive dir prefix.
@@ -695,7 +684,12 @@ class FileStore(Workspace):
         if full_input_path.is_relative_to(full_archive_path):
             store_path = StorePath(relpath(full_input_path, full_archive_path))
         original_path = self.base_dir / store_path
-        move_file(full_input_path, original_path)
+        if with_sidematter:
+            move_sidematter(full_input_path, original_path)
+        else:
+            shutil.move(full_input_path, original_path)
+        # Re-index after restoring from archive.
+        self.id_index.index_item(store_path, self.load)
         return StorePath(store_path)
 
     @synchronized
@@ -712,7 +706,7 @@ class FileStore(Workspace):
         log.message(
             "Using workspace: %s (%s items)",
             fmt_path(self.base_dir, rel_to_cwd=False),
-            len(self.uniquifier),
+            len(self.id_index),
         )
         log.message(
             "Logging to: %s",