feat(agents): improve agents CLI output with useful feedback

  - Add clear feedback about detected project types
  - Add UV lock file validation warnings with guidance
  - Add helpful "Next steps" after Dockerfile generation
  - Improve error messages with multi-line formatting

Author: dwayn

cmd/lk/agent.go

@@ -382,7 +382,7 @@ func createAgent(ctx context.Context, cmd *cli.Command) error {
 		return fmt.Errorf("unable to determine project type: %w, please use a supported project type, or create your own Dockerfile in the current directory", err)
 	}
 
-	if err := requireDockerfile(ctx, cmd, workingDir, projectType, settingsMap); err != nil {
+	if err := requireDockerfile(ctx, cmd, workingDir, settingsMap); err != nil {
 		return err
 	}
 
@@ -1118,29 +1118,19 @@ func requireSecrets(_ context.Context, cmd *cli.Command, required, lazy bool) ([
 	return secretsSlice, nil
 }
 
-func requireDockerfile(_ context.Context, cmd *cli.Command, workingDir string, projectType agentfs.ProjectType, settingsMap map[string]string) error {
+func requireDockerfile(_ context.Context, cmd *cli.Command, workingDir string, settingsMap map[string]string) error {
 	dockerfileExists, err := agentfs.HasDockerfile(workingDir)
 	if err != nil {
 		return err
 	}
 
 	if !dockerfileExists {
 		if !cmd.Bool("silent") {
-			var innerErr error
-			if err := util.Await(
-				"Creating Dockerfile...",
-				func() {
-					innerErr = agentfs.CreateDockerfile(workingDir, projectType, settingsMap)
-				},
-			); err != nil {
+			if err := agentfs.CreateDockerfile(workingDir, settingsMap); err != nil {
 				return err
 			}
-			if innerErr != nil {
-				return innerErr
-			}
-			fmt.Println("Created [" + util.Accented("Dockerfile") + "]")
 		} else {
-			if err := agentfs.CreateDockerfile(workingDir, projectType, settingsMap); err != nil {
+			if err := agentfs.CreateDockerfile(workingDir, settingsMap); err != nil {
 				return err
 			}
 		}

pkg/agentfs/docker.go

@@ -49,45 +49,88 @@ func HasDockerfile(dir string) (bool, error) {
 	return false, nil
 }
 
-func CreateDockerfile(dir string, projectType ProjectType, settingsMap map[string]string) error {
+func CreateDockerfile(dir string, settingsMap map[string]string) error {
 	if len(settingsMap) == 0 {
 		return fmt.Errorf("unable to fetch client settings from server, please try again later")
 	}
 
+	projectType, err := DetectProjectType(dir)
+	if err != nil {
+		return fmt.Errorf(`× Unable to determine project type
+
+Supported project types:
+  • Python: requires requirements.txt or pyproject.toml
+  • Node.js: requires package.json
+
+Please ensure your project has the appropriate dependency file, or create a Dockerfile manually in the current directory`)
+	}
+
+	// Provide user feedback about detected project type
+	switch projectType {
+	case ProjectTypeNode:
+		fmt.Printf("✔ Detected Node.js project (found %s)\n", util.Accented("package.json"))
+		fmt.Printf("  Using template [%s] with npm/yarn support\n", util.Accented("node"))
+	case ProjectTypePythonUV:
+		fmt.Printf("✔ Detected Python project with UV package manager\n")
+		fmt.Printf("  Using template [%s] for faster builds\n", util.Accented("python.uv"))
+		// Validate UV project setup
+		validateUVProject(dir)
+	case ProjectTypePythonPip:
+		fmt.Printf("✔ Detected Python project with pip package manager\n")
+		fmt.Printf("  Using template [%s]\n", util.Accented("python.pip"))
+	}
+
 	var dockerfileContent []byte
 	var dockerIgnoreContent []byte
-	var err error
 
 	dockerfileContent, err = fs.ReadFile("examples/" + string(projectType) + ".Dockerfile")
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to load Dockerfile template '%s': %w", string(projectType), err)
 	}
+
 	dockerIgnoreContent, err = fs.ReadFile("examples/" + string(projectType) + ".dockerignore")
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to load .dockerignore template for '%s': %w", string(projectType), err)
 	}
 
 	// TODO: (@rektdeckard) support Node entrypoint validation
 	if projectType.IsPython() {
 		dockerfileContent, err = validateEntrypoint(dir, dockerfileContent, dockerIgnoreContent, projectType, settingsMap)
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to validate Python entry point: %w", err)
 		}
 	}
 
 	err = os.WriteFile(filepath.Join(dir, "Dockerfile"), dockerfileContent, 0644)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to write Dockerfile: %w", err)
 	}
 
 	err = os.WriteFile(filepath.Join(dir, ".dockerignore"), dockerIgnoreContent, 0644)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to write .dockerignore: %w", err)
 	}
 
+	fmt.Printf("\n✔ Successfully generated Docker files:\n")
+	fmt.Printf("  %s - Container build instructions\n", util.Accented("Dockerfile"))
+	fmt.Printf("  %s - Files excluded from build context\n", util.Accented(".dockerignore"))
+	fmt.Printf("\nNext steps:\n")
+	fmt.Printf("  ► Review the %s and uncomment any needed system packages\n", util.Accented("Dockerfile"))
+	fmt.Printf("  ► Build your agent: docker build -t my-agent .\n")
+	fmt.Printf("  ► Test locally: docker run my-agent\n")
+
 	return nil
 }
 
+func validateUVProject(dir string) {
+	uvLockPath := filepath.Join(dir, "uv.lock")
+	if _, err := os.Stat(uvLockPath); err != nil {
+		fmt.Printf("! Warning: UV project detected but %s file not found\n", util.Accented("uv.lock"))
+		fmt.Printf("  Consider running %s to generate %s for reproducible builds\n", util.Accented("uv lock"), util.Accented("uv.lock"))
+		fmt.Printf("  This ensures consistent dependency versions across environments\n\n")
+	}
+}
+
 func validateEntrypoint(dir string, dockerfileContent []byte, dockerignoreContent []byte, projectType ProjectType, settingsMap map[string]string) ([]byte, error) {
 	valFile := func(fileName string) (string, error) {
 		// Parse dockerignore patterns to filter out files that won't be in build context