ganbatte-os 0.2.6 → 0.2.8

package/.gos/rules/plan-mode.md

@@ -20,7 +20,10 @@ Ativar **PLAN MODE** automaticamente sempre que o input do usuário envolver **q
 - Git operations: `commit`, `push`, `pull`, `branch`, `merge`, `status`, `log`
 - Leitura e explicação: "o que é", "como funciona", "onde está", "mostre", "explique"
 - Edições simples: 1 arquivo, 1 mudança isolada (ex: corrigir typo, ajustar 1 linha)
+- Correções de lint, typo, formatação, ortografia
 - Quando o usuário inclui: `"só faça"`, `"execute direto"`, `"sem plano"`, `"direto ao ponto"`
+- Comandos de retomada ou continuação: `"continue"`, `"continuar"`, `"retomar"`, `"resume"`, `"prosseguir"`, `"segue"`
+- Aprovações após um plano já apresentado: `"ok"`, `"aprovado"`, `"go"`, `"execute"`, `"pode ir"`, `"sim"`, `"proceed"`
 - Quando plan mode já foi ativado ou aprovado na sessão atual
 
 ---
@@ -37,7 +40,7 @@ Ativar **PLAN MODE** automaticamente sempre que o input do usuário envolver **q
   - Mudanças propostas agrupadas por componente
   - Arquivos a criar `[NEW]`, modificar `[MODIFY]`, deletar `[DELETE]`
   - Plano de verificação
-- **Apresentar o plano ao usuário e PARAR**
+- **Apresentar o plano ao usuário e aguardar aprovação na resposta principal, sem bloquear via hook**
 
 ### Fase 3 — AWAIT APPROVAL
 - Aguardar aprovação explícita do usuário (`"ok"`, `"aprovado"`, `"go"`, etc.)

package/.gos/scripts/hooks/claude-session-track.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const ROOT = path.resolve(__dirname, "../../..");
+const STATE_DIR = path.join(ROOT, ".claude", ".hook-state");
+
+function readStdin() {
+  try {
+    return fs.readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function parsePayload() {
+  const raw = readStdin().trim();
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+function getSessionId(payload) {
+  return (
+    payload.session_id ||
+    payload.sessionId ||
+    payload.conversation_id ||
+    payload.conversationId ||
+    "default"
+  );
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function statePathFor(sessionId) {
+  return path.join(STATE_DIR, `${sessionId}.json`);
+}
+
+function readState(statePath, sessionId) {
+  if (!fs.existsSync(statePath)) {
+    return {
+      sessionId,
+      touchedFiles: [],
+      commands: [],
+      significantAction: false,
+      updatedAt: new Date().toISOString(),
+    };
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(statePath, "utf8"));
+  } catch {
+    return {
+      sessionId,
+      touchedFiles: [],
+      commands: [],
+      significantAction: false,
+      updatedAt: new Date().toISOString(),
+    };
+  }
+}
+
+function uniquePush(list, value) {
+  if (!value || list.includes(value)) return;
+  list.push(value);
+}
+
+function normalizePath(candidate) {
+  if (typeof candidate !== "string" || !candidate.trim()) return null;
+  const trimmed = candidate.trim();
+  const absolute = path.isAbsolute(trimmed) ? trimmed : path.join(ROOT, trimmed);
+  const normalized = path.normalize(absolute);
+  if (!normalized.startsWith(ROOT)) return null;
+  return path.relative(ROOT, normalized).replace(/\\/g, "/");
+}
+
+function collectPaths(payload) {
+  const args = payload.args || payload.arguments || {};
+  const candidates = [
+    args.file_path,
+    args.path,
+    args.target_file,
+    args.new_file_path,
+    payload.file_path,
+    payload.path,
+  ];
+
+  const result = [];
+  for (const candidate of candidates) {
+    const normalized = normalizePath(candidate);
+    if (normalized) uniquePush(result, normalized);
+  }
+  return result;
+}
+
+function extractCommand(payload) {
+  const args = payload.args || payload.arguments || {};
+  return (
+    args.command ||
+    args.cmd ||
+    payload.command ||
+    payload.cmd ||
+    ""
+  ).trim();
+}
+
+function main() {
+  const payload = parsePayload();
+  const sessionId = getSessionId(payload);
+  const statePath = statePathFor(sessionId);
+
+  ensureDir(STATE_DIR);
+  const state = readState(statePath, sessionId);
+
+  for (const filePath of collectPaths(payload)) {
+    uniquePush(state.touchedFiles, filePath);
+  }
+
+  const toolName = String(payload.tool || payload.tool_name || payload.matcher || "");
+  if (/Bash/i.test(toolName)) {
+    const command = extractCommand(payload);
+    if (command) uniquePush(state.commands, command);
+  }
+
+  if (state.touchedFiles.length > 0 || state.commands.length > 0) {
+    state.significantAction = true;
+  }
+
+  state.updatedAt = new Date().toISOString();
+  fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+}
+
+try {
+  main();
+} catch {
+  // observation hook: never block
+}

package/.gos/scripts/hooks/claude-stop-summary.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { execFileSync } = require("node:child_process");
+
+const ROOT = path.resolve(__dirname, "../../..");
+const STATE_DIR = path.join(ROOT, ".claude", ".hook-state");
+
+function readStdin() {
+  try {
+    return fs.readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function parsePayload() {
+  const raw = readStdin().trim();
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+function getSessionId(payload) {
+  return (
+    payload.session_id ||
+    payload.sessionId ||
+    payload.conversation_id ||
+    payload.conversationId ||
+    "default"
+  );
+}
+
+function readState(sessionId) {
+  const statePath = path.join(STATE_DIR, `${sessionId}.json`);
+  if (!fs.existsSync(statePath)) {
+    return { statePath, state: null };
+  }
+  try {
+    return {
+      statePath,
+      state: JSON.parse(fs.readFileSync(statePath, "utf8")),
+    };
+  } catch {
+    return { statePath, state: null };
+  }
+}
+
+function safeUnlink(filePath) {
+  try {
+    fs.unlinkSync(filePath);
+  } catch {
+    // ignore cleanup issues
+  }
+}
+
+function runNpm(args, options = {}) {
+  const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+  return execFileSync(npmCmd, args, {
+    cwd: ROOT,
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"],
+    timeout: options.timeout || 120000,
+  });
+}
+
+function getGitStatusMap(paths) {
+  const map = new Map();
+  if (!Array.isArray(paths) || paths.length === 0) return map;
+
+  try {
+    const output = execFileSync("git", ["status", "--porcelain", "--", ...paths], {
+      cwd: ROOT,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 15000,
+    });
+
+    for (const line of output.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      const status = line.slice(0, 2);
+      const filePath = line.slice(3).trim().replace(/\\/g, "/");
+      map.set(filePath, status);
+    }
+  } catch {
+    // ignore git issues
+  }
+
+  return map;
+}
+
+function anyPathMatches(paths, matcher) {
+  return paths.some((filePath) => matcher.test(filePath));
+}
+
+function anyCreatedOrRemoved(statusMap, matcher) {
+  for (const [filePath, status] of statusMap.entries()) {
+    if (!matcher.test(filePath)) continue;
+    if (status.includes("A") || status.includes("D") || status.includes("R") || status === "??") {
+      return true;
+    }
+  }
+  return false;
+}
+
+function main() {
+  const payload = parsePayload();
+  const sessionId = getSessionId(payload);
+  const { statePath, state } = readState(sessionId);
+
+  if (!state || !state.significantAction) {
+    safeUnlink(statePath);
+    return;
+  }
+
+  const touchedFiles = Array.isArray(state.touchedFiles) ? state.touchedFiles : [];
+  const statusMap = getGitStatusMap(touchedFiles);
+  const summary = [];
+  const syncMatcher = /^(\.gos|\.claude|data|README\.md|CLAUDE\.md|AGENTS\.md|GEMINI\.md)/;
+
+  if (anyPathMatches(touchedFiles, syncMatcher)) {
+    try {
+      runNpm(["run", "sync:ides"], { timeout: 180000 });
+      summary.push("sync:ides OK");
+
+      if (anyCreatedOrRemoved(statusMap, /^(\.gos|\.claude)\//)) {
+        runNpm(["run", "doctor"], { timeout: 180000 });
+        summary.push("doctor OK");
+      }
+    } catch (error) {
+      const message = error.stderr || error.stdout || error.message || "falha no sync";
+      summary.push(`sync:ides falhou (${String(message).split(/\r?\n/)[0]})`);
+    }
+  }
+
+  safeUnlink(statePath);
+
+  if (summary.length > 0) {
+    process.stdout.write(`${summary.join("; ")}\n`);
+  }
+}
+
+try {
+  main();
+} catch {
+  // observation hook: never block
+}

package/AGENTS.md

@@ -39,8 +39,8 @@ Antes de executar qualquer tarefa complexa, SEMPRE entre em plan mode.
 
 **Protocolo:**
 1. **RESEARCH** — leia arquivos relevantes sem alterar nada
-2. **PLAN** — crie `implementation_plan.md` com `[NEW]`/`[MODIFY]`/`[DELETE]`, perguntas abertas, plano de verificação. Apresente e **PARE**
+2. **PLAN** — crie `implementation_plan.md` com `[NEW]`/`[MODIFY]`/`[DELETE]`, perguntas abertas, plano de verificação. Apresente e aguarde aprovação na resposta principal, sem bloquear via hook
 3. **AWAIT** — aguarde aprovação: "ok", "aprovado", "go", "execute", "pode ir"
 4. **EXECUTE + TRACK** — crie `task.md`, execute, finalize com `walkthrough.md`
 
-**Exceções — NÃO ativar:** git operations, leitura/explicação, edições simples de 1 arquivo, lint/typo, "execute direto", "sem plano", quando já aprovado na sessão.
+**Exceções — NÃO ativar:** git operations, leitura/explicação, edições simples de 1 arquivo, lint/typo, "execute direto", "sem plano", comandos de retomada como `continue`/`continuar`/`resume`, aprovações como `ok`/`aprovado`/`pode ir`, quando já aprovado na sessão.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ganbatte-os",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Framework operacional para design-to-code, squads de entrega e sprint sync com ClickUp.",
   "bin": {
     "ganbatte-os": ".gos/scripts/cli/gos-cli.js",