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

donna/cli/commands/artifacts.py

@@ -1,18 +1,42 @@
+import builtins
 from collections.abc import Iterable
 
 import typer
 
+from donna.cli import errors as cli_errors
 from donna.cli.application import app
-from donna.cli.types import FullArtifactIdArgument, FullArtifactIdPatternOption, InputPathArgument, OutputPathOption
+from donna.cli.types import (
+    FullArtifactIdArgument,
+    FullArtifactIdPatternArgument,
+    InputPathArgument,
+    OutputPathOption,
+    TagOption,
+)
 from donna.cli.utils import cells_cli, try_initialize_donna
+from donna.core.errors import ErrorsList
+from donna.core.result import Err, Ok, Result
 from donna.domain.ids import FullArtifactIdPattern
 from donna.protocol.cell_shortcuts import operation_succeeded
 from donna.protocol.cells import Cell
-from donna.world import artifacts as world_artifacts
-from donna.world import tmp as world_tmp
+from donna.workspaces import artifacts as world_artifacts
+from donna.workspaces import tmp as world_tmp
 
 artifacts_cli = typer.Typer()
 
+DEFAULT_ARTIFACT_PATTERN = FullArtifactIdPattern.parse("**").unwrap()
+
+
+def _parse_slug_with_extension(value: str) -> Result[tuple[str, str], ErrorsList]:
+    normalized = value.strip()
+    if "." not in normalized:
+        return Err([cli_errors.InvalidSlugWithExtension(value=normalized)])
+
+    slug, extension = normalized.rsplit(".", 1)
+    if not slug or not extension:
+        return Err([cli_errors.InvalidSlugWithExtension(value=normalized)])
+
+    return Ok((slug, extension))
+
 
 @artifacts_cli.callback(invoke_without_command=True)
 def initialize(ctx: typer.Context) -> None:
@@ -28,20 +52,23 @@ def initialize(ctx: typer.Context) -> None:
     help="List artifacts matching a pattern and show their status summaries. Lists all all artifacts by default."
 )
 @cells_cli
-def list(pattern: FullArtifactIdPatternOption = None) -> Iterable[Cell]:
-    if pattern is None:
-        pattern = FullArtifactIdPattern.parse("**").unwrap()
-
-    artifacts = world_artifacts.list_artifacts(pattern).unwrap()
+def list(
+    pattern: FullArtifactIdPatternArgument = DEFAULT_ARTIFACT_PATTERN,
+    tags: TagOption = None,
+) -> Iterable[Cell]:
+    artifacts = world_artifacts.list_artifacts(pattern, tags=tags).unwrap()
 
     return [artifact.node().status() for artifact in artifacts]
 
 
-@artifacts_cli.command(help="Displays a single artifact.")
+@artifacts_cli.command(help="Displays artifacts matching a pattern or a specific id")
 @cells_cli
-def view(id: FullArtifactIdArgument) -> Iterable[Cell]:
-    artifact = world_artifacts.load_artifact(id).unwrap()
-    return [artifact.node().info()]
+def view(
+    pattern: FullArtifactIdPatternArgument,
+    tags: TagOption = None,
+) -> Iterable[Cell]:
+    artifacts = world_artifacts.list_artifacts(pattern, tags=tags).unwrap()
+    return [artifact.node().info() for artifact in artifacts]
 
 
 @artifacts_cli.command(
@@ -63,6 +90,24 @@ def fetch(id: FullArtifactIdArgument, output: OutputPathOption = None) -> Iterab
     ]
 
 
+@artifacts_cli.command(
+    help="Create a temporary file for artifact-related work and print its path. Use it to create new artifacts"
+)
+@cells_cli
+def tmp(
+    slug_with_extension: str = typer.Argument(..., help="Temporary file slug with extension (example: 'draft.md').")
+) -> Iterable[Cell]:
+    slug, extension = _parse_slug_with_extension(slug_with_extension).unwrap()
+    output = world_tmp.create_file_for_slug(slug, extension)
+
+    return [
+        operation_succeeded(
+            f"Temporary file created at '{output}'",
+            output_path=str(output),
+        )
+    ]
+
+
 @artifacts_cli.command(help="Create or replace the artifact with the contents of a file.")
 @cells_cli
 def update(id: FullArtifactIdArgument, input: InputPathArgument) -> Iterable[Cell]:
@@ -70,6 +115,48 @@ def update(id: FullArtifactIdArgument, input: InputPathArgument) -> Iterable[Cel
     return [operation_succeeded(f"Artifact `{id}` updated from '{input}'", artifact_id=str(id), input_path=str(input))]
 
 
+@artifacts_cli.command(help="Copy an artifact to another artifact ID (possibly across worlds).")
+@cells_cli
+def copy(source_id: FullArtifactIdArgument, target_id: FullArtifactIdArgument) -> Iterable[Cell]:
+    world_artifacts.copy_artifact(source_id, target_id).unwrap()
+    return [
+        operation_succeeded(
+            f"Artifact `{source_id}` copied to `{target_id}`",
+            source_id=str(source_id),
+            target_id=str(target_id),
+        )
+    ]
+
+
+@artifacts_cli.command(help="Move an artifact to another artifact ID (possibly across worlds).")
+@cells_cli
+def move(source_id: FullArtifactIdArgument, target_id: FullArtifactIdArgument) -> Iterable[Cell]:
+    world_artifacts.move_artifact(source_id, target_id).unwrap()
+    return [
+        operation_succeeded(
+            f"Artifact `{source_id}` moved to `{target_id}`",
+            source_id=str(source_id),
+            target_id=str(target_id),
+        )
+    ]
+
+
+@artifacts_cli.command(help="Remove artifacts matching a pattern.")
+@cells_cli
+def remove(
+    pattern: FullArtifactIdPatternArgument,
+    tags: TagOption = None,
+) -> Iterable[Cell]:
+    artifacts = world_artifacts.list_artifacts(pattern, tags=tags).unwrap()
+
+    cells: builtins.list[Cell] = []
+    for artifact in artifacts:
+        world_artifacts.remove_artifact(artifact.id).unwrap()
+        cells.append(operation_succeeded(f"Artifact `{artifact.id}` removed", artifact_id=str(artifact.id)))
+
+    return cells
+
+
 @artifacts_cli.command(help="Validate an artifact and return any validation errors.")
 @cells_cli
 def validate(id: FullArtifactIdArgument) -> Iterable[Cell]:
@@ -84,11 +171,11 @@ def validate(id: FullArtifactIdArgument) -> Iterable[Cell]:
     help="Validate all artifacts matching a pattern (defaults to all artifacts) and return any errors."
 )
 @cells_cli
-def validate_all(pattern: FullArtifactIdPatternOption = None) -> Iterable[Cell]:  # noqa: CCR001
-    if pattern is None:
-        pattern = FullArtifactIdPattern.parse("**").unwrap()
-
-    artifacts = world_artifacts.list_artifacts(pattern).unwrap()
+def validate_all(
+    pattern: FullArtifactIdPatternArgument = DEFAULT_ARTIFACT_PATTERN,
+    tags: TagOption = None,
+) -> Iterable[Cell]:  # noqa: CCR001
+    artifacts = world_artifacts.list_artifacts(pattern, tags=tags).unwrap()
 
     errors = []
 

donna/cli/commands/sessions.py

@@ -21,12 +21,18 @@ def initialize(ctx: typer.Context) -> None:
     try_initialize_donna()
 
 
-@sessions_cli.command(help="Start a new session and emit the initial session status and action requests.")
+@sessions_cli.command(help="Start a new session, reset session state, remove all session artifacts.")
 @cells_cli
 def start() -> Iterable[Cell]:
     return sessions.start()
 
 
+@sessions_cli.command(help="Reset the current session state, keeps session artifacts.")
+@cells_cli
+def reset() -> Iterable[Cell]:
+    return sessions.reset()
+
+
 @sessions_cli.command(
     name="continue",
     help="Continue the current session and emit the next queued action request(s).",
@@ -64,12 +70,6 @@ def action_request_completed(
     return sessions.complete_action_request(request_id, next_operation_id)
 
 
-@sessions_cli.command(help="Clear the current session state.")
-@cells_cli
-def clear() -> Iterable[Cell]:
-    return sessions.clear()
-
-
 app.add_typer(
     sessions_cli,
     name="sessions",

donna/cli/commands/workspaces.py

@@ -0,0 +1,42 @@
+import pathlib
+from collections.abc import Iterable
+
+import typer
+
+from donna.cli.application import app
+from donna.cli.types import ProjectDirArgument
+from donna.cli.utils import cells_cli, try_initialize_donna
+from donna.protocol.cell_shortcuts import operation_succeeded
+from donna.protocol.cells import Cell
+from donna.workspaces.initialization import initialize_workspace
+
+workspaces_cli = typer.Typer()
+
+
+@workspaces_cli.callback(invoke_without_command=True)
+def initialize_callback(ctx: typer.Context) -> None:
+    cmd = ctx.invoked_subcommand
+
+    if cmd is None:
+        return
+
+    if cmd in {"init"}:
+        return
+
+    try_initialize_donna()
+
+
+@workspaces_cli.command(help="Initialize Donna workspace.")
+@cells_cli
+def init(project_dir: ProjectDirArgument = None) -> Iterable[Cell]:
+    target_dir = project_dir or pathlib.Path.cwd()
+    initialize_workspace(target_dir).unwrap()
+
+    return [operation_succeeded("Workspace initialized successfully")]
+
+
+app.add_typer(
+    workspaces_cli,
+    name="workspaces",
+    help="Initialize and manage Donna workspace.",
+)

donna/cli/errors.py

@@ -0,0 +1,18 @@
+from donna.core import errors as core_errors
+
+
+class InternalError(core_errors.InternalError):
+    """Base class for internal errors in donna.cli."""
+
+
+class CliError(core_errors.EnvironmentError):
+    cell_kind: str = "cli_error"
+
+
+class InvalidSlugWithExtension(CliError):
+    code: str = "donna.cli.invalid_slug_with_extension"
+    message: str = "Invalid slug with extension: '{error.value}'."
+    ways_to_fix: list[str] = [
+        "Use the format '<slug>.<extension>' (for example: 'draft.md').",
+    ]
+    value: str

donna/cli/types.py

@@ -73,14 +73,22 @@ FullArtifactIdArgument = Annotated[
 ]
 
 
-FullArtifactIdPatternOption = Annotated[
-    FullArtifactIdPattern | None,
-    typer.Option(
+FullArtifactIdPatternArgument = Annotated[
+    FullArtifactIdPattern,
+    typer.Argument(
         parser=_parse_full_artifact_id_pattern,
         help="Artifact pattern (supports '*' and '**', e.g. 'project:*' or '**:intro').",
     ),
 ]
 
+TagOption = Annotated[
+    list[str] | None,
+    typer.Option(
+        "--tag",
+        help="Filter artifacts by tag. Repeatable.",
+    ),
+]
+
 
 FullArtifactSectionIdArgument = Annotated[
     FullArtifactSectionId,
@@ -125,14 +133,13 @@ OutputPathOption = Annotated[
     ),
 ]
 
-
-WorkdirOption = Annotated[
-    pathlib.Path,
-    typer.Option(
-        resolve_path=True,
+ProjectDirArgument = Annotated[
+    pathlib.Path | None,
+    typer.Argument(
         exists=True,
         file_okay=False,
         dir_okay=True,
-        help="Project root directory to initialize (defaults to current working directory).",
+        resolve_path=True,
+        help="Optional project directory. Defaults to the current working directory.",
     ),
 ]

donna/cli/utils.py

@@ -9,7 +9,7 @@ from donna.core.errors import EnvironmentError
 from donna.core.result import UnwrapError
 from donna.protocol.cells import Cell
 from donna.protocol.modes import get_cell_formatter
-from donna.world.initialization import initialize_environment
+from donna.workspaces.initialization import initialize_runtime
 
 
 def output_cells(cells: Iterable[Cell]) -> None:
@@ -43,7 +43,7 @@ def cells_cli(func: Callable[P, Iterable[Cell]]) -> Callable[P, None]:
 
 
 def try_initialize_donna() -> None:
-    result = initialize_environment()
+    result = initialize_runtime()
 
     if result.is_ok():
         return

donna/core/errors.py

@@ -53,17 +53,7 @@ class ProjectDirNotFound(CoreEnvironmentError):
     message: str = "Could not find a project directory containing `{error.donna_dir_name}`."
     ways_to_fix: list[str] = [
         "Run Donna from within a project directory that contains the donna directory.",
-        "Create the donna directory in the project root if it is missing.",
-    ]
-    donna_dir_name: str
-
-
-class ProjectDirIsHome(CoreEnvironmentError):
-    code: str = "donna.core.project_dir_is_home"
-    message: str = "The discovered `{error.donna_dir_name}` directory is the home directory, not a project directory."
-    ways_to_fix: list[str] = [
-        "Run Donna from within a project directory that contains the donna directory.",
-        "Move the donna directory out of the home folder into the project root if appropriate.",
+        "Create the donna workspace via CLI command if it does not exist yet.",
     ]
     donna_dir_name: str
 

donna/core/result.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import functools
-from dataclasses import dataclass
 from typing import Callable, Generic, ParamSpec, TypeVar, cast
 
 from donna.core.errors import InternalError
@@ -25,10 +24,12 @@ class UnwrapErrError(ResultError):
     message: str = "Called unwrap_err on an Ok value."
 
 
-@dataclass(frozen=True, slots=True)
 class Result(Generic[T, E]):
-    _is_ok: bool
-    _value: T | E
+    __slots__ = ("_is_ok", "_value")
+
+    def __init__(self, is_ok: bool, value: T | E) -> None:
+        self._is_ok = is_ok
+        self._value = value
 
     def is_ok(self) -> bool:
         return self._is_ok
@@ -82,10 +83,6 @@ def Err(error: E) -> Result[T, E]:
     return Result(False, error)
 
 
-def ok(result: Result[T, E]) -> bool:
-    return result.is_ok()
-
-
 def unwrap_to_error(func: Callable[P, Result[T, E]]) -> Callable[P, Result[T, E]]:
 
     @functools.wraps(func)

donna/core/utils.py

@@ -31,7 +31,4 @@ def discover_project_dir(donna_dir_name: str) -> Result[pathlib.Path, core_error
     if donna_dir is None:
         return Err([core_errors.ProjectDirNotFound(donna_dir_name=donna_dir_name)])
 
-    if donna_dir == donna_home_dir(donna_dir_name):
-        return Err([core_errors.ProjectDirIsHome(donna_dir_name=donna_dir_name)])
-
     return Ok(donna_dir)

donna/lib/__init__.py

@@ -3,9 +3,11 @@
 from donna.primitives.artifacts.specification import Specification, Text
 from donna.primitives.artifacts.workflow import Workflow
 from donna.primitives.directives.goto import GoTo
+from donna.primitives.directives.list import List
 from donna.primitives.directives.task_variable import TaskVariable
 from donna.primitives.directives.view import View
 from donna.primitives.operations.finish_workflow import FinishWorkflow
+from donna.primitives.operations.output import Output
 from donna.primitives.operations.request_action import RequestAction
 from donna.primitives.operations.run_script import RunScript
 
@@ -14,8 +16,10 @@ workflow = Workflow()
 text = Text()
 request_action = RequestAction()
 finish = FinishWorkflow()
+output = Output()
 run_script = RunScript()
 
 view = View(analyze_id="view")
+list = List(analyze_id="list")
 goto = GoTo(analyze_id="goto")
 task_variable = TaskVariable(analyze_id="task_variable")

donna/lib/sources.py

@@ -1,5 +1,5 @@
 """Shared source constructor instances for default configuration."""
 
-from donna.world.sources.markdown import MarkdownSourceConstructor
+from donna.workspaces.sources.markdown import MarkdownSourceConstructor
 
 markdown = MarkdownSourceConstructor()

donna/lib/worlds.py

@@ -1,7 +1,7 @@
 """Shared world constructor instances for default configuration."""
 
-from donna.world.worlds.filesystem import FilesystemWorldConstructor
-from donna.world.worlds.python import PythonWorldConstructor
+from donna.workspaces.worlds.filesystem import FilesystemWorldConstructor
+from donna.workspaces.worlds.python import PythonWorldConstructor
 
 filesystem = FilesystemWorldConstructor()
 python = PythonWorldConstructor()

donna/machine/action_requests.py

@@ -1,7 +1,5 @@
 import textwrap
 
-import pydantic
-
 from donna.core.entities import BaseEntity
 from donna.domain.ids import ActionRequestId, FullArtifactSectionId
 from donna.protocol.cells import Cell
@@ -13,9 +11,6 @@ class ActionRequest(BaseEntity):
     request: str
     operation_id: FullArtifactSectionId
 
-    # TODO: we may want to make queue items frozen later
-    model_config = pydantic.ConfigDict(frozen=False)
-
     @classmethod
     def build(cls, request: str, operation_id: FullArtifactSectionId) -> "ActionRequest":
         return cls(

donna/machine/artifacts.py

@@ -1,5 +1,7 @@
 from typing import TYPE_CHECKING, Any
 
+import pydantic
+
 from donna.core.entities import BaseEntity
 from donna.core.errors import ErrorsList
 from donna.core.result import Err, Ok, Result, unwrap_to_error
@@ -13,12 +15,13 @@ from donna.protocol.cells import Cell
 from donna.protocol.nodes import Node
 
 if TYPE_CHECKING:
-    from donna.world.artifacts import ArtifactRenderContext
+    from donna.workspaces.artifacts import ArtifactRenderContext
 
 
 class ArtifactSectionConfig(BaseEntity):
     id: ArtifactSectionId
     kind: PythonImportPath
+    tags: list[str] = pydantic.Field(default_factory=list)
 
 
 class ArtifactSectionMeta(BaseEntity):
@@ -32,6 +35,7 @@ class ArtifactSection(BaseEntity):
     kind: PythonImportPath
     title: str
     description: str
+    tags: list[str] = pydantic.Field(default_factory=list)
     primary: bool = False
 
     meta: ArtifactSectionMeta
@@ -138,12 +142,12 @@ class ArtifactNode(Node):
             return primary_section_result.unwrap_err()[0].node().status()
 
         primary_section = primary_section_result.unwrap()
-        return Cell.build_meta(
+        return Cell.build_markdown(
             kind="artifact_status",
             artifact_id=str(self._artifact.id),
             artifact_kind=str(primary_section.kind),
             artifact_title=primary_section.title,
-            artifact_description=primary_section.description,
+            content=primary_section.description,
         )
 
     def info(self) -> Cell:
@@ -161,8 +165,6 @@ class ArtifactNode(Node):
             content="\n".join(blocks_result.unwrap()),
             artifact_id=str(self._artifact.id),
             artifact_kind=str(primary_section.kind),
-            artifact_title=primary_section.title,
-            artifact_description=primary_section.description,
         )
 
     def components(self) -> list["Node"]:
@@ -191,7 +193,7 @@ class ArtifactSectionNode(Node):
 def resolve(
     target_id: FullArtifactSectionId, render_context: "ArtifactRenderContext"
 ) -> Result[ArtifactSection, ErrorsList]:
-    from donna.world import artifacts as world_artifacts
+    from donna.workspaces import artifacts as world_artifacts
 
     artifact = world_artifacts.load_artifact(target_id.full_artifact_id, render_context).unwrap()
 

donna/machine/primitives.py

@@ -14,10 +14,10 @@ if TYPE_CHECKING:
     from donna.machine.artifacts import Artifact, ArtifactSection
     from donna.machine.changes import Change
     from donna.machine.tasks import Task, WorkUnit
-    from donna.world.config import SourceConfig as SourceConfigModel
-    from donna.world.config import WorldConfig
-    from donna.world.sources.base import SourceConfig as SourceConfigValue
-    from donna.world.worlds.base import World
+    from donna.workspaces.config import SourceConfig as SourceConfigModel
+    from donna.workspaces.config import WorldConfig
+    from donna.workspaces.sources.base import SourceConfig as SourceConfigValue
+    from donna.workspaces.worlds.base import World
 
 
 # TODO: Currently is is a kind of God interface. It is convinient for now.

donna/machine/sessions.py

@@ -9,10 +9,10 @@ from donna.machine.operations import OperationMeta
 from donna.machine.state import ConsistentState, MutableState
 from donna.protocol.cell_shortcuts import operation_succeeded
 from donna.protocol.cells import Cell
-from donna.world import artifacts
-from donna.world import tmp as world_tmp
-from donna.world.config import config
-from donna.world.worlds.base import World
+from donna.workspaces import artifacts
+from donna.workspaces import tmp as world_tmp
+from donna.workspaces.config import config
+from donna.workspaces.worlds.base import World
 
 
 def _errors_to_cells(errors: ErrorsList) -> list[Cell]:
@@ -90,6 +90,14 @@ def start() -> list[Cell]:
     return [operation_succeeded("Started new session.")]
 
 
+def reset() -> list[Cell]:
+    save_result = _save_state(MutableState.build().freeze())
+    if save_result.is_err():
+        return _errors_to_cells(save_result.unwrap_err())
+
+    return [operation_succeeded("Session state reset.")]
+
+
 def clear() -> list[Cell]:
     world_tmp.clear()
     session_result = _session()

donna/machine/state.py

@@ -118,8 +118,8 @@ class MutableState(BaseState):
         self.started = True
 
     def add_action_request(self, action_request: ActionRequest) -> None:
-        action_request.id = self.next_action_request_id()
-        self.action_requests.append(action_request)
+        full_request = action_request.replace(id=self.next_action_request_id())
+        self.action_requests.append(full_request)
 
     def add_work_unit(self, work_unit: WorkUnit) -> None:
         self.work_units.append(work_unit)

donna/machine/tasks.py

@@ -1,15 +1,12 @@
 import copy
-import sys
 from typing import TYPE_CHECKING, Any
 
-import pydantic
-
 from donna.core.entities import BaseEntity
 from donna.core.errors import ErrorsList
 from donna.core.result import Ok, Result, unwrap_to_error
 from donna.domain.ids import FullArtifactSectionId, TaskId, WorkUnitId
 from donna.protocol.cells import Cell
-from donna.protocol.modes import get_cell_formatter
+from donna.protocol.utils import instant_output
 
 if TYPE_CHECKING:
     from donna.machine.changes import Change
@@ -19,9 +16,6 @@ class Task(BaseEntity):
     id: TaskId
     context: dict[str, Any]
 
-    # TODO: we may want to make queue items frozen later
-    model_config = pydantic.ConfigDict(frozen=False)
-
     @classmethod
     def build(cls, id: TaskId) -> "Task":
         return Task(
@@ -61,8 +55,8 @@ class WorkUnit(BaseEntity):
     def run(self, task: Task) -> Result[list["Change"], ErrorsList]:
         from donna.machine import artifacts as machine_artifacts
         from donna.machine.primitives import resolve_primitive
-        from donna.world.artifacts import ArtifactRenderContext
-        from donna.world.templates import RenderMode
+        from donna.workspaces.artifacts import ArtifactRenderContext
+        from donna.workspaces.templates import RenderMode
 
         render_context = ArtifactRenderContext(
             primary_mode=RenderMode.execute,
@@ -72,17 +66,9 @@ class WorkUnit(BaseEntity):
         operation = machine_artifacts.resolve(self.operation_id, render_context).unwrap()
         operation_kind = resolve_primitive(operation.kind).unwrap()
 
-        ##########################
-        # We log each operation here to help agent display the progress to the user
-        # TODO: not a good solution from the agent perspective
-        #       let's hope there will some protocol appear that helps with that later
-        # TODO: not so good place for and way of logging, should do smth with that
         log_message = f"{self.operation_id}: {operation.title}"
         log_cell = Cell.build(kind="donna_log", media_type="text/plain", content=log_message)
-        formatter = get_cell_formatter()
-        sys.stdout.buffer.write(formatter.format_log(log_cell, single_mode=True) + b"\n\n")
-        sys.stdout.buffer.flush()
-        ##########################
+        instant_output([log_cell])
 
         changes = list(operation_kind.execute_section(task, self, operation))
 

donna/machine/templates.py

@@ -28,11 +28,12 @@ class Directive(Primitive, ABC):
         self,
         context: Context,
         *argv: Any,
+        **kwargs: Any,
     ) -> Result[Any, ErrorsList]:
-        from donna.world import templates as world_templates
+        from donna.workspaces import templates as world_templates
 
         render_mode = context["render_mode"]
-        arguments_result = self._prepare_arguments(context, *argv)
+        arguments_result = self._prepare_arguments(context, *argv, **kwargs)
         if arguments_result.is_err():
             return arguments_result
 
@@ -52,6 +53,7 @@ class Directive(Primitive, ABC):
         self,
         context: Context,
         *argv: Any,
+        **kwargs: Any,
     ) -> PreparedDirectiveResult:
         return Ok(argv)