stealthos-cli 0.1.0-alpha.3 → 0.1.0-alpha.4

package/ai/scripts/detect-stack.ps1

@@ -0,0 +1,166 @@
+# detect-stack.ps1
+# Inspeciona um projeto e produz um relatorio que pode pre-preencher project-context.md.
+
+param(
+    [string]$TargetPath = (Get-Location).Path,
+    [string]$OutputPath = ""
+)
+
+$ErrorActionPreference = "Continue"
+
+function Test-File($name) { Test-Path (Join-Path $TargetPath $name) }
+function Test-Dir($name) { Test-Path (Join-Path $TargetPath $name) -PathType Container }
+
+$findings = [ordered]@{
+    detected_at = (Get-Date -Format "yyyy-MM-dd HH:mm:ss")
+    target = $TargetPath
+    languages = @()
+    frameworks = @()
+    databases = @()
+    infra = @()
+    ci_cd = @()
+    test_frameworks = @()
+    linters = @()
+    formatters = @()
+    package_manager = $null
+    structure_style = $null
+    smells = @()
+}
+
+# ----- Linguagens -----
+if (Test-File "package.json") { $findings.languages += "JavaScript/Node.js" }
+if (Test-File "tsconfig.json") { $findings.languages += "TypeScript" }
+if ((Test-File "pyproject.toml") -or (Test-File "requirements.txt") -or (Test-File "setup.py")) { $findings.languages += "Python" }
+if (Test-File "Cargo.toml") { $findings.languages += "Rust" }
+if (Test-File "go.mod") { $findings.languages += "Go" }
+if ((Test-File "pom.xml") -or (Test-File "build.gradle") -or (Test-File "build.gradle.kts")) { $findings.languages += "Java/Kotlin/JVM" }
+if (Test-File "composer.json") { $findings.languages += "PHP" }
+if (Test-File "Gemfile") { $findings.languages += "Ruby" }
+if (Test-File "mix.exs") { $findings.languages += "Elixir" }
+if (Test-File "pubspec.yaml") { $findings.languages += "Dart/Flutter" }
+$csproj = Get-ChildItem -Path $TargetPath -Filter "*.csproj" -ErrorAction SilentlyContinue | Select-Object -First 1
+if ($csproj) { $findings.languages += ".NET (C#)" }
+
+# ----- Package manager -----
+if (Test-File "pnpm-lock.yaml") { $findings.package_manager = "pnpm" }
+elseif (Test-File "yarn.lock") { $findings.package_manager = "yarn" }
+elseif (Test-File "package-lock.json") { $findings.package_manager = "npm" }
+elseif (Test-File "bun.lockb") { $findings.package_manager = "bun" }
+elseif (Test-File "poetry.lock") { $findings.package_manager = "poetry" }
+elseif (Test-File "Pipfile.lock") { $findings.package_manager = "pipenv" }
+elseif (Test-File "Cargo.lock") { $findings.package_manager = "cargo" }
+
+# ----- Frameworks (a partir de package.json) -----
+if (Test-File "package.json") {
+    try {
+        $pkg = Get-Content (Join-Path $TargetPath "package.json") -Raw | ConvertFrom-Json
+        $allDeps = @{}
+        if ($pkg.dependencies) { $pkg.dependencies.PSObject.Properties | ForEach-Object { $allDeps[$_.Name] = $_.Value } }
+        if ($pkg.devDependencies) { $pkg.devDependencies.PSObject.Properties | ForEach-Object { $allDeps[$_.Name] = $_.Value } }
+
+        $frontendMap = @{ "react"="React"; "next"="Next.js"; "vue"="Vue"; "nuxt"="Nuxt"; "svelte"="Svelte"; "@sveltejs/kit"="SvelteKit"; "solid-js"="Solid"; "astro"="Astro"; "@angular/core"="Angular" }
+        $backendMap = @{ "express"="Express"; "fastify"="Fastify"; "@nestjs/core"="NestJS"; "koa"="Koa"; "hono"="Hono" }
+        $testMap = @{ "jest"="Jest"; "vitest"="Vitest"; "mocha"="Mocha"; "@playwright/test"="Playwright"; "cypress"="Cypress"; "@testing-library/react"="Testing Library" }
+        $dbMap = @{ "prisma"="Prisma"; "typeorm"="TypeORM"; "sequelize"="Sequelize"; "mongoose"="Mongoose"; "drizzle-orm"="Drizzle"; "pg"="PostgreSQL"; "mysql2"="MySQL"; "mongodb"="MongoDB"; "redis"="Redis"; "ioredis"="Redis" }
+        $linterMap = @{ "eslint"="ESLint"; "@biomejs/biome"="Biome"; "tslint"="TSLint" }
+        $formatterMap = @{ "prettier"="Prettier"; "@biomejs/biome"="Biome" }
+
+        foreach ($k in $frontendMap.Keys) { if ($allDeps.ContainsKey($k)) { $findings.frameworks += $frontendMap[$k] } }
+        foreach ($k in $backendMap.Keys) { if ($allDeps.ContainsKey($k)) { $findings.frameworks += $backendMap[$k] } }
+        foreach ($k in $testMap.Keys) { if ($allDeps.ContainsKey($k)) { $findings.test_frameworks += $testMap[$k] } }
+        foreach ($k in $dbMap.Keys) { if ($allDeps.ContainsKey($k)) { $findings.databases += $dbMap[$k] } }
+        foreach ($k in $linterMap.Keys) { if ($allDeps.ContainsKey($k)) { $findings.linters += $linterMap[$k] } }
+        foreach ($k in $formatterMap.Keys) { if ($allDeps.ContainsKey($k)) { $findings.formatters += $formatterMap[$k] } }
+    } catch {
+        Write-Host "[WARN] package.json malformado: $_" -ForegroundColor Yellow
+    }
+}
+
+# ----- Python frameworks -----
+if (Test-File "pyproject.toml") {
+    $content = Get-Content (Join-Path $TargetPath "pyproject.toml") -Raw -ErrorAction SilentlyContinue
+    if ($content -match "fastapi") { $findings.frameworks += "FastAPI" }
+    if ($content -match "django") { $findings.frameworks += "Django" }
+    if ($content -match "flask") { $findings.frameworks += "Flask" }
+    if ($content -match "pytest") { $findings.test_frameworks += "pytest" }
+    if ($content -match "ruff") { $findings.linters += "Ruff" }
+    if ($content -match "black") { $findings.formatters += "Black" }
+    if ($content -match "mypy") { $findings.linters += "mypy" }
+}
+
+# ----- Infra -----
+if (Test-File "Dockerfile") { $findings.infra += "Docker" }
+if ((Test-File "docker-compose.yml") -or (Test-File "docker-compose.yaml")) { $findings.infra += "Docker Compose" }
+if (Test-Dir "terraform") { $findings.infra += "Terraform" }
+if ((Test-Dir "kubernetes") -or (Test-Dir "k8s") -or (Test-Dir "helm")) { $findings.infra += "Kubernetes" }
+if ((Test-File "serverless.yml") -or (Test-File "sam-template.yaml")) { $findings.infra += "Serverless" }
+
+# ----- CI/CD -----
+if (Test-Dir ".github\workflows") { $findings.ci_cd += "GitHub Actions" }
+if (Test-File ".gitlab-ci.yml") { $findings.ci_cd += "GitLab CI" }
+if (Test-File "Jenkinsfile") { $findings.ci_cd += "Jenkins" }
+if (Test-File ".circleci\config.yml") { $findings.ci_cd += "CircleCI" }
+if ((Test-File "azure-pipelines.yml") -or (Test-File "azure-pipelines.yaml")) { $findings.ci_cd += "Azure Pipelines" }
+
+# ----- Configs detectados -----
+if (Test-File ".editorconfig") { $findings.formatters += "EditorConfig" }
+if ((Test-File ".prettierrc") -or (Test-File ".prettierrc.json") -or (Test-File "prettier.config.js")) {
+    if ($findings.formatters -notcontains "Prettier") { $findings.formatters += "Prettier" }
+}
+if ((Test-File ".eslintrc") -or (Test-File ".eslintrc.json") -or (Test-File "eslint.config.js")) {
+    if ($findings.linters -notcontains "ESLint") { $findings.linters += "ESLint" }
+}
+
+# ----- Smells -----
+if ((Test-File ".env") -and -not (Test-File ".gitignore")) {
+    $findings.smells += "Possivel commit de .env (sem .gitignore)"
+} elseif (Test-File ".env") {
+    $gitignore = Get-Content (Join-Path $TargetPath ".gitignore") -Raw -ErrorAction SilentlyContinue
+    if ($gitignore -and $gitignore -notmatch "\.env") {
+        $findings.smells += ".env nao esta no .gitignore"
+    }
+}
+
+if (Test-Dir "node_modules") {
+    $gitignore = Get-Content (Join-Path $TargetPath ".gitignore") -Raw -ErrorAction SilentlyContinue
+    if ($gitignore -and $gitignore -notmatch "node_modules") {
+        $findings.smells += "node_modules nao esta no .gitignore"
+    }
+}
+
+if ($findings.test_frameworks.Count -eq 0 -and $findings.languages.Count -gt 0) {
+    $findings.smells += "Nenhum framework de teste detectado"
+}
+
+if ($findings.ci_cd.Count -eq 0 -and $findings.languages.Count -gt 0) {
+    $findings.smells += "Nenhuma config de CI/CD detectada"
+}
+
+if (-not (Test-File "README.md")) {
+    $findings.smells += "README.md ausente"
+}
+
+# Dedup
+foreach ($k in @("languages","frameworks","databases","infra","ci_cd","test_frameworks","linters","formatters","smells")) {
+    if ($findings[$k]) { $findings[$k] = @($findings[$k] | Sort-Object -Unique) }
+}
+
+# ----- Output -----
+$json = $findings | ConvertTo-Json -Depth 5
+Write-Host ""
+Write-Host "----- Stack Detection Report -----" -ForegroundColor Cyan
+Write-Host $json
+Write-Host "----------------------------------" -ForegroundColor Cyan
+
+if ($OutputPath) {
+    $json | Out-File -FilePath $OutputPath -Encoding utf8
+    Write-Host ""
+    Write-Host "Relatorio salvo em: $OutputPath" -ForegroundColor Green
+}
+
+# Salvar tambem em .ai/memory/_detected-stack.json para o agente consumir
+$autoOut = Join-Path $TargetPath ".ai\memory\_detected-stack.json"
+if (Test-Path (Join-Path $TargetPath ".ai\memory")) {
+    $json | Out-File -FilePath $autoOut -Encoding utf8
+    Write-Host "Cache salvo em: $autoOut" -ForegroundColor Green
+}

package/ai/scripts/detect-stack.sh

@@ -0,0 +1,172 @@
+#!/usr/bin/env bash
+# detect-stack.sh - Inspeciona projeto e produz relatorio JSON (macOS/Linux)
+set -euo pipefail
+
+TARGET="$(pwd)"
+OUTPUT=""
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --target) TARGET="$2"; shift 2 ;;
+        --output) OUTPUT="$2"; shift 2 ;;
+        *) echo "Arg desconhecido: $1" >&2; exit 1 ;;
+    esac
+done
+
+has_file() { [[ -f "$TARGET/$1" ]]; }
+has_dir() { [[ -d "$TARGET/$1" ]]; }
+file_grep() { [[ -f "$TARGET/$1" ]] && grep -q "$2" "$TARGET/$1" 2>/dev/null; }
+
+# Arrays
+declare -a LANGS=()
+declare -a FRAMEWORKS=()
+declare -a DBS=()
+declare -a INFRA=()
+declare -a CI=()
+declare -a TESTS=()
+declare -a LINTERS=()
+declare -a FORMATTERS=()
+declare -a SMELLS=()
+PKG_MGR=""
+
+# Linguagens
+has_file "package.json" && LANGS+=("JavaScript/Node.js")
+has_file "tsconfig.json" && LANGS+=("TypeScript")
+{ has_file "pyproject.toml" || has_file "requirements.txt" || has_file "setup.py"; } && LANGS+=("Python")
+has_file "Cargo.toml" && LANGS+=("Rust")
+has_file "go.mod" && LANGS+=("Go")
+{ has_file "pom.xml" || has_file "build.gradle" || has_file "build.gradle.kts"; } && LANGS+=("Java/Kotlin/JVM")
+has_file "composer.json" && LANGS+=("PHP")
+has_file "Gemfile" && LANGS+=("Ruby")
+has_file "mix.exs" && LANGS+=("Elixir")
+has_file "pubspec.yaml" && LANGS+=("Dart/Flutter")
+ls "$TARGET"/*.csproj 2>/dev/null | head -1 >/dev/null 2>&1 && LANGS+=(".NET (C#)")
+
+# Package manager
+has_file "pnpm-lock.yaml" && PKG_MGR="pnpm"
+[[ -z "$PKG_MGR" ]] && has_file "yarn.lock" && PKG_MGR="yarn"
+[[ -z "$PKG_MGR" ]] && has_file "package-lock.json" && PKG_MGR="npm"
+[[ -z "$PKG_MGR" ]] && has_file "bun.lockb" && PKG_MGR="bun"
+[[ -z "$PKG_MGR" ]] && has_file "poetry.lock" && PKG_MGR="poetry"
+[[ -z "$PKG_MGR" ]] && has_file "Pipfile.lock" && PKG_MGR="pipenv"
+[[ -z "$PKG_MGR" ]] && has_file "Cargo.lock" && PKG_MGR="cargo"
+
+# Frameworks via package.json
+if has_file "package.json"; then
+    PKG="$TARGET/package.json"
+    grep -q '"react"' "$PKG" && FRAMEWORKS+=("React")
+    grep -q '"next"' "$PKG" && FRAMEWORKS+=("Next.js")
+    grep -q '"vue"' "$PKG" && FRAMEWORKS+=("Vue")
+    grep -q '"nuxt"' "$PKG" && FRAMEWORKS+=("Nuxt")
+    grep -q '"svelte"' "$PKG" && FRAMEWORKS+=("Svelte")
+    grep -q '"@sveltejs/kit"' "$PKG" && FRAMEWORKS+=("SvelteKit")
+    grep -q '"solid-js"' "$PKG" && FRAMEWORKS+=("Solid")
+    grep -q '"astro"' "$PKG" && FRAMEWORKS+=("Astro")
+    grep -q '"@angular/core"' "$PKG" && FRAMEWORKS+=("Angular")
+    grep -q '"express"' "$PKG" && FRAMEWORKS+=("Express")
+    grep -q '"fastify"' "$PKG" && FRAMEWORKS+=("Fastify")
+    grep -q '"@nestjs/core"' "$PKG" && FRAMEWORKS+=("NestJS")
+    grep -q '"koa"' "$PKG" && FRAMEWORKS+=("Koa")
+    grep -q '"hono"' "$PKG" && FRAMEWORKS+=("Hono")
+    grep -q '"jest"' "$PKG" && TESTS+=("Jest")
+    grep -q '"vitest"' "$PKG" && TESTS+=("Vitest")
+    grep -q '"mocha"' "$PKG" && TESTS+=("Mocha")
+    grep -q '"@playwright/test"' "$PKG" && TESTS+=("Playwright")
+    grep -q '"cypress"' "$PKG" && TESTS+=("Cypress")
+    grep -q '"@testing-library/react"' "$PKG" && TESTS+=("Testing Library")
+    grep -q '"prisma"' "$PKG" && DBS+=("Prisma")
+    grep -q '"typeorm"' "$PKG" && DBS+=("TypeORM")
+    grep -q '"sequelize"' "$PKG" && DBS+=("Sequelize")
+    grep -q '"mongoose"' "$PKG" && DBS+=("Mongoose")
+    grep -q '"drizzle-orm"' "$PKG" && DBS+=("Drizzle")
+    grep -q '"pg"' "$PKG" && DBS+=("PostgreSQL")
+    grep -q '"mysql2"' "$PKG" && DBS+=("MySQL")
+    grep -q '"mongodb"' "$PKG" && DBS+=("MongoDB")
+    grep -q '"redis"\|"ioredis"' "$PKG" && DBS+=("Redis")
+    grep -q '"eslint"' "$PKG" && LINTERS+=("ESLint")
+    grep -q '"@biomejs/biome"' "$PKG" && { LINTERS+=("Biome"); FORMATTERS+=("Biome"); }
+    grep -q '"prettier"' "$PKG" && FORMATTERS+=("Prettier")
+fi
+
+# Python frameworks
+if has_file "pyproject.toml"; then
+    file_grep "pyproject.toml" "fastapi" && FRAMEWORKS+=("FastAPI")
+    file_grep "pyproject.toml" "django" && FRAMEWORKS+=("Django")
+    file_grep "pyproject.toml" "flask" && FRAMEWORKS+=("Flask")
+    file_grep "pyproject.toml" "pytest" && TESTS+=("pytest")
+    file_grep "pyproject.toml" "ruff" && LINTERS+=("Ruff")
+    file_grep "pyproject.toml" "black" && FORMATTERS+=("Black")
+    file_grep "pyproject.toml" "mypy" && LINTERS+=("mypy")
+fi
+
+# Infra
+has_file "Dockerfile" && INFRA+=("Docker")
+{ has_file "docker-compose.yml" || has_file "docker-compose.yaml"; } && INFRA+=("Docker Compose")
+has_dir "terraform" && INFRA+=("Terraform")
+{ has_dir "kubernetes" || has_dir "k8s" || has_dir "helm"; } && INFRA+=("Kubernetes")
+{ has_file "serverless.yml" || has_file "sam-template.yaml"; } && INFRA+=("Serverless")
+
+# CI/CD
+has_dir ".github/workflows" && CI+=("GitHub Actions")
+has_file ".gitlab-ci.yml" && CI+=("GitLab CI")
+has_file "Jenkinsfile" && CI+=("Jenkins")
+has_file ".circleci/config.yml" && CI+=("CircleCI")
+{ has_file "azure-pipelines.yml" || has_file "azure-pipelines.yaml"; } && CI+=("Azure Pipelines")
+
+# Configs
+has_file ".editorconfig" && FORMATTERS+=("EditorConfig")
+{ has_file ".prettierrc" || has_file ".prettierrc.json" || has_file "prettier.config.js"; } && FORMATTERS+=("Prettier")
+{ has_file ".eslintrc" || has_file ".eslintrc.json" || has_file "eslint.config.js"; } && LINTERS+=("ESLint")
+
+# Smells
+if has_file ".env" && has_file ".gitignore" && ! grep -q '\.env' "$TARGET/.gitignore"; then
+    SMELLS+=(".env nao esta no .gitignore")
+fi
+if has_dir "node_modules" && has_file ".gitignore" && ! grep -q "node_modules" "$TARGET/.gitignore"; then
+    SMELLS+=("node_modules nao esta no .gitignore")
+fi
+[[ ${#TESTS[@]} -eq 0 && ${#LANGS[@]} -gt 0 ]] && SMELLS+=("Nenhum framework de teste detectado")
+[[ ${#CI[@]} -eq 0 && ${#LANGS[@]} -gt 0 ]] && SMELLS+=("Nenhuma config de CI/CD detectada")
+! has_file "README.md" && SMELLS+=("README.md ausente")
+
+# Dedup helper
+dedup_join() {
+    local IFS=$'\n'
+    local sorted=($(printf "%s\n" "$@" | awk '!x[$0]++'))
+    local first=1
+    printf "["
+    for s in "${sorted[@]}"; do
+        [[ $first -eq 0 ]] && printf ","
+        printf '"%s"' "$s"
+        first=0
+    done
+    printf "]"
+}
+
+DATE=$(date "+%Y-%m-%d %H:%M:%S")
+JSON=$(cat <<EOF
+{
+  "detected_at": "$DATE",
+  "target": "$TARGET",
+  "languages": $(dedup_join "${LANGS[@]:-}"),
+  "frameworks": $(dedup_join "${FRAMEWORKS[@]:-}"),
+  "databases": $(dedup_join "${DBS[@]:-}"),
+  "infra": $(dedup_join "${INFRA[@]:-}"),
+  "ci_cd": $(dedup_join "${CI[@]:-}"),
+  "test_frameworks": $(dedup_join "${TESTS[@]:-}"),
+  "linters": $(dedup_join "${LINTERS[@]:-}"),
+  "formatters": $(dedup_join "${FORMATTERS[@]:-}"),
+  "package_manager": "$PKG_MGR",
+  "smells": $(dedup_join "${SMELLS[@]:-}")
+}
+EOF
+)
+
+echo "----- Stack Detection Report -----"
+echo "$JSON"
+echo "----------------------------------"
+
+[[ -n "$OUTPUT" ]] && echo "$JSON" > "$OUTPUT" && echo "Salvo em: $OUTPUT"
+
+AUTO_OUT="$TARGET/.ai/memory/_detected-stack.json"
+[[ -d "$TARGET/.ai/memory" ]] && echo "$JSON" > "$AUTO_OUT" && echo "Cache: $AUTO_OUT"

package/ai/scripts/init-ai-os.ps1

@@ -0,0 +1,170 @@
+# init-ai-os.ps1
+# Inicializa ou verifica o AI Operating System em um projeto.
+# Uso:
+#   .\scripts\init-ai-os.ps1                    # interativo
+#   .\scripts\init-ai-os.ps1 -Mode new          # forca novo
+#   .\scripts\init-ai-os.ps1 -Mode existing     # forca existente
+#   .\scripts\init-ai-os.ps1 -Verify            # so verifica integridade
+#   .\scripts\init-ai-os.ps1 -TargetPath C:\path\to\project
+
+param(
+    [ValidateSet("auto", "new", "existing", "verify")]
+    [string]$Mode = "auto",
+
+    [string]$TargetPath = (Get-Location).Path,
+
+    [string]$TemplateRoot = (Split-Path (Split-Path $PSScriptRoot -Parent) -Parent),
+
+    [switch]$Verify
+)
+
+if ($Verify) { $Mode = "verify" }
+
+$ErrorActionPreference = "Stop"
+
+function Write-Section($text) {
+    Write-Host ""
+    Write-Host "=== $text ===" -ForegroundColor Cyan
+}
+
+function Write-Ok($text) { Write-Host "[OK] $text" -ForegroundColor Green }
+function Write-Warn($text) { Write-Host "[WARN] $text" -ForegroundColor Yellow }
+function Write-Err($text) { Write-Host "[ERR] $text" -ForegroundColor Red }
+
+# ----- Detect mode if auto -----
+function Get-ProjectMode {
+    param([string]$Path)
+
+    $aiExists = Test-Path (Join-Path $Path ".ai")
+    $hasCode = @(
+        "package.json", "pyproject.toml", "requirements.txt", "Cargo.toml",
+        "go.mod", "pom.xml", "build.gradle", "composer.json", "Gemfile",
+        "mix.exs", "pubspec.yaml"
+    ) | Where-Object { Test-Path (Join-Path $Path $_) }
+
+    if ($aiExists) { return "verify" }
+    if ($hasCode.Count -gt 0) { return "existing" }
+    return "new"
+}
+
+if ($Mode -eq "auto") {
+    $Mode = Get-ProjectMode -Path $TargetPath
+    Write-Host "Modo detectado: $Mode"
+}
+
+# ----- VERIFY MODE -----
+if ($Mode -eq "verify") {
+    Write-Section "Verificando integridade do AI OS em $TargetPath"
+
+    $manifestPath = Join-Path $TargetPath ".ai\manifest.json"
+    if (-not (Test-Path $manifestPath)) {
+        Write-Err "manifest.json nao encontrado em .ai/. OS pode estar quebrado."
+        exit 1
+    }
+
+    $manifest = Get-Content $manifestPath -Raw | ConvertFrom-Json
+    $missing = @()
+    foreach ($f in $manifest.required_files) {
+        $full = Join-Path $TargetPath ($f -replace '/', '\')
+        if (-not (Test-Path $full)) {
+            $missing += $f
+        }
+    }
+
+    if ($missing.Count -eq 0) {
+        Write-Ok "Todos os $($manifest.required_files.Count) arquivos obrigatorios presentes."
+    } else {
+        Write-Err "$($missing.Count) arquivos faltando:"
+        $missing | ForEach-Object { Write-Host "  - $_" }
+        exit 1
+    }
+
+    # Link lint
+    Write-Section "Validando links cruzados"
+    & (Join-Path $PSScriptRoot "lint-os.ps1") -TargetPath $TargetPath
+    exit $LASTEXITCODE
+}
+
+# ----- NEW MODE -----
+if ($Mode -eq "new") {
+    Write-Section "Bootstrap: projeto NOVO em $TargetPath"
+
+    if (Test-Path (Join-Path $TargetPath ".ai")) {
+        Write-Warn ".ai/ ja existe. Use -Mode verify para checar integridade ou -Mode existing para retrofit."
+        exit 1
+    }
+
+    # Copia template
+    $templateAi = Join-Path $TemplateRoot ".ai"
+    $templateClaude = Join-Path $TemplateRoot ".claude"
+    $templateEntries = @("CLAUDE.md", "GEMINI.md", "GPT.md")
+
+    if (-not (Test-Path $templateAi)) {
+        Write-Err "Template .ai/ nao encontrado em $TemplateRoot. Rode este script a partir do diretorio raiz do template."
+        exit 1
+    }
+
+    Copy-Item $templateAi (Join-Path $TargetPath ".ai") -Recurse
+    Write-Ok "Estrutura .ai/ copiada."
+
+    if (Test-Path $templateClaude) {
+        Copy-Item $templateClaude (Join-Path $TargetPath ".claude") -Recurse
+        Write-Ok "Hooks .claude/ copiados."
+    }
+
+    foreach ($entry in $templateEntries) {
+        $src = Join-Path $TemplateRoot $entry
+        $dst = Join-Path $TargetPath $entry
+        if ((Test-Path $src) -and -not (Test-Path $dst)) {
+            Copy-Item $src $dst
+            Write-Ok "Entry point $entry copiado."
+        }
+    }
+
+    Write-Host ""
+    Write-Host "Proximo passo: abra Claude Code / Gemini / GPT neste diretorio."
+    Write-Host "O agente seguira o fluxo de bootstrap/new-project.md automaticamente."
+    exit 0
+}
+
+# ----- EXISTING MODE -----
+if ($Mode -eq "existing") {
+    Write-Section "Bootstrap: projeto EXISTENTE em $TargetPath"
+
+    if (-not (Test-Path (Join-Path $TargetPath ".ai"))) {
+        # Copia o template
+        $templateAi = Join-Path $TemplateRoot ".ai"
+        if (-not (Test-Path $templateAi)) {
+            Write-Err "Template .ai/ nao encontrado em $TemplateRoot."
+            exit 1
+        }
+        Copy-Item $templateAi (Join-Path $TargetPath ".ai") -Recurse
+        Write-Ok "Estrutura .ai/ enxertada no projeto."
+
+        $templateClaude = Join-Path $TemplateRoot ".claude"
+        if (Test-Path $templateClaude) {
+            Copy-Item $templateClaude (Join-Path $TargetPath ".claude") -Recurse
+            Write-Ok "Hooks .claude/ enxertados."
+        }
+
+        @("CLAUDE.md", "GEMINI.md", "GPT.md") | ForEach-Object {
+            $src = Join-Path $TemplateRoot $_
+            $dst = Join-Path $TargetPath $_
+            if ((Test-Path $src) -and -not (Test-Path $dst)) {
+                Copy-Item $src $dst
+                Write-Ok "Entry point $_ enxertado."
+            }
+        }
+    } else {
+        Write-Ok ".ai/ ja existe — pulando copia."
+    }
+
+    # Detectar stack e gerar pre-fill de project-context.md
+    Write-Section "Detectando stack do projeto"
+    & (Join-Path $PSScriptRoot "detect-stack.ps1") -TargetPath $TargetPath
+    Write-Host ""
+    Write-Host "Proximo passo: abra Claude Code / Gemini / GPT neste diretorio."
+    Write-Host "O agente seguira o fluxo de bootstrap/existing-project.md."
+    Write-Host "Ele vai validar a deteccao com voce e completar o que falta via discovery-questions."
+    exit 0
+}

package/ai/scripts/init-ai-os.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+# init-ai-os.sh - Equivalente Unix do init-ai-os.ps1
+# Uso:
+#   ./scripts/init-ai-os.sh                       # auto
+#   ./scripts/init-ai-os.sh --mode new
+#   ./scripts/init-ai-os.sh --mode existing
+#   ./scripts/init-ai-os.sh --verify
+#   ./scripts/init-ai-os.sh --target /path/to/project
+
+set -euo pipefail
+
+MODE="auto"
+TARGET="$(pwd)"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TEMPLATE_ROOT="$(dirname "$(dirname "$SCRIPT_DIR")")"
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --mode) MODE="$2"; shift 2 ;;
+        --target) TARGET="$2"; shift 2 ;;
+        --verify) MODE="verify"; shift ;;
+        --template-root) TEMPLATE_ROOT="$2"; shift 2 ;;
+        *) echo "Arg desconhecido: $1"; exit 1 ;;
+    esac
+done
+
+c_cyan='\033[0;36m'; c_green='\033[0;32m'; c_yellow='\033[0;33m'; c_red='\033[0;31m'; c_reset='\033[0m'
+section() { echo -e "\n${c_cyan}=== $1 ===${c_reset}"; }
+ok() { echo -e "${c_green}[OK]${c_reset} $1"; }
+warn() { echo -e "${c_yellow}[WARN]${c_reset} $1"; }
+err() { echo -e "${c_red}[ERR]${c_reset} $1"; }
+
+detect_mode() {
+    [[ -d "$TARGET/.ai" ]] && { echo "verify"; return; }
+    for f in package.json pyproject.toml requirements.txt Cargo.toml go.mod pom.xml build.gradle composer.json Gemfile mix.exs pubspec.yaml; do
+        [[ -f "$TARGET/$f" ]] && { echo "existing"; return; }
+    done
+    echo "new"
+}
+
+if [[ "$MODE" == "auto" ]]; then
+    MODE=$(detect_mode)
+    echo "Modo detectado: $MODE"
+fi
+
+case "$MODE" in
+    verify)
+        section "Verificando integridade em $TARGET"
+        [[ -f "$TARGET/.ai/manifest.json" ]] || { err "manifest.json ausente"; exit 1; }
+        # Requer jq
+        if ! command -v jq &>/dev/null; then
+            warn "jq nao instalado — pulando validacao detalhada"
+            exit 0
+        fi
+        missing=()
+        while IFS= read -r f; do
+            [[ -e "$TARGET/$f" ]] || missing+=("$f")
+        done < <(jq -r '.required_files[]' "$TARGET/.ai/manifest.json")
+        if [[ ${#missing[@]} -eq 0 ]]; then
+            ok "Todos os arquivos obrigatorios presentes."
+        else
+            err "Faltando: ${missing[*]}"
+            exit 1
+        fi
+        ;;
+
+    new)
+        section "Bootstrap: projeto NOVO em $TARGET"
+        [[ -d "$TARGET/.ai" ]] && { warn ".ai/ ja existe"; exit 1; }
+        [[ -d "$TEMPLATE_ROOT/.ai" ]] || { err "template .ai/ ausente em $TEMPLATE_ROOT"; exit 1; }
+        cp -r "$TEMPLATE_ROOT/.ai" "$TARGET/.ai" && ok ".ai/ copiado"
+        [[ -d "$TEMPLATE_ROOT/.claude" ]] && cp -r "$TEMPLATE_ROOT/.claude" "$TARGET/.claude" && ok ".claude/ copiado"
+        for e in CLAUDE.md GEMINI.md GPT.md; do
+            [[ -f "$TEMPLATE_ROOT/$e" && ! -f "$TARGET/$e" ]] && cp "$TEMPLATE_ROOT/$e" "$TARGET/$e" && ok "$e copiado"
+        done
+        echo "Proximo passo: abra Claude Code/Gemini/GPT — o agente seguira bootstrap/new-project.md."
+        ;;
+
+    existing)
+        section "Bootstrap: projeto EXISTENTE em $TARGET"
+        if [[ ! -d "$TARGET/.ai" ]]; then
+            cp -r "$TEMPLATE_ROOT/.ai" "$TARGET/.ai" && ok ".ai/ enxertado"
+            [[ -d "$TEMPLATE_ROOT/.claude" ]] && cp -r "$TEMPLATE_ROOT/.claude" "$TARGET/.claude" && ok ".claude/ enxertado"
+            for e in CLAUDE.md GEMINI.md GPT.md; do
+                [[ -f "$TEMPLATE_ROOT/$e" && ! -f "$TARGET/$e" ]] && cp "$TEMPLATE_ROOT/$e" "$TARGET/$e" && ok "$e enxertado"
+            done
+        else
+            ok ".ai/ ja existe"
+        fi
+        section "Detectando stack"
+        [[ -x "$SCRIPT_DIR/detect-stack.sh" ]] && "$SCRIPT_DIR/detect-stack.sh" --target "$TARGET" || warn "detect-stack.sh nao encontrado/executavel (use a versao .ps1 ou crie equivalente)"
+        echo "Proximo passo: abra Claude Code/Gemini/GPT — o agente seguira bootstrap/existing-project.md."
+        ;;
+
+    *)
+        err "Modo invalido: $MODE"
+        exit 1
+        ;;
+esac