Go para CLI Tools: Guia Pratico

go version
# go version go1.22.0 linux/amd64

mkdir minha-cli && cd minha-cli
go mod init github.com/seu-usuario/minha-cli

go install github.com/spf13/cobra-cli@latest
cobra-cli init

import { readFileSync, writeFileSync, existsSync } from "fs";
import { join } from "path";
import { homedir } from "os";
 
interface Task {
  id: number;
  title: string;
  done: boolean;
  createdAt: string;
}
 
interface TaskStore {
  tasks: Task[];
  nextId: number;
}
 
const STORE_PATH = join(homedir(), ".tasks.json");
 
function loadStore(): TaskStore {
  if (!existsSync(STORE_PATH)) {
    return { tasks: [], nextId: 1 };
  }
  const raw = readFileSync(STORE_PATH, "utf-8");
  return JSON.parse(raw) as TaskStore;
}
 
function saveStore(store: TaskStore): void {
  writeFileSync(STORE_PATH, JSON.stringify(store, null, 2), "utf-8");
}
 
function addTask(title: string): Task {
  const store = loadStore();
  const task: Task = {
    id: store.nextId,
    title,
    done: false,
    createdAt: new Date().toISOString(),
  };
  store.tasks.push(task);
  store.nextId += 1;
  saveStore(store);
  return task;
}
 
function listTasks(showAll: boolean): Task[] {
  const store = loadStore();
  if (showAll) {
    return store.tasks;
  }
  return store.tasks.filter((t) => !t.done);
}
 
function completeTask(id: number): Task | null {
  const store = loadStore();
  const task = store.tasks.find((t) => t.id === id);
  if (!task) return null;
  task.done = true;
  saveStore(store);
  return task;
}
 
// Simulando o parse de argumentos da CLI
const command = process.argv[2];
const arg = process.argv[3];
 
switch (command) {
  case "add":
    if (!arg) {
      console.error("Uso: tasks add <titulo>");
      process.exit(1);
    }
    const newTask = addTask(arg);
    console.log(`Tarefa #${newTask.id} criada: ${newTask.title}`);
    break;
  case "list":
    const all = arg === "--all";
    const tasks = listTasks(all);
    tasks.forEach((t) => {
      const status = t.done ? "[x]" : "[ ]";
      console.log(`${status} #${t.id} ${t.title}`);
    });
    break;
  case "done":
    const completed = completeTask(Number(arg));
    if (completed) {
      console.log(`Tarefa #${completed.id} concluída!`);
    } else {
      console.error(`Tarefa #${arg} não encontrada.`);
    }
    break;
  default:
    console.log("Comandos: add, list, done");
}

// main.go
package main
 
import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"strconv"
	"time"
 
	"github.com/spf13/cobra"
)
 
type Task struct {
	ID        int       `json:"id"`
	Title     string    `json:"title"`
	Done      bool      `json:"done"`
	CreatedAt time.Time `json:"created_at"`
}
 
type TaskStore struct {
	Tasks  []Task `json:"tasks"`
	NextID int    `json:"next_id"`
}
 
func storePath() string {
	home, _ := os.UserHomeDir()
	return filepath.Join(home, ".tasks.json")
}
 
func loadStore() (TaskStore, error) {
    path := storePath()
    data, err := os.ReadFile(path)
    if os.IsNotExist(err) {
        return TaskStore{NextID: 1}, nil
    }
    if err != nil {
        return TaskStore{}, fmt.Errorf("ler %s: %w", path, err)
    }
 
    var store TaskStore
    if err := json.Unmarshal(data, &store); err != nil {
        return TaskStore{}, fmt.Errorf("JSON inválido em %s: %w", path, err)
    }
    if store.NextID < 1 {
        return TaskStore{}, fmt.Errorf("next_id inválido em %s", path)
    }
    return store, nil
}
 
func saveStore(store TaskStore) error {
	data, err := json.MarshalIndent(store, "", "  ")
	if err != nil {
		return err
	}
	return os.WriteFile(storePath(), data, 0644)
}
 
func main() {
	var showAll bool
 
	rootCmd := &cobra.Command{
		Use:   "tasks",
		Short: "Gerenciador de tarefas via terminal",
	}
 
	addCmd := &cobra.Command{
		Use:   "add [titulo]",
		Short: "Adiciona uma nova tarefa",
		Args:  cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			store, err := loadStore()
			if err != nil {
			    return err
			}
			task := Task{
				ID:        store.NextID,
				Title:     args[0],
				Done:      false,
				CreatedAt: time.Now(),
			}
			store.Tasks = append(store.Tasks, task)
			store.NextID++
			if err := saveStore(store); err != nil {
				return fmt.Errorf("erro ao salvar: %w", err)
			}
			fmt.Printf("Tarefa #%d criada: %s\n", task.ID, task.Title)
			return nil
		},
	}
 
	listCmd := &cobra.Command{
	    Use:   "list",
	    Short: "Lista tarefas pendentes",
	    RunE: func(cmd *cobra.Command, args []string) error {
	        store, err := loadStore()
	        if err != nil {
	            return err
	        }
	        for _, t := range store.Tasks {
	            if !showAll && t.Done {
	                continue
	            }
	            status := "[ ]"
	            if t.Done {
	                status = "[x]"
	            }
	            fmt.Printf("%s #%d %s\n", status, t.ID, t.Title)
	        }
	        return nil
	    },
	}
	listCmd.Flags().BoolVarP(&showAll, "all", "a", false, "Mostra todas as tarefas")
 
	doneCmd := &cobra.Command{
		Use:   "done [id]",
		Short: "Marca uma tarefa como concluída",
		Args:  cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			id, err := strconv.Atoi(args[0])
			if err != nil {
				return fmt.Errorf("ID inválido: %s", args[0])
			}
			store, err := loadStore()
			if err != nil {
			    return err
			}
			for i := range store.Tasks {
				if store.Tasks[i].ID == id {
					store.Tasks[i].Done = true
					if err := saveStore(store); err != nil {
					    return fmt.Errorf("erro ao salvar: %w", err)
					}
					fmt.Printf("Tarefa #%d concluída!\n", id)
					return nil
				}
			}
			return fmt.Errorf("tarefa #%d não encontrada", id)
		},
	}
 
	rootCmd.AddCommand(addCmd, listCmd, doneCmd)
	if err := rootCmd.Execute(); err != nil {
	    os.Exit(1)
	}
}

go build -o tasks .
./tasks add "Escrever artigo sobre Go CLI"
./tasks list
./tasks done 1
./tasks list --all

import { readFileSync } from "fs";
import { z } from "zod";
 
const ConfigSchema = z.object({
  appName: z.string().min(1, "appName é obrigatório"),
  port: z.number().int().min(1024).max(65535),
  database: z.object({
    host: z.string().min(1),
    port: z.number().int(),
    name: z.string().min(1),
  }),
  features: z.record(z.boolean()).optional(),
});
 
type Config = z.infer<typeof ConfigSchema>;
 
interface ValidationResult {
  valid: boolean;
  errors: string[];
  warnings: string[];
}
 
function validateConfig(filePath: string): ValidationResult {
  const result: ValidationResult = {
    valid: true,
    errors: [],
    warnings: [],
  };
 
  let raw: string;
  try {
    raw = readFileSync(filePath, "utf-8");
  } catch {
    return { valid: false, errors: [`Arquivo não encontrado: ${filePath}`], warnings: [] };
  }
 
  let parsed: unknown;
  try {
    parsed = JSON.parse(raw);
  } catch {
    return { valid: false, errors: ["JSON inválido"], warnings: [] };
  }
 
  const parseResult = ConfigSchema.safeParse(parsed);
  if (!parseResult.success) {
    result.valid = false;
    result.errors = parseResult.error.issues.map(
      (issue) => `${issue.path.join(".")}: ${issue.message}`
    );
    return result;
  }
 
  const config = parseResult.data;
  if (config.port === 3000) {
    result.warnings.push("Porta 3000 é comum em desenvolvimento. Considere mudar para produção.");
  }
  if (!config.features || Object.keys(config.features).length === 0) {
    result.warnings.push("Nenhuma feature flag configurada.");
  }
 
  return result;
}
 
const filePath = process.argv[2] || "config.json";
const validation = validateConfig(filePath);
 
if (validation.valid) {
  console.log("Configuração válida!");
} else {
  console.error("Erros encontrados:");
  validation.errors.forEach((e) => console.error(`  - ${e}`));
}
 
if (validation.warnings.length > 0) {
  console.warn("Avisos:");
  validation.warnings.forEach((w) => console.warn(`  - ${w}`));
}
 
process.exit(validation.valid ? 0 : 1);

minha-cli/
  cmd/
    root.go
    add.go
    list.go
    done.go
  internal/
    store/
      store.go
    config/
      config.go
  pkg/
    formatter/
      table.go
  main.go
  go.mod
  go.sum