@lucapimenta/copy-chief-black 1.0.0

package/framework/.aios-core/copy-chief/utils/decision-detector.js

@@ -0,0 +1,138 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var decision_detector_exports = {};
+__export(decision_detector_exports, {
+  DECISIONS_PATH: () => DECISIONS_PATH,
+  PATTERNS: () => PATTERNS,
+  detectDecisions: () => detectDecisions,
+  extractSentence: () => extractSentence,
+  hashText: () => hashText,
+  loadDecisions: () => loadDecisions,
+  recordNewDecisions: () => recordNewDecisions,
+  saveDecisions: () => saveDecisions
+});
+module.exports = __toCommonJS(decision_detector_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_crypto = require("crypto");
+const HOME = process.env.HOME ?? "/tmp";
+const DECISIONS_PATH = (0, import_path.join)(HOME, ".claude", "memory", "user-decisions.json");
+const PATTERNS = [
+  // Workflow — explicit instructions / rules
+  { regex: /\b(sempre use|always use)\b/i, category: "workflow" },
+  { regex: /\b(nunca|never)\b/i, category: "workflow" },
+  { regex: /\ba partir de agora\b/i, category: "workflow" },
+  { regex: /\bfrom now on\b/i, category: "workflow" },
+  { regex: /\bmude para|troque por\b/i, category: "workflow" },
+  { regex: /\bswitch to|change to\b/i, category: "workflow" },
+  // Approval / continuation
+  { regex: /\b(pode continuar|aprovo|approve)\b/i, category: "workflow" },
+  // System protection
+  { regex: /\b(nao quero|nao mexa|don't touch)\b/i, category: "system" },
+  // Preferences
+  { regex: /\bprefiro\b/i, category: "style" },
+  { regex: /\bprefer[oe]\b/i, category: "style" },
+  // Decisions (offer-level)
+  { regex: /\bdecid[io]\b/i, category: "offer" },
+  { regex: /\bescolh[eo]\b/i, category: "offer" },
+  // System settings — model selection
+  { regex: /\b(use|usar)\s+(modelo|model|opus|sonnet|haiku)\b/i, category: "system" }
+];
+function hashText(text) {
+  return (0, import_crypto.createHash)("md5").update(text.toLowerCase().trim()).digest("hex").slice(0, 8);
+}
+function extractSentence(prompt, matchIndex) {
+  const sentenceBreaks = /[.!?\n]/g;
+  let start = 0;
+  let end = prompt.length;
+  const before = prompt.slice(0, matchIndex);
+  const lastBreak = Math.max(
+    before.lastIndexOf("."),
+    before.lastIndexOf("!"),
+    before.lastIndexOf("?"),
+    before.lastIndexOf("\n")
+  );
+  if (lastBreak >= 0) start = lastBreak + 1;
+  const after = prompt.slice(matchIndex);
+  const nextBreakMatch = after.search(sentenceBreaks);
+  if (nextBreakMatch >= 0) end = matchIndex + nextBreakMatch;
+  return prompt.slice(start, end).trim().slice(0, 200);
+}
+function detectDecisions(prompt) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { regex, category } of PATTERNS) {
+    const match = regex.exec(prompt);
+    if (!match) continue;
+    const sentence = extractSentence(prompt, match.index);
+    if (!sentence || seen.has(sentence)) continue;
+    seen.add(sentence);
+    found.push({ text: sentence, category });
+  }
+  return found;
+}
+function loadDecisions() {
+  if (!(0, import_fs.existsSync)(DECISIONS_PATH)) return [];
+  try {
+    return JSON.parse((0, import_fs.readFileSync)(DECISIONS_PATH, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function saveDecisions(decisions) {
+  const dir = (0, import_path.dirname)(DECISIONS_PATH);
+  if (!(0, import_fs.existsSync)(dir)) (0, import_fs.mkdirSync)(dir, { recursive: true });
+  (0, import_fs.writeFileSync)(DECISIONS_PATH, JSON.stringify(decisions, null, 2), "utf-8");
+}
+function recordNewDecisions(prompt) {
+  if (!prompt || prompt.length < 5) return 0;
+  const detected = detectDecisions(prompt);
+  if (detected.length === 0) return 0;
+  const existing = loadDecisions();
+  const existingHashes = new Set(existing.map((d) => d.hash));
+  let added = 0;
+  for (const { text, category } of detected) {
+    const hash = hashText(text);
+    if (existingHashes.has(hash)) continue;
+    const now = /* @__PURE__ */ new Date();
+    existing.push({
+      id: `d-${Math.floor(now.getTime() / 1e3)}`,
+      date: now.toISOString(),
+      text,
+      category,
+      hash
+    });
+    existingHashes.add(hash);
+    added++;
+  }
+  if (added > 0) {
+    saveDecisions(existing);
+  }
+  return added;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DECISIONS_PATH,
+  PATTERNS,
+  detectDecisions,
+  extractSentence,
+  hashText,
+  loadDecisions,
+  recordNewDecisions,
+  saveDecisions
+});

package/framework/.aios-core/copy-chief/utils/decision-detector.ts

@@ -0,0 +1,193 @@
+// ~/.claude/.aios-core/copy-chief/utils/decision-detector.ts
+// Decision / preference detection for UserPromptSubmit hooks.
+// Extracted from decision-detector.ts hook — v1.0 (2026-03-02)
+//
+// Detects decision/preference signals in user messages and persists them to
+// ~/.claude/memory/user-decisions.json with dedup via MD5-prefix hash.
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { createHash } from 'crypto';
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+
+const HOME = process.env.HOME ?? '/tmp';
+export const DECISIONS_PATH = join(HOME, '.claude', 'memory', 'user-decisions.json');
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type DecisionCategory = 'workflow' | 'offer' | 'style' | 'system';
+
+export interface Decision {
+  id: string;
+  date: string;
+  text: string;
+  category: DecisionCategory;
+  hash: string;
+}
+
+// ---------------------------------------------------------------------------
+// Detection patterns
+// ---------------------------------------------------------------------------
+
+/** Regex patterns with their semantic category. Order matters for precedence. */
+export const PATTERNS: Array<{ regex: RegExp; category: DecisionCategory }> = [
+  // Workflow — explicit instructions / rules
+  { regex: /\b(sempre use|always use)\b/i,             category: 'workflow' },
+  { regex: /\b(nunca|never)\b/i,                        category: 'workflow' },
+  { regex: /\ba partir de agora\b/i,                    category: 'workflow' },
+  { regex: /\bfrom now on\b/i,                          category: 'workflow' },
+  { regex: /\bmude para|troque por\b/i,                 category: 'workflow' },
+  { regex: /\bswitch to|change to\b/i,                  category: 'workflow' },
+  // Approval / continuation
+  { regex: /\b(pode continuar|aprovo|approve)\b/i,      category: 'workflow' },
+  // System protection
+  { regex: /\b(nao quero|nao mexa|don't touch)\b/i,    category: 'system'   },
+  // Preferences
+  { regex: /\bprefiro\b/i,                              category: 'style'    },
+  { regex: /\bprefer[oe]\b/i,                           category: 'style'    },
+  // Decisions (offer-level)
+  { regex: /\bdecid[io]\b/i,                            category: 'offer'    },
+  { regex: /\bescolh[eo]\b/i,                           category: 'offer'    },
+  // System settings — model selection
+  { regex: /\b(use|usar)\s+(modelo|model|opus|sonnet|haiku)\b/i, category: 'system' },
+];
+
+// ---------------------------------------------------------------------------
+// Hashing / sentence extraction
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns an 8-char MD5 prefix of the lowercased, trimmed text.
+ * Used for deduplication.
+ */
+export function hashText(text: string): string {
+  return createHash('md5')
+    .update(text.toLowerCase().trim())
+    .digest('hex')
+    .slice(0, 8);
+}
+
+/**
+ * Extracts the complete sentence surrounding `matchIndex` in `prompt`.
+ * Sentence boundaries: `.` `!` `?` `\n`
+ * Result is capped at 200 characters.
+ */
+export function extractSentence(prompt: string, matchIndex: number): string {
+  const sentenceBreaks = /[.!?\n]/g;
+  let start = 0;
+  let end = prompt.length;
+
+  const before = prompt.slice(0, matchIndex);
+  const lastBreak = Math.max(
+    before.lastIndexOf('.'),
+    before.lastIndexOf('!'),
+    before.lastIndexOf('?'),
+    before.lastIndexOf('\n'),
+  );
+  if (lastBreak >= 0) start = lastBreak + 1;
+
+  const after = prompt.slice(matchIndex);
+  const nextBreakMatch = after.search(sentenceBreaks);
+  if (nextBreakMatch >= 0) end = matchIndex + nextBreakMatch;
+
+  return prompt.slice(start, end).trim().slice(0, 200);
+}
+
+// ---------------------------------------------------------------------------
+// Detection
+// ---------------------------------------------------------------------------
+
+/**
+ * Scans a user prompt for decision/preference signals.
+ * Deduplicates by extracted sentence text within a single call.
+ *
+ * Returns an array of `{ text, category }` for each unique signal found.
+ */
+export function detectDecisions(
+  prompt: string,
+): Array<{ text: string; category: DecisionCategory }> {
+  const found: Array<{ text: string; category: DecisionCategory }> = [];
+  const seen = new Set<string>();
+
+  for (const { regex, category } of PATTERNS) {
+    const match = regex.exec(prompt);
+    if (!match) continue;
+
+    const sentence = extractSentence(prompt, match.index);
+    if (!sentence || seen.has(sentence)) continue;
+
+    seen.add(sentence);
+    found.push({ text: sentence, category });
+  }
+
+  return found;
+}
+
+// ---------------------------------------------------------------------------
+// Persistence
+// ---------------------------------------------------------------------------
+
+/** Loads existing decisions from disk. Returns empty array on missing/corrupt file. */
+export function loadDecisions(): Decision[] {
+  if (!existsSync(DECISIONS_PATH)) return [];
+  try {
+    return JSON.parse(readFileSync(DECISIONS_PATH, 'utf-8')) as Decision[];
+  } catch {
+    return [];
+  }
+}
+
+/** Persists the decisions array to disk. Creates parent directory if needed. */
+export function saveDecisions(decisions: Decision[]): void {
+  const dir = dirname(DECISIONS_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(DECISIONS_PATH, JSON.stringify(decisions, null, 2), 'utf-8');
+}
+
+// ---------------------------------------------------------------------------
+// High-level: detect + persist (returns number of new entries added)
+// ---------------------------------------------------------------------------
+
+/**
+ * Detects decision signals in `prompt`, deduplicates against existing records,
+ * and persists new ones. Fail-open: errors are swallowed internally.
+ *
+ * Returns the count of newly added decisions (0 if none).
+ */
+export function recordNewDecisions(prompt: string): number {
+  if (!prompt || prompt.length < 5) return 0;
+
+  const detected = detectDecisions(prompt);
+  if (detected.length === 0) return 0;
+
+  const existing = loadDecisions();
+  const existingHashes = new Set(existing.map((d) => d.hash));
+  let added = 0;
+
+  for (const { text, category } of detected) {
+    const hash = hashText(text);
+    if (existingHashes.has(hash)) continue;
+
+    const now = new Date();
+    existing.push({
+      id: `d-${Math.floor(now.getTime() / 1000)}`,
+      date: now.toISOString(),
+      text,
+      category,
+      hash,
+    });
+    existingHashes.add(hash);
+    added++;
+  }
+
+  if (added > 0) {
+    saveDecisions(existing);
+  }
+
+  return added;
+}

package/framework/.aios-core/copy-chief/utils/file-discovery.js

@@ -0,0 +1,180 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var file_discovery_exports = {};
+__export(file_discovery_exports, {
+  EXCLUDED_PATTERNS: () => EXCLUDED_PATTERNS,
+  MAX_DEPTH: () => MAX_DEPTH,
+  MAX_EXECUTION_MS: () => MAX_EXECUTION_MS,
+  MAX_SIMILAR_FILES: () => MAX_SIMILAR_FILES,
+  discoverSimilarFiles: () => discoverSimilarFiles,
+  extractFilePath: () => extractFilePath,
+  filenameSimilarity: () => filenameSimilarity,
+  findSimilarInDir: () => findSimilarInDir,
+  formatDiscoveryWarning: () => formatDiscoveryWarning,
+  getFileModifiedDate: () => getFileModifiedDate,
+  isExcludedPath: () => isExcludedPath
+});
+module.exports = __toCommonJS(file_discovery_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+const MAX_EXECUTION_MS = 3e3;
+const MAX_SIMILAR_FILES = 5;
+const MAX_DEPTH = 2;
+const EXCLUDED_PATTERNS = [
+  /\/production\//i,
+  /\/research\//i,
+  /\/tmp\//i,
+  /\/temp\//i,
+  /session-state\//i,
+  /node_modules\//i,
+  /\.git\//i,
+  /\/raw\//i,
+  /\/processed\//i
+];
+function extractFilePath(toolInput) {
+  for (const field of ["file_path", "path", "filePath"]) {
+    if (typeof toolInput[field] === "string") {
+      return toolInput[field];
+    }
+  }
+  return null;
+}
+function isExcludedPath(filePath) {
+  return EXCLUDED_PATTERNS.some((pattern) => pattern.test(filePath));
+}
+function getFileModifiedDate(filePath) {
+  try {
+    const stats = (0, import_fs.statSync)(filePath);
+    const d = stats.mtime;
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+  } catch {
+    return "unknown";
+  }
+}
+function filenameSimilarity(name1, name2) {
+  const base1 = (0, import_path.basename)(name1, (0, import_path.extname)(name1)).toLowerCase();
+  const base2 = (0, import_path.basename)(name2, (0, import_path.extname)(name2)).toLowerCase();
+  if (base1 === base2) return 1;
+  const words1 = new Set(base1.split(/[-_.\s]+/).filter((w) => w.length > 1));
+  const words2 = new Set(base2.split(/[-_.\s]+/).filter((w) => w.length > 1));
+  if (words1.size === 0 || words2.size === 0) return 0;
+  let intersection = 0;
+  for (const w of words1) {
+    if (words2.has(w)) intersection++;
+  }
+  const union = words1.size + words2.size - intersection;
+  if (union === 0) return 0;
+  const jaccard = intersection / union;
+  const firstWord1 = [...words1][0];
+  const firstWord2 = [...words2][0];
+  const prefixBonus = firstWord1 === firstWord2 ? 0.15 : 0;
+  return Math.min(1, jaccard + prefixBonus);
+}
+function findSimilarInDir(dir, targetName, targetExt) {
+  const results = [];
+  try {
+    if (!(0, import_fs.existsSync)(dir)) return results;
+    const entries = (0, import_fs.readdirSync)(dir);
+    for (const entry of entries) {
+      if (entry.startsWith(".")) continue;
+      const fullPath = (0, import_path.join)(dir, entry);
+      try {
+        const stats = (0, import_fs.statSync)(fullPath);
+        if (!stats.isFile()) continue;
+      } catch {
+        continue;
+      }
+      const entryExt = (0, import_path.extname)(entry);
+      const similarity = filenameSimilarity(targetName, entry);
+      const sameExt = entryExt === targetExt;
+      const threshold = sameExt ? 0.3 : 0.5;
+      if (similarity >= threshold) {
+        results.push({
+          path: fullPath,
+          modified: getFileModifiedDate(fullPath),
+          similarity: sameExt ? `nome ${Math.round(similarity * 100)}% similar, mesma extensao` : `nome ${Math.round(similarity * 100)}% similar`
+        });
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function discoverSimilarFiles(input) {
+  const noWarn = { shouldWarn: false, filePath: "", similar: [] };
+  if (input.tool_name !== "Write") return noWarn;
+  const filePath = extractFilePath(input.tool_input);
+  if (!filePath) return noWarn;
+  if ((0, import_fs.existsSync)(filePath)) return noWarn;
+  if (isExcludedPath(filePath)) return noWarn;
+  const targetDir = (0, import_path.dirname)(filePath);
+  const targetName = (0, import_path.basename)(filePath);
+  const targetExt = (0, import_path.extname)(filePath);
+  const allSimilar = [];
+  allSimilar.push(...findSimilarInDir(targetDir, targetName, targetExt));
+  let currentDir = targetDir;
+  for (let i = 0; i < MAX_DEPTH; i++) {
+    const parentDir = (0, import_path.dirname)(currentDir);
+    if (parentDir === currentDir) break;
+    allSimilar.push(...findSimilarInDir(parentDir, targetName, targetExt));
+    currentDir = parentDir;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const unique = allSimilar.filter((f) => {
+    if (seen.has(f.path)) return false;
+    seen.add(f.path);
+    return true;
+  });
+  unique.sort((a, b) => {
+    const pctA = parseInt(a.similarity.match(/(\d+)%/)?.[1] || "0");
+    const pctB = parseInt(b.similarity.match(/(\d+)%/)?.[1] || "0");
+    return pctB - pctA;
+  });
+  const topResults = unique.slice(0, MAX_SIMILAR_FILES);
+  return {
+    shouldWarn: topResults.length > 0,
+    filePath,
+    similar: topResults
+  };
+}
+function formatDiscoveryWarning(result) {
+  const fileList = result.similar.map((f) => `  - ${f.path} (modificado: ${f.modified}) [${f.similarity}]`).join("\n");
+  return `
+\u{1F50D} DISCOVERY CHECK: Criando novo arquivo "${(0, import_path.basename)(result.filePath)}"
+Arquivos similares encontrados:
+${fileList}
+
+Considere: Estender existente ao inves de criar novo?
+(Este e um aviso \u2014 a criacao NAO foi bloqueada)
+
+`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EXCLUDED_PATTERNS,
+  MAX_DEPTH,
+  MAX_EXECUTION_MS,
+  MAX_SIMILAR_FILES,
+  discoverSimilarFiles,
+  extractFilePath,
+  filenameSimilarity,
+  findSimilarInDir,
+  formatDiscoveryWarning,
+  getFileModifiedDate,
+  isExcludedPath
+});