donna 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

donna/{world → workspaces}/config.py

@@ -8,11 +8,11 @@ from donna.core.errors import ErrorsList
 from donna.core.result import Err, Ok, Result
 from donna.domain.ids import PythonImportPath, WorldId
 from donna.machine.primitives import resolve_primitive
-from donna.world import errors as world_errors
-from donna.world.sources.base import SourceConfig as SourceConfigValue
-from donna.world.sources.base import SourceConstructor
-from donna.world.worlds.base import World as BaseWorld
-from donna.world.worlds.base import WorldConstructor
+from donna.workspaces import errors as world_errors
+from donna.workspaces.sources.base import SourceConfig as SourceConfigValue
+from donna.workspaces.sources.base import SourceConstructor
+from donna.workspaces.worlds.base import World as BaseWorld
+from donna.workspaces.worlds.base import WorldConstructor
 
 DONNA_DIR_NAME = ".donna"
 DONNA_CONFIG_NAME = "config.toml"
@@ -152,7 +152,14 @@ class Config(BaseEntity):
             if source.kind == kind:
                 return Ok(source)
 
-        return Err([world_errors.SourceConfigNotConfigured(kind=kind)])
+        return Err(
+            [
+                world_errors.SourceConfigNotConfigured(
+                    source_id=kind,
+                    kind=kind,
+                )
+            ]
+        )
 
     def find_source_for_extension(self, extension: str) -> SourceConfigValue | None:
         for source in self._sources_instances:

donna/{world → workspaces}/errors.py

@@ -5,64 +5,82 @@ from donna.domain.ids import ArtifactId, FullArtifactId, WorldId
 
 
 class InternalError(core_errors.InternalError):
-    """Base class for internal errors in donna.world."""
+    """Base class for internal errors in donna.workspaces."""
 
 
-class WorldError(core_errors.EnvironmentError):
-    cell_kind: str = "world_error"
+class WorkspaceError(core_errors.EnvironmentError):
+    cell_kind: str = "workspace_error"
 
 
-class WorldConfigError(WorldError):
-    cell_kind: str = "world_config_error"
+class WorkspaceConfigError(WorkspaceError):
+    cell_kind: str = "workspace_config_error"
     config_path: pathlib.Path
 
     def content_intro(self) -> str:
-        return f"Error in world config file '{self.config_path}'"
+        return f"Error in workspace config file '{self.config_path}'"
 
 
-class ConfigParseFailed(WorldConfigError):
-    code: str = "donna.world.config_parse_failed"
+class ConfigParseFailed(WorkspaceConfigError):
+    code: str = "donna.workspaces.config_parse_failed"
     message: str = "Failed to parse config file: {error.details}"
     details: str
 
 
-class ConfigValidationFailed(WorldConfigError):
-    code: str = "donna.world.config_validation_failed"
+class ConfigValidationFailed(WorkspaceConfigError):
+    code: str = "donna.workspaces.config_validation_failed"
     message: str = "Failed to validate config file: {error.details}"
     details: str
 
 
+class WorkspaceAlreadyInitialized(WorkspaceError):
+    code: str = "donna.workspaces.workspace_already_initialized"
+    message: str = "Workspace already initialized at `{error.project_dir}`"
+    ways_to_fix: list[str] = [
+        "Continue using the existing workspace.",
+        "Remove the existing `.donna` directory if you want to reinitialize.",
+        "Choose a different project directory.",
+    ]
+    project_dir: pathlib.Path
+
+
+class WorldError(WorkspaceError):
+    cell_kind: str = "world_error"
+    world_id: WorldId
+
+
 class WorldNotConfigured(WorldError):
-    code: str = "donna.world.world_not_configured"
+    code: str = "donna.workspaces.world_not_configured"
     message: str = "World with id `{error.world_id}` is not configured"
-    world_id: WorldId
 
 
-class SourceConfigNotConfigured(WorldError):
-    code: str = "donna.world.source_config_not_configured"
+class SourceError(WorkspaceError):
+    cell_kind: str = "source_error"
+    source_id: str
+
+
+class SourceConfigNotConfigured(SourceError):
+    code: str = "donna.workspaces.source_config_not_configured"
     message: str = "Source config `{error.kind}` is not configured"
     kind: str
 
 
 class WorldReadonly(WorldError):
-    code: str = "donna.world.world_readonly"
+    code: str = "donna.workspaces.world_readonly"
     message: str = "World `{error.world_id}` is read-only"
     ways_to_fix: list[str] = [
         "Use a world configured with readonly = false. Most likely they are `project` and `session`.",
     ]
-    world_id: WorldId
 
 
 class WorldStateStorageUnsupported(WorldError):
-    code: str = "donna.world.state_storage_unsupported"
+    code: str = "donna.workspaces.state_storage_unsupported"
     message: str = "World `{error.world_id}` does not support state storage"
     ways_to_fix: list[str] = [
         "Use the session world.",
     ]
-    world_id: WorldId
 
 
-class ArtifactError(WorldError):
+class ArtifactError(WorkspaceError):
     cell_kind: str = "artifact_error"
     artifact_id: ArtifactId
     world_id: WorldId
@@ -72,7 +90,7 @@ class ArtifactError(WorldError):
 
 
 class ArtifactNotFound(ArtifactError):
-    code: str = "donna.world.artifact_not_found"
+    code: str = "donna.workspaces.artifact_not_found"
     message: str = "Artifact `{error.artifact_id}` does not exist in world `{error.world_id}`"
     ways_to_fix: list[str] = [
         "Check the artifact id for typos.",
@@ -81,7 +99,7 @@ class ArtifactNotFound(ArtifactError):
 
 
 class ArtifactMultipleFiles(ArtifactError):
-    code: str = "donna.world.artifact_multiple_files"
+    code: str = "donna.workspaces.artifact_multiple_files"
     message: str = "Artifact `{error.artifact_id}` has multiple files in world `{error.world_id}`"
     ways_to_fix: list[str] = [
         "Keep a single source file per artifact in the world.",
@@ -89,7 +107,7 @@ class ArtifactMultipleFiles(ArtifactError):
 
 
 class UnsupportedArtifactSourceExtension(ArtifactError):
-    code: str = "donna.world.unsupported_artifact_source_extension"
+    code: str = "donna.workspaces.unsupported_artifact_source_extension"
     message: str = "Unsupported artifact source extension `{error.extension}` in world `{error.world_id}`"
     ways_to_fix: list[str] = [
         "Use a supported extension for the configured sources.",
@@ -97,7 +115,7 @@ class UnsupportedArtifactSourceExtension(ArtifactError):
     extension: str
 
 
-class MarkdownError(WorldError):
+class MarkdownError(WorkspaceError):
     cell_kind: str = "markdown_error"
     artifact_id: FullArtifactId | None = None
 
@@ -108,7 +126,7 @@ class MarkdownError(WorldError):
         return f"Error in markdown artifact '{self.artifact_id}'"
 
 
-class TemplateDirectiveError(WorldError):
+class TemplateDirectiveError(WorkspaceError):
     cell_kind: str = "template_directive_error"
     artifact_id: FullArtifactId | None = None
 
@@ -120,14 +138,14 @@ class TemplateDirectiveError(WorldError):
 
 
 class DirectivePathIncomplete(TemplateDirectiveError):
-    code: str = "donna.world.directive_path_incomplete"
+    code: str = "donna.workspaces.directive_path_incomplete"
     message: str = "Directive path must include module and directive parts, got `{error.path}`."
     ways_to_fix: list[str] = ["Use a directive path with both module and directive names."]
     path: str
 
 
 class DirectiveModuleNotImportable(TemplateDirectiveError):
-    code: str = "donna.world.directive_module_not_importable"
+    code: str = "donna.workspaces.directive_module_not_importable"
     message: str = "Directive module `{error.module_path}` is not importable."
     ways_to_fix: list[str] = [
         "Check the module path for typos.",
@@ -137,7 +155,7 @@ class DirectiveModuleNotImportable(TemplateDirectiveError):
 
 
 class DirectiveNotAvailable(TemplateDirectiveError):
-    code: str = "donna.world.directive_not_available"
+    code: str = "donna.workspaces.directive_not_available"
     message: str = "Directive `{error.module_path}.{error.directive_name}` is not available."
     ways_to_fix: list[str] = [
         "Check the directive name for typos.",
@@ -148,7 +166,7 @@ class DirectiveNotAvailable(TemplateDirectiveError):
 
 
 class DirectiveNotDirective(TemplateDirectiveError):
-    code: str = "donna.world.directive_not_directive"
+    code: str = "donna.workspaces.directive_not_directive"
     message: str = "`{error.module_path}.{error.directive_name}` is not a directive."
     ways_to_fix: list[str] = [
         "Check the directive path for typos.",
@@ -160,7 +178,7 @@ class DirectiveNotDirective(TemplateDirectiveError):
 
 
 class DirectiveUnexpectedError(TemplateDirectiveError):
-    code: str = "donna.world.directive_unexpected_error"
+    code: str = "donna.workspaces.directive_unexpected_error"
     message: str = "Unexpected error while applying directive `{error.directive_path}`: {error.details}"
     ways_to_fix: list[str] = [
         "Check the documentation for the directive to ensure correct usage.",
@@ -171,7 +189,7 @@ class DirectiveUnexpectedError(TemplateDirectiveError):
 
 
 class MarkdownUnsupportedCodeFormat(MarkdownError):
-    code: str = "donna.world.markdown_unsupported_code_format"
+    code: str = "donna.workspaces.markdown_unsupported_code_format"
     message: str = "Unsupported code block format `{error.format}`"
     ways_to_fix: list[str] = [
         "Use one of the supported formats: json, yaml, yml, toml.",
@@ -180,36 +198,28 @@ class MarkdownUnsupportedCodeFormat(MarkdownError):
 
 
 class MarkdownMultipleH1Sections(MarkdownError):
-    code: str = "donna.world.markdown_multiple_h1_sections"
+    code: str = "donna.workspaces.markdown_multiple_h1_sections"
     message: str = "Multiple H1 sections are not supported"
     ways_to_fix: list[str] = [
         "Keep a single H1 section in the artifact.",
     ]
 
 
-class MarkdownMultipleH1Titles(MarkdownError):
-    code: str = "donna.world.markdown_multiple_h1_titles"
-    message: str = "Multiple H1 titles are not supported"
-    ways_to_fix: list[str] = [
-        "Keep a single H1 title in the artifact.",
-    ]
-
-
-class MarkdownH2BeforeH1Title(MarkdownError):
-    code: str = "donna.world.markdown_h2_before_h1_title"
-    message: str = "H2 section found before H1 title"
+class MarkdownH1SectionMustBeFirst(MarkdownError):
+    code: str = "donna.workspaces.markdown_h1_section_must_be_first"
+    message: str = "H1 section must be the first section in the artifact"
     ways_to_fix: list[str] = [
-        "Ensure the first heading is an H1 title before any H2 sections.",
+        "Ensure the H1 section is the first section in the artifact.",
     ]
 
 
 class MarkdownArtifactWithoutSections(MarkdownError):
-    code: str = "donna.world.markdown_artifact_without_sections"
+    code: str = "donna.workspaces.markdown_artifact_without_sections"
     message: str = "Artifact MUST have at least one section"
 
 
 class PrimitiveDoesNotSupportMarkdown(MarkdownError):
-    code: str = "donna.world.primitive_does_not_support_markdown"
+    code: str = "donna.workspaces.primitive_does_not_support_markdown"
     message: str = "Primitive {error.primitive_id} cannot construct artifact section from the Markdown source"
     ways_to_fix: list[str] = [
         "Ensure the section kind points to a primitive that supports Markdown sections.",

donna/workspaces/initialization.py

@@ -0,0 +1,78 @@
+import pathlib
+import tomllib
+
+import tomli_w
+
+from donna.core import errors as core_errors
+from donna.core import utils
+from donna.core.result import Err, Ok, Result, unwrap_to_error
+from donna.domain.ids import WorldId
+from donna.workspaces import config
+from donna.workspaces import errors as world_errors
+
+
+@unwrap_to_error
+def initialize_runtime() -> Result[None, core_errors.ErrorsList]:
+    """Initialize the runtime environment for the application.
+
+    This function MUST be called before any other operations.
+    """
+    project_dir = utils.discover_project_dir(config.DONNA_DIR_NAME).unwrap()
+
+    config.project_dir.set(project_dir)
+
+    config_dir = project_dir / config.DONNA_DIR_NAME
+
+    config.config_dir.set(config_dir)
+
+    config_path = config_dir / config.DONNA_CONFIG_NAME
+
+    if not config_path.exists():
+        config.config.set(config.Config())
+        return Ok(None)
+
+    try:
+        data = tomllib.loads(config_path.read_text(encoding="utf-8"))
+    except tomllib.TOMLDecodeError as e:
+        return Err([world_errors.ConfigParseFailed(config_path=config_path, details=str(e))])
+
+    try:
+        loaded_config = config.Config.model_validate(data)
+    except Exception as e:
+        return Err([world_errors.ConfigValidationFailed(config_path=config_path, details=str(e))])
+
+    config.config.set(loaded_config)
+
+    return Ok(None)
+
+
+@unwrap_to_error
+def initialize_workspace(project_dir: pathlib.Path) -> Result[None, core_errors.ErrorsList]:
+    """Initialize the physical workspace for the project (`.donna` directory)."""
+    project_dir = project_dir.resolve()
+    workspace_dir = project_dir / config.DONNA_DIR_NAME
+
+    if workspace_dir.exists():
+        return Err([world_errors.WorkspaceAlreadyInitialized(project_dir=project_dir)])
+
+    config.project_dir.set(project_dir)
+    config.config_dir.set(workspace_dir)
+
+    workspace_dir.mkdir(parents=True, exist_ok=True)
+
+    default_config = config.Config()
+    config.config.set(default_config)
+
+    config_path = workspace_dir / config.DONNA_CONFIG_NAME
+    config_path.write_text(
+        tomli_w.dumps(default_config.model_dump(mode="json")),
+        encoding="utf-8",
+    )
+
+    project_world = default_config.get_world(WorldId(config.DONNA_WORLD_PROJECT_DIR_NAME)).unwrap()
+    project_world.initialize()
+
+    session_world = default_config.get_world(WorldId(config.DONNA_WORLD_SESSION_DIR_NAME)).unwrap()
+    session_world.initialize()
+
+    return Ok(None)

donna/{world → workspaces}/markdown.py

@@ -1,7 +1,6 @@
 import enum
 from typing import Any
 
-import pydantic
 from markdown_it import MarkdownIt
 from markdown_it.token import Token
 from markdown_it.tree import SyntaxTreeNode
@@ -11,7 +10,7 @@ from donna.core.entities import BaseEntity
 from donna.core.errors import ErrorsList
 from donna.core.result import Err, Ok, Result, unwrap_to_error
 from donna.domain.ids import FullArtifactId
-from donna.world import errors as world_errors
+from donna.workspaces import errors as world_errors
 
 
 class SectionLevel(str, enum.Enum):
@@ -54,8 +53,6 @@ class SectionSource(BaseEntity):
     original_tokens: list[Token]
     analysis_tokens: list[Token]
 
-    model_config = pydantic.ConfigDict(frozen=False)
-
     def _as_markdown(self, tokens: list[Token], with_title: bool) -> str:
         parts = []
 
@@ -110,15 +107,21 @@ def clear_heading(text: str) -> str:
 def _parse_h1(
     sections: list[SectionSource], node: SyntaxTreeNode, artifact_id: FullArtifactId | None
 ) -> Result[SyntaxTreeNode | None, ErrorsList]:
-    section = sections[-1]
-
-    if section.level != SectionLevel.h1:
+    if sections and any(section.level == SectionLevel.h1 for section in sections):
         return Err([world_errors.MarkdownMultipleH1Sections(artifact_id=artifact_id)])
 
-    if section.title is not None:
-        return Err([world_errors.MarkdownMultipleH1Titles(artifact_id=artifact_id)])
+    if sections:
+        return Err([world_errors.MarkdownH1SectionMustBeFirst(artifact_id=artifact_id)])
+
+    new_section = SectionSource(
+        level=SectionLevel.h1,
+        title=clear_heading(render_back(node.to_tokens()).strip()),
+        original_tokens=[],
+        analysis_tokens=[],
+        configs=[],
+    )
 
-    section.title = clear_heading(render_back(node.to_tokens()).strip())
+    sections.append(new_section)
 
     return Ok(node.next_sibling)
 
@@ -126,10 +129,9 @@ def _parse_h1(
 def _parse_h2(
     sections: list[SectionSource], node: SyntaxTreeNode, artifact_id: FullArtifactId | None
 ) -> Result[SyntaxTreeNode | None, ErrorsList]:
-    section = sections[-1]
 
-    if section.title is None:
-        return Err([world_errors.MarkdownH2BeforeH1Title(artifact_id=artifact_id)])
+    if not sections:
+        return Err([world_errors.MarkdownH1SectionMustBeFirst(artifact_id=artifact_id)])
 
     new_section = SectionSource(
         level=SectionLevel.h2,
@@ -147,7 +149,6 @@ def _parse_h2(
 def _parse_heading(
     sections: list[SectionSource], node: SyntaxTreeNode, artifact_id: FullArtifactId | None
 ) -> Result[SyntaxTreeNode | None, ErrorsList]:
-    section = sections[-1]
 
     if node.tag == "h1":
         return _parse_h1(sections, node, artifact_id)
@@ -155,7 +156,11 @@ def _parse_heading(
     if node.tag == "h2":
         return _parse_h2(sections, node, artifact_id)
 
-    section.original_tokens.extend(node.to_tokens())
+    if not sections:
+        return Err([world_errors.MarkdownH1SectionMustBeFirst(artifact_id=artifact_id)])
+
+    sections[-1].original_tokens.extend(node.to_tokens())
+
     return Ok(node.next_sibling)
 
 
@@ -231,15 +236,7 @@ def parse(  # noqa: CCR001, CFQ001
     # we do not need root node
     node: SyntaxTreeNode | None = SyntaxTreeNode(tokens).children[0]
 
-    sections: list[SectionSource] = [
-        SectionSource(
-            level=SectionLevel.h1,
-            title=None,
-            original_tokens=[],
-            analysis_tokens=[],
-            configs=[],
-        )
-    ]
+    sections: list[SectionSource] = []
 
     while node is not None:
 
@@ -263,5 +260,3 @@ def parse(  # noqa: CCR001, CFQ001
         node = node.next_sibling
 
     return Ok(sections)
-
-    return sections

donna/{world → workspaces}/sources/base.py

@@ -13,8 +13,8 @@ from donna.machine.primitives import Primitive
 if TYPE_CHECKING:
     from donna.domain.ids import FullArtifactId
     from donna.machine.artifacts import Artifact
-    from donna.world.artifacts import ArtifactRenderContext
-    from donna.world.config import SourceConfig as SourceConfigModel
+    from donna.workspaces.artifacts import ArtifactRenderContext
+    from donna.workspaces.config import SourceConfig as SourceConfigModel
 
 
 class SourceConfig(BaseEntity, ABC):

donna/{world → workspaces}/sources/markdown.py

@@ -6,11 +6,11 @@ from donna.core.result import Err, Ok, Result, unwrap_to_error
 from donna.domain.ids import ArtifactSectionId, FullArtifactId, PythonImportPath
 from donna.machine.artifacts import Artifact, ArtifactSection, ArtifactSectionConfig, ArtifactSectionMeta
 from donna.machine.primitives import Primitive, resolve_primitive
-from donna.world import errors as world_errors
-from donna.world import markdown
-from donna.world.artifacts import ArtifactRenderContext
-from donna.world.sources.base import SourceConfig, SourceConstructor
-from donna.world.templates import RenderMode, render
+from donna.workspaces import errors as world_errors
+from donna.workspaces import markdown
+from donna.workspaces.artifacts import ArtifactRenderContext
+from donna.workspaces.sources.base import SourceConfig, SourceConstructor
+from donna.workspaces.templates import RenderMode, render
 
 
 class MarkdownSectionConstructor(Protocol):
@@ -111,6 +111,7 @@ class MarkdownSectionMixin:
                 kind=section_config.kind,
                 title=title,
                 description=description,
+                tags=section_config.tags,
                 primary=primary,
                 meta=meta,
             )
@@ -257,4 +258,4 @@ def _ensure_markdown_constructible(
 
 
 if TYPE_CHECKING:
-    from donna.world.config import SourceConfig as SourceConfigModel
+    from donna.workspaces.config import SourceConfig as SourceConfigModel

donna/{world → workspaces}/templates.py

@@ -12,10 +12,10 @@ from donna.core.errors import EnvironmentErrorsProxy, ErrorsList
 from donna.core.result import Err, Ok, Result
 from donna.domain.ids import FullArtifactId
 from donna.machine.templates import Directive
-from donna.world import errors as world_errors
+from donna.workspaces import errors as world_errors
 
 if TYPE_CHECKING:
-    from donna.world.artifacts import ArtifactRenderContext
+    from donna.workspaces.artifacts import ArtifactRenderContext
 
 
 class RenderMode(enum.Enum):
@@ -57,7 +57,7 @@ class DirectivePathBuilder:
         return DirectivePathBuilder(self._parts + (name,))
 
     @jinja2.pass_context
-    def __call__(self, context: jinja2.runtime.Context, *argv: object) -> object:  # noqa: CCR001
+    def __call__(self, context: jinja2.runtime.Context, *argv: object, **kwargs: object) -> object:  # noqa: CCR001
         artifact_id = context.get("artifact_id")
         directive_path = ".".join(self._parts)
         if len(self._parts) < 2:
@@ -112,7 +112,7 @@ class DirectivePathBuilder:
             )
 
         try:
-            result = directive.apply_directive(context, *argv)
+            result = directive.apply_directive(context, *argv, **kwargs)
         except EnvironmentErrorsProxy:
             raise
         except core_errors.InternalError:

donna/{world → workspaces}/tmp.py

@@ -3,7 +3,7 @@ import shutil
 import time
 
 from donna.cli.types import FullArtifactIdArgument
-from donna.world.config import config, config_dir
+from donna.workspaces.config import config, config_dir
 
 
 def dir() -> pathlib.Path:
@@ -29,5 +29,23 @@ def file_for_artifact(artifact_id: FullArtifactIdArgument, extention: str) -> pa
     return directory / artifact_file_name
 
 
+def file_for_slug(slug: str, extension: str) -> pathlib.Path:
+    directory = dir()
+
+    directory.mkdir(parents=True, exist_ok=True)
+
+    normalized_slug = slug.replace("/", ".").replace("\\", ".")
+    normalized_extension = extension.lstrip(".")
+    artifact_file_name = f"{normalized_slug}.{int(time.time() * 1000)}.{normalized_extension}"
+
+    return directory / artifact_file_name
+
+
+def create_file_for_slug(slug: str, extension: str) -> pathlib.Path:
+    path = file_for_slug(slug, extension)
+    path.touch()
+    return path
+
+
 def clear() -> None:
     shutil.rmtree(dir())

donna/{world → workspaces}/worlds/base.py

@@ -11,8 +11,8 @@ from donna.machine.artifacts import Artifact
 from donna.machine.primitives import Primitive
 
 if TYPE_CHECKING:
-    from donna.world.artifacts import ArtifactRenderContext
-    from donna.world.config import WorldConfig
+    from donna.workspaces.artifacts import ArtifactRenderContext
+    from donna.workspaces.config import WorldConfig
 
 
 class World(BaseEntity, ABC):
@@ -36,6 +36,9 @@ class World(BaseEntity, ABC):
         self, artifact_id: ArtifactId, content: bytes, extension: str
     ) -> Result[None, ErrorsList]: ...  # noqa: E704
 
+    @abstractmethod
+    def remove(self, artifact_id: ArtifactId) -> Result[None, ErrorsList]: ...  # noqa: E704
+
     @abstractmethod
     def file_extension_for(self, artifact_id: ArtifactId) -> Result[str, ErrorsList]: ...  # noqa: E704
 

donna/{world → workspaces}/worlds/filesystem.py

@@ -6,14 +6,14 @@ from donna.core.errors import ErrorsList
 from donna.core.result import Err, Ok, Result, unwrap_to_error
 from donna.domain.ids import ArtifactId, FullArtifactId, FullArtifactIdPattern
 from donna.machine.artifacts import Artifact
-from donna.world import errors as world_errors
-from donna.world.artifacts import ArtifactRenderContext
-from donna.world.artifacts_discovery import ArtifactListingNode, list_artifacts_by_pattern
-from donna.world.worlds.base import World as BaseWorld
-from donna.world.worlds.base import WorldConstructor
+from donna.workspaces import errors as world_errors
+from donna.workspaces.artifacts import ArtifactRenderContext
+from donna.workspaces.artifacts_discovery import ArtifactListingNode, list_artifacts_by_pattern
+from donna.workspaces.worlds.base import World as BaseWorld
+from donna.workspaces.worlds.base import WorldConstructor
 
 if TYPE_CHECKING:
-    from donna.world.config import SourceConfigValue, WorldConfig
+    from donna.workspaces.config import SourceConfigValue, WorldConfig
 
 
 class World(BaseWorld):
@@ -35,7 +35,7 @@ class World(BaseWorld):
         if not parent.exists():
             return Ok(None)
 
-        from donna.world.config import config
+        from donna.workspaces.config import config
 
         supported_extensions = config().supported_extensions()
         matches = [
@@ -55,7 +55,7 @@ class World(BaseWorld):
     def _get_source_by_filename(
         self, artifact_id: ArtifactId, filename: str
     ) -> Result["SourceConfigValue", ErrorsList]:
-        from donna.world.config import config
+        from donna.workspaces.config import config
 
         extension = pathlib.Path(filename).suffix
         source_config = config().find_source_for_extension(extension)
@@ -89,7 +89,7 @@ class World(BaseWorld):
         full_id = FullArtifactId((self.id, artifact_id))
 
         extension = pathlib.Path(path.name).suffix
-        from donna.world.config import config
+        from donna.workspaces.config import config
 
         source_config = config().find_source_for_extension(extension)
         if source_config is None:
@@ -123,6 +123,20 @@ class World(BaseWorld):
         path.write_bytes(content)
         return Ok(None)
 
+    @unwrap_to_error
+    def remove(self, artifact_id: ArtifactId) -> Result[None, ErrorsList]:
+        if self.readonly:
+            return Err([world_errors.WorldReadonly(world_id=self.id)])
+
+        path = self._resolve_artifact_file(artifact_id).unwrap()
+
+        if path is None:
+            return Ok(None)
+
+        path.unlink()
+
+        return Ok(None)
+
     @unwrap_to_error
     def file_extension_for(self, artifact_id: ArtifactId) -> Result[str, ErrorsList]:
         path = self._resolve_artifact_file(artifact_id).unwrap()