ganbatte-os 0.2.6 → 0.2.7

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/package.json

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