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

donna/workspaces/artifacts.py

@@ -0,0 +1,238 @@
+import pathlib
+
+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, FullArtifactIdPattern, WorldId
+from donna.machine.artifacts import Artifact
+from donna.machine.tasks import Task, WorkUnit
+from donna.workspaces import errors
+from donna.workspaces.config import config
+from donna.workspaces.templates import RenderMode
+
+
+class ArtifactRenderContext(BaseEntity):
+    primary_mode: RenderMode
+    current_task: Task | None = None
+    current_work_unit: WorkUnit | None = None
+
+
+class ArtifactUpdateError(errors.WorkspaceError):
+    cell_kind: str = "artifact_update_error"
+    artifact_id: FullArtifactId
+    path: pathlib.Path
+
+    def content_intro(self) -> str:
+        return f"Error updating artifact '{self.artifact_id}' from the path '{self.path}'"
+
+
+class CanNotUpdateReadonlyWorld(ArtifactUpdateError):
+    code: str = "donna.workspaces.cannot_update_readonly_world"
+    message: str = "Cannot upload artifact to the read-only world `{error.world_id}`"
+    world_id: WorldId
+
+
+class ArtifactRemoveError(errors.WorkspaceError):
+    cell_kind: str = "artifact_remove_error"
+    artifact_id: FullArtifactId
+
+    def content_intro(self) -> str:
+        return f"Error removing artifact '{self.artifact_id}'"
+
+
+class CanNotRemoveReadonlyWorld(ArtifactRemoveError):
+    code: str = "donna.workspaces.cannot_remove_readonly_world"
+    message: str = "Cannot remove artifact from the read-only world `{error.world_id}`"
+    world_id: WorldId
+
+
+class InputPathHasNoExtension(ArtifactUpdateError):
+    code: str = "donna.workspaces.input_path_has_no_extension"
+    message: str = "Input path has no extension to determine artifact source type"
+
+
+class NoSourceForArtifactExtension(ArtifactUpdateError):
+    code: str = "donna.workspaces.no_source_for_artifact_extension"
+    message: str = "No source found for artifact extension of input path"
+    extension: str
+
+
+class ArtifactCopyError(errors.WorkspaceError):
+    cell_kind: str = "artifact_copy_error"
+    source_id: FullArtifactId
+    target_id: FullArtifactId
+
+    def content_intro(self) -> str:
+        return f"Error copying artifact '{self.source_id}' to '{self.target_id}'"
+
+
+class CanNotCopyToReadonlyWorld(ArtifactCopyError):
+    code: str = "donna.workspaces.cannot_copy_to_readonly_world"
+    message: str = "Cannot copy artifact to the read-only world `{error.world_id}`"
+    world_id: WorldId
+
+
+class SourceArtifactHasNoExtension(ArtifactCopyError):
+    code: str = "donna.workspaces.source_artifact_has_no_extension"
+    message: str = "Source artifact has no extension to determine source type"
+
+
+@unwrap_to_error
+def artifact_file_extension(full_id: FullArtifactId) -> Result[str, ErrorsList]:
+    world = config().get_world(full_id.world_id).unwrap()
+    return Ok(world.file_extension_for(full_id.artifact_id).unwrap().lstrip("."))
+
+
+@unwrap_to_error
+def fetch_artifact(full_id: FullArtifactId, output: pathlib.Path) -> Result[None, ErrorsList]:
+    world = config().get_world(full_id.world_id).unwrap()
+    content = world.fetch_source(full_id.artifact_id).unwrap()
+
+    with output.open("wb") as f:
+        f.write(content)
+
+    return Ok(None)
+
+
+@unwrap_to_error
+def update_artifact(full_id: FullArtifactId, input: pathlib.Path) -> Result[None, ErrorsList]:
+    world = config().get_world(full_id.world_id).unwrap()
+
+    if world.readonly:
+        return Err([CanNotUpdateReadonlyWorld(artifact_id=full_id, path=input, world_id=world.id)])
+
+    source_suffix = input.suffix.lower()
+    content_bytes = input.read_bytes()
+
+    if not source_suffix:
+        return Err([InputPathHasNoExtension(artifact_id=full_id, path=input)])
+
+    source_config = config().find_source_for_extension(source_suffix)
+    if source_config is None:
+        return Err([NoSourceForArtifactExtension(artifact_id=full_id, path=input, extension=source_suffix)])
+
+    render_context = ArtifactRenderContext(primary_mode=RenderMode.view)
+    test_artifact = source_config.construct_artifact_from_bytes(full_id, content_bytes, render_context).unwrap()
+    validation_result = test_artifact.validate_artifact()
+
+    validation_result.unwrap()
+    world.update(full_id.artifact_id, content_bytes, source_suffix).unwrap()
+
+    return Ok(None)
+
+
+@unwrap_to_error
+def copy_artifact(source_id: FullArtifactId, target_id: FullArtifactId) -> Result[None, ErrorsList]:
+    source_world = config().get_world(source_id.world_id).unwrap()
+    target_world = config().get_world(target_id.world_id).unwrap()
+
+    if target_world.readonly:
+        return Err(
+            [
+                CanNotCopyToReadonlyWorld(
+                    source_id=source_id,
+                    target_id=target_id,
+                    world_id=target_world.id,
+                )
+            ]
+        )
+
+    content_bytes = source_world.fetch_source(source_id.artifact_id).unwrap()
+    source_extension = source_world.file_extension_for(source_id.artifact_id).unwrap()
+
+    if not source_extension:
+        return Err([SourceArtifactHasNoExtension(source_id=source_id, target_id=target_id)])
+
+    source_extension = source_extension.lower()
+    source_config = config().find_source_for_extension(source_extension)
+    if source_config is None:
+        return Err(
+            [
+                NoSourceForArtifactExtension(
+                    artifact_id=source_id,
+                    path=pathlib.Path(str(source_id)),
+                    extension=source_extension,
+                )
+            ]
+        )
+
+    render_context = ArtifactRenderContext(primary_mode=RenderMode.view)
+    test_artifact = source_config.construct_artifact_from_bytes(target_id, content_bytes, render_context).unwrap()
+    test_artifact.validate_artifact().unwrap()
+
+    target_world.update(target_id.artifact_id, content_bytes, source_extension).unwrap()
+    return Ok(None)
+
+
+@unwrap_to_error
+def move_artifact(source_id: FullArtifactId, target_id: FullArtifactId) -> Result[None, ErrorsList]:
+    copy_result = copy_artifact(source_id, target_id)
+    if copy_result.is_err():
+        return copy_result
+
+    return remove_artifact(source_id)
+
+
+@unwrap_to_error
+def remove_artifact(full_id: FullArtifactId) -> Result[None, ErrorsList]:
+    world = config().get_world(full_id.world_id).unwrap()
+
+    if world.readonly:
+        return Err([CanNotRemoveReadonlyWorld(artifact_id=full_id, world_id=world.id)])
+
+    world.remove(full_id.artifact_id).unwrap()
+    return Ok(None)
+
+
+@unwrap_to_error
+def load_artifact(
+    full_id: FullArtifactId, render_context: ArtifactRenderContext | None = None
+) -> Result[Artifact, ErrorsList]:
+    if render_context is None:
+        render_context = ArtifactRenderContext(primary_mode=RenderMode.view)
+
+    world = config().get_world(full_id.world_id).unwrap()
+    return Ok(world.fetch(full_id.artifact_id, render_context).unwrap())
+
+
+def list_artifacts(  # noqa: CCR001
+    pattern: FullArtifactIdPattern,
+    render_context: ArtifactRenderContext | None = None,
+    tags: list[str] | None = None,
+) -> Result[list[Artifact], ErrorsList]:
+    if render_context is None:
+        render_context = ArtifactRenderContext(primary_mode=RenderMode.view)
+
+    tag_filters = tags or []
+
+    artifacts: list[Artifact] = []
+    errors: ErrorsList = []
+
+    for world in reversed(config().worlds_instances):
+        for artifact_id in world.list_artifacts(pattern):
+            full_id = FullArtifactId((world.id, artifact_id))
+            artifact_result = load_artifact(full_id, render_context)
+            if artifact_result.is_err():
+                errors.extend(artifact_result.unwrap_err())
+                continue
+            artifact = artifact_result.unwrap()
+            if tag_filters and not _artifact_matches_tags(artifact, tag_filters):
+                continue
+            artifacts.append(artifact)
+
+    if errors:
+        return Err(errors)
+
+    return Ok(artifacts)
+
+
+def _artifact_matches_tags(artifact: Artifact, tags: list[str]) -> bool:
+    if not tags:
+        return True
+
+    primary_result = artifact.primary_section()
+    if primary_result.is_err():
+        return False
+
+    primary = primary_result.unwrap()
+    return all(tag in primary.tags for tag in tags)

donna/{world → workspaces}/artifacts_discovery.py

@@ -3,7 +3,7 @@ from functools import lru_cache
 from typing import Iterable, Protocol
 
 from donna.domain.ids import ArtifactId, FullArtifactId, FullArtifactIdPattern, WorldId
-from donna.world.config import config
+from donna.workspaces.config import config
 
 
 class ArtifactListingNode(Protocol):

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"
@@ -46,7 +46,7 @@ def _default_sources() -> list[SourceConfig]:
     ]
 
 
-def _create_default_worlds(project_dir: pathlib.Path) -> list[WorldConfig]:
+def _create_default_worlds() -> list[WorldConfig]:
     return [
         WorldConfig.model_validate(
             {
@@ -63,7 +63,7 @@ def _create_default_worlds(project_dir: pathlib.Path) -> list[WorldConfig]:
                 "kind": "donna.lib.worlds.filesystem",
                 "readonly": True,
                 "session": False,
-                "path": pathlib.Path.home() / DONNA_DIR_NAME / DONNA_WORLD_HOME_DIR_NAME,
+                "path": f"~/{DONNA_DIR_NAME}/{DONNA_WORLD_HOME_DIR_NAME}",
             }
         ),
         WorldConfig.model_validate(
@@ -72,7 +72,7 @@ def _create_default_worlds(project_dir: pathlib.Path) -> list[WorldConfig]:
                 "kind": "donna.lib.worlds.filesystem",
                 "readonly": False,
                 "session": False,
-                "path": project_dir / DONNA_DIR_NAME / DONNA_WORLD_PROJECT_DIR_NAME,
+                "path": pathlib.Path(DONNA_DIR_NAME) / DONNA_WORLD_PROJECT_DIR_NAME,
             }
         ),
         WorldConfig.model_validate(
@@ -81,14 +81,14 @@ def _create_default_worlds(project_dir: pathlib.Path) -> list[WorldConfig]:
                 "kind": "donna.lib.worlds.filesystem",
                 "readonly": False,
                 "session": True,
-                "path": project_dir / DONNA_DIR_NAME / DONNA_WORLD_SESSION_DIR_NAME,
+                "path": pathlib.Path(DONNA_DIR_NAME) / DONNA_WORLD_SESSION_DIR_NAME,
             }
         ),
     ]
 
 
 def _default_worlds() -> list[WorldConfig]:
-    return _create_default_worlds(project_dir())
+    return _create_default_worlds()
 
 
 class Config(BaseEntity):
@@ -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)