Phase D: TUI + AI Assistant

.gitignore

@@ -122,4 +122,7 @@ terraform.tfvars*
 .moon/cache
 .moon/docker
 
+# Worktrees
+.worktrees/
+
 # Specific directories for individual projects

apps/cli/.gitignore

@@ -6,4 +6,7 @@
 
 # Build artifacts
 bin/
-release/
+release/
+
+# Go module cache (downloaded deps)
+pkg/

apps/cli/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+## [Unreleased]
+
+## [v4.6.0-workspace-phase-d] - 2026-06-20
+
+### Added
+
+- Terminal UI (TUI) with bubbletea — dashboard and AI chat views
+- AI assistant with tool-calling capability (OpenAI/OpenRouter)
+- Multi-provider AI support (configurable via radas.yml)
+- Tool registry with workspace operations (run, generate, scan, read)
+- `:command` mode for direct CLI execution within TUI
+- Cost tracking per session with configurable ceiling
+- System prompt builder with workspace context injection
+- Help overlay and keybinding reference
+- Streaming chat with iterative tool execution
+- env-var resolution for API keys ($OPENROUTER_KEY, etc.)
+
+## [v4.5.0-workspace-phase-c] - 2026-06-20
+
+### Added
+
+- Code generator engine with .gotpl template rendering (text/template, missingkey=error)
+- Template definition parser (YAML-based template.yml with variables and outputs)
+- Variable resolution with --var overrides, defaults, and validation patterns
+- Local template registry with Scan() for discovering templates
+- Remote template fetching via git clone (Add method)
+- `workspace generate <name>` command with --output-dir, --var, --force, --non-interactive flags
+- `workspace template list` command to show available templates
+- `workspace template add <url>` command to install remote templates
+- `workspace template create <name>` command to scaffold new templates
+- Integration test exercising the full generate pipeline
+
+### Added
+
+- `workspace run <task> [--project|--all|--affected]` — topological task execution with cache (Phase B)
+- `workspace affected [--base|--json]` — list projects affected by git changes
+- `workspace cache status|clear` — local cache management
+- `internal/cache/` — content-addressable cache (SHA256, FS-backed at `~/.radas/cache/`)
+- `internal/runner/` — pipeline resolution, layered Kahn's scheduler, parallel batch executor, summary table
+- `internal/graph/affected.go` — git diff → affected project set with transitive expansion
+- `workspace` command group (Phase A: Monorepo Manager)
+  - `workspace init` — generate radas.yml with workspace section
+  - `workspace list` — table of all projects
+  - `workspace show <name>` — project details + dependencies
+  - `workspace graph [--ascii|--output=svg|png|json|--web]` — dependency visualization
+  - `workspace validate` — check for cycles and stale patterns
+- `internal/workspace/` package: scanner, detectors (radasyml/go/node), parser
+- `internal/project/` package: Project data model
+- `internal/graph/` package: dominikbraun/graph wrapper, ASCII/DOT/SVG renderers, web viewer
+- Configuration: `RadasConfig.Workspace` (optional block; presence enables workspace mode)

apps/cli/cmd/root.go

@@ -8,13 +8,16 @@ import (
 	"github.com/raizora/radas/v4/cmd/frontend"
 	"github.com/raizora/radas/v4/cmd/infra"
 	"github.com/raizora/radas/v4/cmd/rootcmd"
+	"github.com/raizora/radas/v4/cmd/workspace"
 )
 
 var rootCmd = &cobra.Command{
 	Use:   "radas",
 	Short: "RADAS CLI - tool to simplify daily developer activities",
 	Long: `RADAS CLI is a command line interface that helps developers from various teams
-(Frontend, Backend, DevOps, Design) to handle their daily activities with ease.`,
+(Frontend, Backend, DevOps, Design) to handle their daily activities with ease.
+When run with no arguments in a terminal, it launches the TUI dashboard.`,
+	RunE: runTUI,
 }
 
 // Execute runs the root command
@@ -42,4 +45,5 @@ func init() {
 	rootCmd.AddCommand(rootcmd.RebuildCmd)
 	rootCmd.AddCommand(rootcmd.PullCmd)
 	rootCmd.AddCommand(rootcmd.ScanCmd)
+	rootCmd.AddCommand(workspace.Cmd)
 }

apps/cli/cmd/tui.go

@@ -0,0 +1,35 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/raizora/radas/v4/internal/ai"
+	"github.com/raizora/radas/v4/internal/tui"
+	"github.com/spf13/cobra"
+)
+
+func isTerminal(fd uintptr) bool {
+	stat, _ := os.Stdout.Stat()
+	return (stat.Mode() & os.ModeCharDevice) != 0
+}
+
+func runTUI(cmd *cobra.Command, args []string) error {
+	if len(args) > 0 {
+		return cmd.Help()
+	}
+	if !isTerminal(os.Stdout.Fd()) {
+		return cmd.Help()
+	}
+
+	aiConfig, err := ai.LoadAIConfigFromRadasYML()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "warning: failed to load AI config: %v\n", err)
+		aiConfig = nil
+	}
+
+	projects := []string{}
+	templates := []string{}
+
+	return tui.Start(projects, templates, aiConfig)
+}

apps/cli/cmd/workspace/affected.go

@@ -0,0 +1,14 @@
+package workspace
+
+import "github.com/spf13/cobra"
+
+var affectedCmd = &cobra.Command{
+	Use:   "affected",
+	Short: "List projects affected by changes between git refs",
+	RunE:  func(cmd *cobra.Command, args []string) error { return runAffected(cmd) },
+}
+
+func init() {
+	affectedCmd.Flags().String("base", "main", "base ref")
+	affectedCmd.Flags().Bool("json", false, "output as JSON")
+}

apps/cli/cmd/workspace/cache.go

@@ -0,0 +1,24 @@
+package workspace
+
+import "github.com/spf13/cobra"
+
+var cacheCmd = &cobra.Command{
+	Use:   "cache",
+	Short: "Manage the local task cache",
+}
+
+var cacheStatusCmd = &cobra.Command{
+	Use:   "status",
+	Short: "Show cache size and entry count",
+	RunE:  func(cmd *cobra.Command, args []string) error { return runCacheStatus(cmd) },
+}
+
+var cacheClearCmd = &cobra.Command{
+	Use:   "clear",
+	Short: "Remove all cache entries",
+	RunE:  func(cmd *cobra.Command, args []string) error { return runCacheClear(cmd) },
+}
+
+func init() {
+	cacheCmd.AddCommand(cacheStatusCmd, cacheClearCmd)
+}

apps/cli/cmd/workspace/generate.go

@@ -0,0 +1,66 @@
+package workspace
+
+import (
+	"fmt"
+
+	"github.com/raizora/radas/v4/internal/generator"
+	"github.com/spf13/cobra"
+)
+
+var (
+	generateOutDir         string
+	generateVars           []string
+	generateForce          bool
+	generateNonInteractive bool
+	generateTemplateDir    string
+)
+
+var generateCmd = &cobra.Command{
+	Use:   "generate <template-name>",
+	Short: "Generate code from a template",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		overrides := make(map[string]string)
+		for _, v := range generateVars {
+			parts := splitVar(v)
+			if parts == nil {
+				return fmt.Errorf("invalid --var format %q, expected key=value", v)
+			}
+			overrides[parts[0]] = parts[1]
+		}
+
+		err := generator.GenerateTemplateWith(generator.GenerateSettings{
+			TemplateName:   args[0],
+			Overrides:      overrides,
+			OutDir:         generateOutDir,
+			Force:          generateForce,
+			NonInteractive: generateNonInteractive,
+			TemplateDir:    generateTemplateDir,
+		})
+		if err != nil {
+			return err
+		}
+
+		cmd.Println("Generated from template:", args[0])
+		return nil
+	},
+}
+
+func init() {
+	Cmd.AddCommand(generateCmd)
+
+	generateCmd.Flags().StringVarP(&generateOutDir, "output-dir", "o", ".", "Output directory")
+	generateCmd.Flags().StringArrayVar(&generateVars, "var", nil, "Template variable (key=value)")
+	generateCmd.Flags().BoolVarP(&generateForce, "force", "f", false, "Overwrite existing files")
+	generateCmd.Flags().BoolVar(&generateNonInteractive, "non-interactive", false, "Skip prompts, use defaults")
+	generateCmd.Flags().StringVarP(&generateTemplateDir, "template-dir", "T", "./templates", "Template directory")
+}
+
+func splitVar(v string) []string {
+	for i := 0; i < len(v); i++ {
+		if v[i] == '=' {
+			return []string{v[:i], v[i+1:]}
+		}
+	}
+	return nil
+}

apps/cli/cmd/workspace/graph.go

@@ -0,0 +1,16 @@
+package workspace
+
+import "github.com/spf13/cobra"
+
+var graphCmd = &cobra.Command{
+	Use:   "graph",
+	Short: "Visualize the workspace dependency graph",
+	RunE: func(cmd *cobra.Command, args []string) error { return runGraph(cmd) },
+}
+
+func init() {
+	graphCmd.Flags().StringP("output", "o", "", "output format: svg|png|json")
+	graphCmd.Flags().String("file", "", "output file path")
+	graphCmd.Flags().Bool("web", false, "open interactive browser viewer")
+	graphCmd.Flags().Bool("ascii", false, "force ASCII output (default)")
+}

apps/cli/cmd/workspace/helpers.go

@@ -0,0 +1,7 @@
+package workspace
+
+import "path/filepath"
+
+func filepathDir(p string) string {
+	return filepath.Dir(p)
+}

apps/cli/cmd/workspace/init.go

@@ -0,0 +1,9 @@
+package workspace
+
+import "github.com/spf13/cobra"
+
+var initCmd = &cobra.Command{
+	Use:   "init",
+	Short: "Initialize workspace mode in the current directory",
+	RunE: func(cmd *cobra.Command, args []string) error { return runInit(cmd) },
+}

apps/cli/cmd/workspace/integration_test.go

@@ -0,0 +1,76 @@
+package workspace
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestEndToEndWorkspace(t *testing.T) {
+	root := t.TempDir()
+	os.WriteFile(filepath.Join(root, "radas.yml"),
+		[]byte("name: e2e\nworkspace:\n  projects: [apps/*, libs/*]\n"), 0644)
+	for _, p := range []struct {
+		path, name, typ, dep string
+	}{
+		{"apps/api", "api", "backend-api", "[shared]"},
+		{"apps/web", "web", "frontend-web", "[shared]"},
+		{"libs/shared", "shared", "lib", ""},
+	} {
+		d := filepath.Join(root, p.path)
+		os.MkdirAll(d, 0755)
+		yml := "name: " + p.name + "\ntype: " + p.typ + "\n"
+		if p.dep != "" {
+			yml += "workspace:\n  depends_on: " + p.dep + "\n"
+		}
+		os.WriteFile(filepath.Join(d, "radas.yml"), []byte(yml), 0644)
+	}
+	oldDir, _ := os.Getwd()
+	os.Chdir(root)
+	defer os.Chdir(oldDir)
+
+	// 1. list shows all 3 projects
+	var buf bytes.Buffer
+	listCmd.SetOut(&buf)
+	if err := runList(listCmd); err != nil {
+		t.Fatal(err)
+	}
+	for _, n := range []string{"api", "web", "shared"} {
+		if !strings.Contains(buf.String(), n) {
+			t.Errorf("list missing %q: %s", n, buf.String())
+		}
+	}
+
+	// 2. show displays project details
+	buf.Reset()
+	showCmd.SetOut(&buf)
+	if err := runShow(showCmd, []string{"api"}); err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(buf.String(), "Dependencies") {
+		t.Errorf("show missing Dependencies: %s", buf.String())
+	}
+
+	// 3. graph --ascii produces output
+	buf.Reset()
+	graphCmd.SetOut(&buf)
+	graphCmd.SetArgs([]string{"--ascii"})
+	if err := runGraph(graphCmd); err != nil {
+		t.Fatal(err)
+	}
+	if buf.Len() == 0 {
+		t.Error("graph produced empty output")
+	}
+
+	// 4. validate reports OK
+	buf.Reset()
+	validateCmd.SetOut(&buf)
+	if err := runValidate(validateCmd); err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(buf.String(), "OK") {
+		t.Errorf("validate: %s", buf.String())
+	}
+}

apps/cli/cmd/workspace/list.go

@@ -0,0 +1,9 @@
+package workspace
+
+import "github.com/spf13/cobra"
+
+var listCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all projects in the workspace",
+	RunE: func(cmd *cobra.Command, args []string) error { return runList(cmd) },
+}

apps/cli/cmd/workspace/run.go

@@ -0,0 +1,25 @@
+package workspace
+
+import "github.com/spf13/cobra"
+
+var runCmd = &cobra.Command{
+	Use:   "run <task>",
+	Short: "Run a task with topological scheduling, parallel execution, and cache",
+	Long: `Run a task across the workspace. Examples:
+
+  radas workspace run test --project=api
+  radas workspace run build --all
+  radas workspace run test --affected --base=main
+  radas workspace run build --no-cache`,
+	Args: cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error { return runRun(cmd, args) },
+}
+
+func init() {
+	runCmd.Flags().String("project", "", "run task only in this project")
+	runCmd.Flags().Bool("all", false, "run task in all projects that have it")
+	runCmd.Flags().Bool("affected", false, "run task only in projects affected by changes")
+	runCmd.Flags().String("base", "main", "base ref for affected detection (used with --affected)")
+	runCmd.Flags().Bool("no-cache", false, "force re-execution, bypass cache")
+	runCmd.Flags().Int("max-parallel", 4, "max parallel task execution")
+}