Method run

atomic-cli/src/commands/view/new.rs:314–416

(&self)

impl Command for New {
    fn run(&self) -> CliResult<()> {
        // Get the view name
        let name = self
            .name
            .as_ref()
            .ok_or_else(|| CliError::InvalidArgument {
                message: "View name is required".to_string(),
            })?;

        // Validate the view name
        validate_view_name(name).map_err(|msg| CliError::InvalidArgument { message: msg })?;

        // Find the repository
        let repo_root = find_repository_root()?;
        let mut repo = Repository::open(&repo_root).map_err(|e| match e {
            atomic_repository::RepositoryError::NotFound { path } => CliError::RepositoryNotFound {
                searched_path: path.into(),
            },
            other => CliError::Repository(other),
        })?;

        // Check if the view already exists
        if repo.view_exists(name).map_err(CliError::Repository)? {
            return Err(CliError::ViewAlreadyExists {
                name: name.to_string(),
            });
        }

        // If --draft or --parent is specified, use the two-tier create path
        if self.draft || self.parent.is_some() {
            return self.run_two_tier(name, &mut repo);
        }

        // Determine how to create the new view:
        //
        //   --from X → create Draft parented on X, insert X's changes
        //   default  → create Draft parented on nearest Shared ancestor,
        //              with an EMPTY change log (no files until `insert`)
        //
        // The new view is a Draft workspace whose edges go to
        // GRAPH (filtered by this view's change set).  The parent link
        // gives the overlay chain read-access to the shared graph for
        // record-time diff computation.
        //
        // When --from is specified, the source's changes are inserted
        // immediately so the new view starts with the source's files.
        // Without --from, the change log starts empty — the user brings
        // in changes explicitly via `insert from-view`.  This is the
        // normal workflow:
        //
        //   atomic view create feature          # empty workspace
        //   atomic insert from-view dev         # inherit dev's files
        //   # ... make changes, record ...
        //   atomic insert from-view feature --to-view dev  # promote
        if let Some(ref source) = self.from {
            // Explicit --from: fork from the specified view.
            if !repo.view_exists(source).map_err(CliError::Repository)? {
                return Err(CliError::ViewNotFound {