anchor.diff:                 (apply #'trivial-shell:shell-command args)
                (declare (ignorable result code))
                (when (not (zerop status))
  -               (return-from update-repository-from-address (values nil nil nil))))))
  -    (let ((library-version-repository (find-library-version-repository
  -                                       library-version
  -                                       (name repository))))
  -      (when (and library-version-repository
  -                 (typep (repository-address library-version-repository)
  -                        'git-repository-address))
  -        (let ((library-version-repository-address (repository-address library-version-repository)))
  -          ;; Ok, try the update
  -          (info-msg "Updating ~A...~%" (library-version-unique-name library-version))
  -          (let ((command (format nil "cd ~A; git pull" install-directory)))
  -            (verbose-msg (format nil "~A~%" command))
  -            (run-or-fail command))
  -          (awhen (branch library-version-repository-address)
  -            (let ((command (format nil "cd ~A; git checkout ~A" install-directory it)))
  -              (verbose-msg (format nil "~A~%" command))
  -              (run-or-fail command)))
  -          (awhen (commit library-version-repository-address)
  -            (let ((command (format nil "cd ~A; git checkout ~A" install-directory it)))
  -              (verbose-msg (format nil "~A~%" command))
  -              (run-or-fail command)))
  -          (awhen (tag library-version-repository-address)
  -            (let ((command (format nil "cd ~A; git checkout tags/~A" install-directory it)))
  -              (verbose-msg (format nil "~A~%" command))
  -              (run-or-fail command)))
  -          ;; Return the install directory and repository
  -          (values t                 ;; The update was successful
  -                  install-directory ;; In which directory the update was made
  -                  library-version-repository ;; The repository from which the update was made
  -                  ))))))
  +	       (verbose-msg "Command ~A failed~A" args)
  +               (return-from update-repository-from-address nil)))))
  +    ;; Ok, try the update
  +    (info-msg "Updating ~A...~%" (library-version-unique-name library-version))
  +    (let ((command (format nil "cd ~A; git pull" install-directory)))
  +      (verbose-msg (format nil "~A~%" command))
  +      (run-or-fail command))
  +    (awhen (branch repository-address)
  +      (let ((command (format nil "cd ~A; git checkout ~A" install-directory it)))
  +	(verbose-msg (format nil "~A~%" command))
  +	(run-or-fail command)))
  +    (awhen (commit repository-address)
  +      (let ((command (format nil "cd ~A; git checkout ~A" install-directory it)))
  +	(verbose-msg (format nil "~A~%" command))
  +	(run-or-fail command)))
  +    (awhen (tag repository-address)
  +      (let ((command (format nil "cd ~A; git checkout tags/~A" install-directory it)))
  +	(verbose-msg (format nil "~A~%" command))
  +	(run-or-fail command)))
  +    (make-instance 'installed-library-version
  +		   :name (library-name library-version)
  +		   :version (version library-version)
  +		   :repository repository
  +		   :install-directory install-directory)))
   
   (defun find-cld-repository (name &optional (error-p t))
     (let ((cld-repository (find name (list-cld-repositories)
  
positive.code:     (info-msg "Cloning repository: ~A...~%" (url repository-address))
      (run-or-fail (format nil "git clone ~A ~A"
                           (url repository-address)
                           (princ-to-string target-directory)))
      (when (branch repository-address)
        (info-msg "Checking out ~A branch.~%" (branch repository-address))
        (run-or-fail (format nil "cd ~A; git checkout ~A"
                             target-directory
                             (branch repository-address))))
      (when (commit repository-address)
        (info-msg "Checking out commit ~A~%" (commit repository-address))
        (let ((command  (format nil "cd ~A; git checkout ~A"
                                (princ-to-string target-directory)
                                (commit repository-address))))
          (verbose-msg "~A~%" command)
          (run-or-fail command)))
      (when (tag repository-address)
        (info-msg "Checking out tag ~A~%" (tag repository-address))
        (let ((command  (format nil "cd ~A; git checkout tags/~A"
                                (princ-to-string target-directory)
                                (tag repository-address))))
          (verbose-msg "~A~%" command)
          (run-or-fail command)))
  
negative.code:       (info-msg "Downloading ~A...~%" (url repository-address))
        (run-or-fail (format nil "wget -O ~A ~A" temporal-file (url repository-address)))
        (info-msg "Extracting...~%")
        (run-or-fail (format nil "mkdir ~A" (princ-to-string install-directory)))
        (run-or-fail (format nil "tar zxf ~A --strip=1 -C ~A"
                             temporal-file
                             (princ-to-string install-directory))))
      t))
  
  (defmethod install-repository-from-address ((repository-address ssh-repository-address)
                                              repository install-directory)
    (flet ((run-or-fail (&rest args)
             (multiple-value-bind (result code status)
                 (apply #'trivial-shell:shell-command args)
  