legacy-squad 1.2.0 → 1.3.0

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 
 // apps/cli/src/index.ts
 import { Command } from "commander";
-import path9 from "node:path";
+import path10 from "node:path";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
@@ -1318,7 +1318,7 @@ var Installer = class {
       mode: { execution: "read_only" },
       ide: { primary: "claude-code" },
       installed_at: (/* @__PURE__ */ new Date()).toISOString(),
-      framework_version: "1.2.0"
+      framework_version: "1.3.0"
     };
     await writeFile2(
       path7.join(configDir, "project.yaml"),
@@ -1328,9 +1328,11 @@ var Installer = class {
     await mkdir2(path7.join(effectiveRoot, ".legacy-squad", "outputs", "reports"), { recursive: true });
     await mkdir2(path7.join(effectiveRoot, ".legacy-squad", "outputs", "assessments"), { recursive: true });
     await mkdir2(path7.join(effectiveRoot, ".legacy-squad", "logs"), { recursive: true });
-    const claudeCommandsDir = path7.join(effectiveRoot, ".claude", "commands", "legacy-squad");
+    const claudeCommandsRoot = path7.join(effectiveRoot, ".claude", "commands");
+    const claudeCommandsDir = path7.join(claudeCommandsRoot, "legacy-squad");
     await mkdir2(claudeCommandsDir, { recursive: true });
     await this.copySlashCommands(templateDir, claudeCommandsDir);
+    await this.copyOrchestrator(templateDir, claudeCommandsRoot);
     await this.generateAgentsMd(effectiveRoot, repoIndex.project.name);
     const logContent = [
       `Legacy Squad Framework \u2014 Install Log`,
@@ -1390,6 +1392,21 @@ var Installer = class {
       }
     }
   }
+  /**
+   * DA-012: copia o template do orchestrator para `.claude/commands/legacy-squad.md`
+   * (raiz de commands, não subdir). No Claude Code, arquivos na raiz de commands viram
+   * o comando puro `/<filename>` — então este caminho expressa `/legacy-squad` (validado
+   * emp.). Falha silenciosamente se o template não existir, no mesmo estilo de copySlashCommands.
+   */
+  async copyOrchestrator(templateDir, commandsRoot) {
+    const sourcePath = path7.join(templateDir, "legacy-squad.md");
+    const targetPath = path7.join(commandsRoot, "legacy-squad.md");
+    try {
+      const content = await readFile2(sourcePath, "utf-8");
+      await writeFile2(targetPath, content, "utf-8");
+    } catch {
+    }
+  }
   async generateAgentsMd(projectRoot, projectName) {
     const lines = [
       `# Legacy Squad Agents \u2014 ${projectName}`,
@@ -1442,6 +1459,7 @@ var Doctor = class {
     checks.push(await this.checkFile(projectRoot, ".legacy-squad/memory/context-packs.json", "Context Packs"));
     checks.push(await this.checkFile(projectRoot, ".legacy-squad/config/project.yaml", "Project Config"));
     checks.push(await this.checkDir(projectRoot, ".claude/commands/legacy-squad", "Claude Code Agents"));
+    checks.push(await this.checkFile(projectRoot, ".claude/commands/legacy-squad.md", "Orchestrator /legacy-squad"));
     checks.push(await this.checkFile(projectRoot, "AGENTS.md", "Codex AGENTS.md"));
     checks.push(await this.checkDir(projectRoot, ".legacy-squad/outputs/assessments", "Assessments Dir"));
     checks.push(await this.checkDir(projectRoot, ".legacy-squad/outputs/reports", "Reports Dir"));
@@ -1507,19 +1525,281 @@ var Doctor = class {
   }
 };
 
+// packages/agents/src/lifecycle-detector.ts
+import path9 from "node:path";
+var REPO_INDEX_PATH = ".legacy-squad/memory/repo-index.json";
+var FINDINGS_INDEX_PATH = ".legacy-squad/memory/findings/index.json";
+var assessmentPath = (slug) => `.legacy-squad/outputs/assessments/${slug}-assessment.md`;
+var PRS_PATH = ".legacy-squad/outputs/reports/PRS.md";
+var SDD_PATH = ".legacy-squad/outputs/sdd/SDD.md";
+var MMP_PATH = ".legacy-squad/outputs/mmp/MMP.md";
+var SPECS_PATH = ".legacy-squad/outputs/specs/INDEX.md";
+var MATURITY_LABELS = {
+  1: "Unknown",
+  2: "Understood",
+  3: "Assessed",
+  4: "Planned",
+  5: "Modernization Ready",
+  6: "Continuously Modernized"
+};
+var STEPS = [
+  {
+    id: "scan",
+    label: "Scan",
+    command: null,
+    phase: "discovery",
+    target: REPO_INDEX_PATH,
+    reason: "Rode `npx legacy-squad install` para escanear o projeto e gerar o repo-index."
+  },
+  {
+    id: "security",
+    label: "Security assessment",
+    command: "/legacy-squad:security",
+    phase: "assessment",
+    target: assessmentPath("security"),
+    reason: "Inicie os assessments rodando `/legacy-squad:security`."
+  },
+  {
+    id: "architecture",
+    label: "Architecture assessment",
+    command: "/legacy-squad:architecture",
+    phase: "assessment",
+    target: assessmentPath("architecture"),
+    reason: "Rode `/legacy-squad:architecture`."
+  },
+  {
+    id: "legacy-code",
+    label: "Legacy code assessment",
+    command: "/legacy-squad:legacy-code",
+    phase: "assessment",
+    target: assessmentPath("legacy-code"),
+    reason: "Rode `/legacy-squad:legacy-code`."
+  },
+  {
+    id: "business-rules",
+    label: "Business rules assessment",
+    command: "/legacy-squad:business-rules",
+    phase: "assessment",
+    target: assessmentPath("business-rules"),
+    reason: "Rode `/legacy-squad:business-rules`."
+  },
+  {
+    id: "modernization",
+    label: "Modernization assessment",
+    command: "/legacy-squad:modernization",
+    phase: "assessment",
+    target: assessmentPath("modernization"),
+    reason: "Rode `/legacy-squad:modernization`."
+  },
+  {
+    id: "generate-prs",
+    label: "PRS",
+    command: "/legacy-squad:generate-prs",
+    phase: "assessment",
+    target: PRS_PATH,
+    reason: "Consolide o diagn\xF3stico com `/legacy-squad:generate-prs`."
+  },
+  {
+    id: "generate-sdd",
+    label: "SDD",
+    command: "/legacy-squad:generate-sdd",
+    phase: "design",
+    target: SDD_PATH,
+    reason: "Gere o desenho t\xE9cnico com `/legacy-squad:generate-sdd`."
+  },
+  {
+    id: "generate-mmp",
+    label: "MMP",
+    command: "/legacy-squad:generate-mmp",
+    phase: "planning",
+    target: MMP_PATH,
+    reason: "Gere o plano mestre com `/legacy-squad:generate-mmp`."
+  },
+  {
+    id: "generate-specs",
+    label: "Execution Specs",
+    command: "/legacy-squad:generate-specs",
+    phase: "execution",
+    target: SPECS_PATH,
+    reason: "Decomponha em specs com `/legacy-squad:generate-specs`."
+  }
+];
+var PHASE_ORDER = [
+  { id: "discovery", label: "Discovery" },
+  { id: "assessment", label: "Assessment" },
+  { id: "design", label: "Design" },
+  { id: "planning", label: "Planning" },
+  { id: "execution", label: "Execution" }
+];
+var ASSESSMENT_STEP_IDS = [
+  "security",
+  "architecture",
+  "legacy-code",
+  "business-rules",
+  "modernization"
+];
+var LifecycleDetector = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  /** Detecta e retorna o snapshot determinístico do lifecycle em `projectRoot`. */
+  async detect(projectRoot) {
+    const done = /* @__PURE__ */ new Map();
+    for (const step of STEPS) {
+      done.set(step.id, await this.fs.exists(path9.join(projectRoot, step.target)));
+    }
+    const installed = done.get("scan") === true;
+    const project = installed ? await this.readProject(projectRoot) : null;
+    const findingCount = installed ? await this.readFindingCount(projectRoot) : 0;
+    const maturityLevel = this.computeMaturity(done);
+    return {
+      project,
+      installed,
+      findingCount,
+      maturityLevel,
+      maturityLabel: MATURITY_LABELS[maturityLevel],
+      phases: this.buildPhases(done),
+      nextStep: this.computeNextStep(done),
+      complete: done.get("generate-specs") === true
+    };
+  }
+  /** Agrupa os passos por fase, calculando a contagem de concluídos. */
+  buildPhases(done) {
+    return PHASE_ORDER.map(({ id, label }) => {
+      const steps = STEPS.filter((s) => s.phase === id).map((s) => ({
+        id: s.id,
+        label: s.label,
+        command: s.command,
+        done: done.get(s.id) === true
+      }));
+      return {
+        id,
+        label,
+        steps,
+        doneCount: steps.filter((s) => s.done).length,
+        totalCount: steps.length
+      };
+    });
+  }
+  /** Deriva o Maturity Level (§10) a partir dos artefatos presentes. */
+  computeMaturity(done) {
+    if (done.get("generate-specs")) return 5;
+    if (done.get("generate-mmp")) return 4;
+    if (ASSESSMENT_STEP_IDS.every((id) => done.get(id))) return 3;
+    if (done.get("scan")) return 2;
+    return 1;
+  }
+  /** Próximo passo = primeiro `target` ausente na ordem canônica; null se tudo concluído. */
+  computeNextStep(done) {
+    const [scanStep] = STEPS;
+    if (!done.get("scan")) {
+      return { id: "install", command: null, reason: scanStep.reason };
+    }
+    for (const step of STEPS) {
+      if (!done.get(step.id)) {
+        return { id: step.id, command: step.command, reason: step.reason };
+      }
+    }
+    return null;
+  }
+  /** Lê nome, tipo e stack do repo-index; null se ausente ou ilegível. */
+  async readProject(root) {
+    try {
+      const raw = await this.fs.readFile(path9.join(root, REPO_INDEX_PATH));
+      const idx = JSON.parse(raw);
+      return {
+        name: idx.project?.name ?? "unknown",
+        type: idx.project?.type ?? "unknown",
+        stack: (idx.stack ?? []).map((s) => s.name ?? "").filter((n) => n.length > 0)
+      };
+    } catch {
+      return null;
+    }
+  }
+  /** Conta os achados no index slim (DA-011); 0 se ausente ou ilegível. */
+  async readFindingCount(root) {
+    try {
+      const raw = await this.fs.readFile(path9.join(root, FINDINGS_INDEX_PATH));
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed.length : 0;
+    } catch {
+      return 0;
+    }
+  }
+};
+
+// packages/output/src/dashboard-renderer.ts
+var RULE = "\u2501".repeat(40);
+var STEP_DISPLAY = {
+  scan: "scan",
+  security: "security",
+  architecture: "architecture",
+  "legacy-code": "legacy-code",
+  "business-rules": "business-rules",
+  modernization: "modernization",
+  "generate-prs": "PRS",
+  "generate-sdd": "SDD",
+  "generate-mmp": "MMP",
+  "generate-specs": "Specs"
+};
+var display = (id) => STEP_DISPLAY[id] ?? id;
+function phaseIcon(phase) {
+  if (phase.totalCount > 0 && phase.doneCount === phase.totalCount) return "\u2713";
+  if (phase.doneCount > 0) return "\u25D0";
+  return "\xB7";
+}
+function phaseDetail(phase) {
+  if (phase.steps.length === 1) {
+    return display(phase.steps[0].id);
+  }
+  const names = phase.steps.map((s) => display(s.id)).join(" \xB7 ");
+  return `${phase.doneCount}/${phase.totalCount}   ${names}`;
+}
+var DashboardRenderer = class {
+  render(snapshot) {
+    const lines = [RULE];
+    if (snapshot.project) {
+      const stack = snapshot.project.stack.join(", ");
+      lines.push(`  Legacy Squad \u2014 ${snapshot.project.name}`);
+      lines.push(`  ${snapshot.project.type}${stack ? ` \xB7 ${stack}` : ""}`);
+    } else {
+      lines.push("  Legacy Squad");
+      lines.push("  (framework n\xE3o instalado neste diret\xF3rio)");
+    }
+    lines.push(RULE, "");
+    lines.push(`  Maturity   Level ${snapshot.maturityLevel} \u2014 ${snapshot.maturityLabel}`);
+    lines.push(`  Findings   ${snapshot.findingCount}`, "");
+    const labelWidth = Math.max(...snapshot.phases.map((p) => p.label.length));
+    for (const phase of snapshot.phases) {
+      lines.push(`  ${phaseIcon(phase)} ${phase.label.padEnd(labelWidth)}   ${phaseDetail(phase)}`);
+    }
+    lines.push("");
+    if (snapshot.nextStep) {
+      const target = snapshot.nextStep.command ?? "npx legacy-squad install";
+      lines.push(`  \u2192 Pr\xF3ximo passo: ${target}`);
+      lines.push(`    ${snapshot.nextStep.reason}`);
+    } else {
+      lines.push("  \u2713 Lifecycle V1 completo \u2014 specs prontas para execu\xE7\xE3o.");
+    }
+    lines.push(RULE);
+    return lines.join("\n");
+  }
+};
+
 // apps/cli/src/index.ts
 var program = new Command();
 function getTemplateDir() {
-  const cliDir = path9.dirname(fileURLToPath(import.meta.url));
-  const bundledPath = path9.resolve(cliDir, "templates", "claude-commands");
+  const cliDir = path10.dirname(fileURLToPath(import.meta.url));
+  const bundledPath = path10.resolve(cliDir, "templates", "claude-commands");
   if (existsSync(bundledPath)) return bundledPath;
-  const devPath = path9.resolve(cliDir, "..", "..", "..", "templates", "claude-commands");
+  const devPath = path10.resolve(cliDir, "..", "..", "..", "templates", "claude-commands");
   if (existsSync(devPath)) return devPath;
   throw new Error("Templates not found. Run from the framework root or use the published package.");
 }
-program.name("legacy-squad").description("AI-Powered Legacy Modernization Platform \u2014 Understand. Plan. Modernize.").version("1.2.0");
+program.name("legacy-squad").description("AI-Powered Legacy Modernization Platform \u2014 Understand. Plan. Modernize.").version("1.3.0");
 program.command("install").description("Install Legacy Squad Framework inside the current project").option("-p, --path <dir>", "Project root directory", ".").action(async (opts) => {
-  const projectRoot = path9.resolve(opts.path);
+  const projectRoot = path10.resolve(opts.path);
   const templateDir = getTemplateDir();
   console.log("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
   console.log("  Legacy Squad Framework V1 \u2014 Install");
@@ -1561,21 +1841,21 @@ program.command("install").description("Install Legacy Squad Framework inside th
   console.log("    1. Open Claude Code: claude");
   console.log("");
   console.log("  Analysis (run in order):");
-  console.log("    /legacy-squad-security");
-  console.log("    /legacy-squad-architecture");
-  console.log("    /legacy-squad-legacy-code");
-  console.log("    /legacy-squad-business-rules");
-  console.log("    /legacy-squad-modernization");
+  console.log("    /legacy-squad:security");
+  console.log("    /legacy-squad:architecture");
+  console.log("    /legacy-squad:legacy-code");
+  console.log("    /legacy-squad:business-rules");
+  console.log("    /legacy-squad:modernization");
   console.log("");
   console.log("  Consolidated artifacts (run after analysis):");
-  console.log("    /legacy-squad-generate-prs    (Product Refactor Specification)");
-  console.log("    /legacy-squad-generate-sdd    (Software Design Document)");
-  console.log("    /legacy-squad-generate-mmp    (Modernization Master Plan)");
-  console.log("    /legacy-squad-generate-specs  (Execution Specs for V2)");
+  console.log("    /legacy-squad:generate-prs    (Product Refactor Specification)");
+  console.log("    /legacy-squad:generate-sdd    (Software Design Document)");
+  console.log("    /legacy-squad:generate-mmp    (Modernization Master Plan)");
+  console.log("    /legacy-squad:generate-specs  (Execution Specs for V2)");
   console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n");
 });
 program.command("scan").description("Re-scan the project and update .legacy-squad/memory/").option("-p, --path <dir>", "Project root directory", ".").action(async (opts) => {
-  const projectRoot = path9.resolve(opts.path);
+  const projectRoot = path10.resolve(opts.path);
   console.log(`
 \u{1F50D} Re-scanning: ${projectRoot}
 `);
@@ -1590,18 +1870,18 @@ program.command("scan").description("Re-scan the project and update .legacy-squa
   const compliance = new ComplianceEngine(fs);
   const findings = await compliance.evaluate(effectiveRoot, repoIndex);
   const { mkdir: mkdir3, writeFile: writeFile3 } = await import("node:fs/promises");
-  const memoryDir = path9.join(effectiveRoot, ".legacy-squad", "memory");
+  const memoryDir = path10.join(effectiveRoot, ".legacy-squad", "memory");
   await mkdir3(memoryDir, { recursive: true });
-  await writeFile3(path9.join(memoryDir, "repo-index.json"), JSON.stringify(repoIndex, null, 2), "utf-8");
+  await writeFile3(path10.join(memoryDir, "repo-index.json"), JSON.stringify(repoIndex, null, 2), "utf-8");
   await new FindingsWriter(fs).write(findings, memoryDir);
   console.log(`\u2705 Stack: ${repoIndex.stack.map((s) => s.name).join(", ")}`);
   console.log(`\u{1F4E6} Modules: ${repoIndex.modules.length}`);
   console.log(`\u{1F512} Findings: ${findings.length}`);
-  console.log(`\u{1F4C4} Updated: ${path9.join(effectiveRoot, ".legacy-squad", "memory")}
+  console.log(`\u{1F4C4} Updated: ${path10.join(effectiveRoot, ".legacy-squad", "memory")}
 `);
 });
 program.command("doctor").description("Verify Legacy Squad installation health").option("-p, --path <dir>", "Project root directory", ".").action(async (opts) => {
-  const projectRoot = path9.resolve(opts.path);
+  const projectRoot = path10.resolve(opts.path);
   console.log("\n\u{1FA7A} Legacy Squad Doctor\n");
   const doctor = new Doctor();
   const checks = await doctor.check(projectRoot);
@@ -1618,4 +1898,16 @@ program.command("doctor").description("Verify Legacy Squad installation health")
     console.log("\n\u2705 All checks passed.\n");
   }
 });
+program.command("status").description("Show the project lifecycle dashboard and the recommended next step").option("-p, --path <dir>", "Project root directory", ".").option("--json", "Output the raw lifecycle snapshot as JSON").action(async (opts) => {
+  const projectRoot = path10.resolve(opts.path);
+  const fs = new NodeFileSystem();
+  const snapshot = await new LifecycleDetector(fs).detect(projectRoot);
+  if (opts.json) {
+    console.log(JSON.stringify(snapshot, null, 2));
+    return;
+  }
+  console.log("");
+  console.log(new DashboardRenderer().render(snapshot));
+  console.log("");
+});
 program.parse();

package/dist/templates/claude-commands/legacy-squad.md

@@ -0,0 +1,38 @@
+Você é o **Orchestrator** do Legacy Squad Framework — o ponto de entrada que mostra onde o projeto está no lifecycle (Discovery → Assessment → Design → Planning → Execution) e qual é o próximo passo recomendado, respeitando dependências.
+
+## Passos
+
+1. **Obtenha o estado do lifecycle.** Tente primeiro:
+
+   ```
+   npx legacy-squad status --json
+   ```
+
+   O comando retorna um snapshot determinístico (`LifecycleSnapshot`) com `project`, `installed`, `findingCount`, `maturityLevel`, `phases` e `nextStep`.
+
+2. **Fallback** — se o comando não estiver disponível (ex.: o framework não foi instalado ainda neste projeto), inspecione `.legacy-squad/` diretamente:
+   - `memory/repo-index.json` — projeto instalado (Discovery concluído).
+   - `memory/findings/index.json` — contagem de achados (DA-011).
+   - `outputs/assessments/{security,architecture,legacy-code,business-rules,modernization}-assessment.md` — assessments por pilar.
+   - `outputs/reports/PRS.md`, `outputs/sdd/SDD.md`, `outputs/mmp/MMP.md`, `outputs/specs/INDEX.md` — artefatos.
+
+   Se nada existir, oriente o usuário a rodar `npx legacy-squad install`.
+
+3. **Renderize o dashboard** a partir do JSON. O `status` (sem `--json`) já imprime um dashboard formatado — você pode rodar `npx legacy-squad status` e mostrar a saída ao usuário. Se preferir reorganizar, use os campos do snapshot.
+
+4. **Ofereça o próximo passo.** Leia `snapshot.nextStep`:
+   - Se `nextStep.command` estiver definido, ofereça executá-lo (ex.: "Quer que eu rode `/legacy-squad:security` agora?").
+   - Se `nextStep` for `null`, o lifecycle V1 está completo (Level 5 — Modernization Ready) e as specs estão prontas para execução assistida (V2).
+   - Se `nextStep.id` for `install`, oriente o usuário a rodar `npx legacy-squad install` (você não roda comandos da CLI sem confirmação).
+
+5. **Respeite a ordem canônica** do lifecycle (FRAMEWORK_SPECIFICATION §3): scan → 5 assessments (security, architecture, legacy-code, business-rules, modernization) → PRS → SDD → MMP → Specs. Nunca pule passos: as dependências duras (SDD←architecture-assessment, MMP←modernization-assessment, Specs←MMP) já estão refletidas nessa ordem.
+
+## Output
+
+Não escreva em `.legacy-squad/outputs/`. Este comando é apenas o orchestrator — quem produz artefatos são `/legacy-squad:security`, `/legacy-squad:generate-prs`, etc. Sua função é mostrar o estado e sugerir o próximo passo.
+
+## Restrições
+
+- Não invente progresso: o snapshot é determinístico (calculado em TypeScript a partir da existência de arquivos canônicos). Se um arquivo não existe, o passo não está concluído — não tente "interpretar".
+- Não execute o próximo passo sem confirmação explícita do usuário.
+- O comando `npx legacy-squad status --json` lê o filesystem; ele não modifica nada.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "legacy-squad",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "AI-Powered Legacy Modernization Platform — Install-first, IDE-native, evidence-driven framework that transforms legacy systems into modernization-ready assets.",
   "keywords": [
     "legacy",
@@ -23,7 +23,7 @@
   "homepage": "https://github.com/hrpimenta/legacy-squad",
   "repository": {
     "type": "git",
-    "url": "https://github.com/hrpimenta/legacy-squad.git"
+    "url": "git+https://github.com/hrpimenta/legacy-squad.git"
   },
   "license": "MIT",
   "author": "Legacy Squad Team",
@@ -56,4 +56,4 @@
   "engines": {
     "node": ">=18"
   }
-}
+}