@lucapimenta/copy-chief-black 1.0.0

package/framework/.aios-core/copy-chief/utils/processing-registry.js

@@ -0,0 +1,218 @@
+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 processing_registry_exports = {};
+__export(processing_registry_exports, {
+  DEFAULT_TTL_DAYS: () => DEFAULT_TTL_DAYS,
+  ECOSYSTEM: () => ECOSYSTEM,
+  EXTRACTION_TOOL_PATTERNS: () => EXTRACTION_TOOL_PATTERNS,
+  HOME: () => HOME,
+  REGISTRY_FILENAME: () => REGISTRY_FILENAME,
+  checkForDuplicates: () => checkForDuplicates,
+  daysAgo: () => daysAgo,
+  extractTargets: () => extractTargets,
+  findAllRegistries: () => findAllRegistries,
+  formatWarnings: () => formatWarnings,
+  hashInput: () => hashInput,
+  isExtractionTool: () => isExtractionTool,
+  lookupTarget: () => lookupTarget,
+  parseEntries: () => parseEntries
+});
+module.exports = __toCommonJS(processing_registry_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_crypto = require("crypto");
+var import_os = require("os");
+const HOME = (0, import_os.homedir)();
+const ECOSYSTEM = (0, import_path.join)(HOME, "copywriting-ecosystem");
+const REGISTRY_FILENAME = "processing-registry.yaml";
+const DEFAULT_TTL_DAYS = 30;
+const EXTRACTION_TOOL_PATTERNS = [
+  /^mcp__firecrawl__/,
+  /^mcp__apify__/,
+  /^mcp__playwright__/
+];
+function hashInput(input) {
+  return (0, import_crypto.createHash)("sha256").update(input).digest("hex").slice(0, 16);
+}
+function daysAgo(dateStr) {
+  return Math.floor((Date.now() - new Date(dateStr).getTime()) / (1e3 * 60 * 60 * 24));
+}
+function isExtractionTool(toolName) {
+  return EXTRACTION_TOOL_PATTERNS.some((pat) => pat.test(toolName));
+}
+function extractTargets(toolInput) {
+  const candidates = [];
+  const check = (val) => {
+    if (typeof val === "string" && val.length > 5) {
+      if (val.startsWith("http") || val.startsWith("/") || val.includes(".com") || val.includes(".io")) {
+        candidates.push(val);
+      }
+    }
+  };
+  for (const key of [
+    "url",
+    "urls",
+    "startUrl",
+    "searchTerms",
+    "query",
+    "path",
+    "website",
+    "link"
+  ]) {
+    const val = toolInput[key];
+    if (Array.isArray(val)) {
+      val.forEach(check);
+    } else {
+      check(val);
+    }
+  }
+  for (const val of Object.values(toolInput)) {
+    check(val);
+  }
+  return [...new Set(candidates)];
+}
+function findAllRegistries() {
+  const result = [];
+  if (!(0, import_fs.existsSync)(ECOSYSTEM)) return result;
+  try {
+    const niches = (0, import_fs.readdirSync)(ECOSYSTEM).filter((d) => {
+      if (d.startsWith(".")) return false;
+      try {
+        return (0, import_fs.statSync)((0, import_path.join)(ECOSYSTEM, d)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+    for (const niche of niches) {
+      let offers = [];
+      try {
+        offers = (0, import_fs.readdirSync)((0, import_path.join)(ECOSYSTEM, niche)).filter((d) => {
+          if (d.startsWith(".")) return false;
+          try {
+            return (0, import_fs.statSync)((0, import_path.join)(ECOSYSTEM, niche, d)).isDirectory();
+          } catch {
+            return false;
+          }
+        });
+      } catch {
+        continue;
+      }
+      for (const offer of offers) {
+        const rp = (0, import_path.join)(ECOSYSTEM, niche, offer, REGISTRY_FILENAME);
+        if ((0, import_fs.existsSync)(rp)) result.push({ offer, regPath: rp });
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+function parseEntries(content) {
+  const entries = [];
+  const blocks = content.split(/\n  - hash:/);
+  for (let i = 1; i < blocks.length; i++) {
+    const block = blocks[i];
+    const get = (key) => {
+      const m = block.match(new RegExp(`^\\s*${key}:\\s*["']?([^"'\\n]+)["']?`, "m"));
+      return m ? m[1].trim() : void 0;
+    };
+    const getNum = (key) => {
+      const m = block.match(new RegExp(`^\\s*${key}:\\s*(\\d+)`, "m"));
+      return m ? parseInt(m[1], 10) : void 0;
+    };
+    const firstLine = block.split("\n")[0].trim().replace(/^["']|["']$/g, "");
+    const entry = {
+      hash: firstLine,
+      path: get("path") || "",
+      date: get("date") || "",
+      source: get("source") || "",
+      offer: get("offer") || "",
+      type: get("type") || "",
+      extracted_count: getNum("extracted_count"),
+      confidence: get("confidence"),
+      ttl_days: getNum("ttl_days")
+    };
+    if (entry.hash && entry.path && entry.date) entries.push(entry);
+  }
+  return entries;
+}
+function lookupTarget(target) {
+  const targetHash = hashInput(target);
+  const registries = findAllRegistries();
+  for (const { regPath } of registries) {
+    try {
+      const content = (0, import_fs.readFileSync)(regPath, "utf-8");
+      const entries = parseEntries(content);
+      const match = entries.find(
+        (e) => e.hash === targetHash || e.path === target || e.path.includes(target)
+      );
+      if (match) {
+        const age = daysAgo(match.date);
+        const ttl = match.ttl_days ?? DEFAULT_TTL_DAYS;
+        if (age <= ttl) return match;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function checkForDuplicates(input) {
+  if (!isExtractionTool(input.tool_name)) return [];
+  const targets = extractTargets(input.tool_input);
+  if (targets.length === 0) return [];
+  const warnings = [];
+  for (const target of targets) {
+    const match = lookupTarget(target);
+    if (match) {
+      warnings.push({ target, entry: match, agedays: daysAgo(match.date) });
+    }
+  }
+  return warnings;
+}
+function formatWarnings(warnings) {
+  const lines = ["\n[PROCESSING-CHECK] Duplicate extraction detected:"];
+  for (const { target, entry, agedays } of warnings) {
+    const ttl = entry.ttl_days ?? DEFAULT_TTL_DAYS;
+    const countStr = entry.extracted_count !== void 0 ? ` (${entry.extracted_count} items extracted)` : "";
+    const confStr = entry.confidence ? ` [${entry.confidence}]` : "";
+    lines.push(
+      `WARNING [REGISTRY] Already processed ${entry.source}/${entry.type}${confStr}: ${target.slice(0, 80)}
+  Offer: ${entry.offer} | Processed: ${entry.date.split("T")[0]} (${agedays}d ago, TTL ${ttl}d)${countStr}
+  Re-register after TTL or use: bun run scripts/processing-registry.ts reset ${entry.offer} --confirm`
+    );
+  }
+  lines.push("  To skip: ignore this warning and proceed.");
+  lines.push("  To track new results: re-register with updated --count.\n");
+  return lines.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_TTL_DAYS,
+  ECOSYSTEM,
+  EXTRACTION_TOOL_PATTERNS,
+  HOME,
+  REGISTRY_FILENAME,
+  checkForDuplicates,
+  daysAgo,
+  extractTargets,
+  findAllRegistries,
+  formatWarnings,
+  hashInput,
+  isExtractionTool,
+  lookupTarget,
+  parseEntries
+});

package/framework/.aios-core/copy-chief/utils/processing-registry.ts

@@ -0,0 +1,273 @@
+/**
+ * processing-registry.ts — Copy Chief OS Layer
+ * copy-chief/utils/processing-registry.ts
+ *
+ * Business logic for checking whether URLs/paths have already been processed
+ * by research extraction tools within a configurable TTL window.
+ *
+ * Used by hook: ~/.claude/hooks/processing-check.ts
+ */
+
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { createHash } from 'crypto';
+import { homedir } from 'os';
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface HookInput {
+  tool_name: string;
+  tool_input: Record<string, unknown>;
+}
+
+export interface RegistryEntry {
+  hash: string;
+  path: string;
+  date: string;
+  source: string;
+  offer: string;
+  type: string;
+  extracted_count?: number;
+  confidence?: string;
+  ttl_days?: number;
+}
+
+export interface DuplicateWarning {
+  target: string;
+  entry: RegistryEntry;
+  agedays: number;
+}
+
+// ─── Config ───────────────────────────────────────────────────────────────────
+
+export const HOME = homedir();
+export const ECOSYSTEM = join(HOME, 'copywriting-ecosystem');
+export const REGISTRY_FILENAME = 'processing-registry.yaml';
+export const DEFAULT_TTL_DAYS = 30;
+
+export const EXTRACTION_TOOL_PATTERNS = [
+  /^mcp__firecrawl__/,
+  /^mcp__apify__/,
+  /^mcp__playwright__/,
+];
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+export function hashInput(input: string): string {
+  return createHash('sha256').update(input).digest('hex').slice(0, 16);
+}
+
+export function daysAgo(dateStr: string): number {
+  return Math.floor((Date.now() - new Date(dateStr).getTime()) / (1000 * 60 * 60 * 24));
+}
+
+export function isExtractionTool(toolName: string): boolean {
+  return EXTRACTION_TOOL_PATTERNS.some((pat) => pat.test(toolName));
+}
+
+/**
+ * Extract URL/path candidates from tool input.
+ * Handles various field shapes used by Firecrawl, Apify, Playwright.
+ */
+export function extractTargets(toolInput: Record<string, unknown>): string[] {
+  const candidates: string[] = [];
+
+  const check = (val: unknown): void => {
+    if (typeof val === 'string' && val.length > 5) {
+      if (
+        val.startsWith('http') ||
+        val.startsWith('/') ||
+        val.includes('.com') ||
+        val.includes('.io')
+      ) {
+        candidates.push(val);
+      }
+    }
+  };
+
+  for (const key of [
+    'url',
+    'urls',
+    'startUrl',
+    'searchTerms',
+    'query',
+    'path',
+    'website',
+    'link',
+  ]) {
+    const val = toolInput[key];
+    if (Array.isArray(val)) {
+      val.forEach(check);
+    } else {
+      check(val);
+    }
+  }
+
+  // Also check all string values at top level
+  for (const val of Object.values(toolInput)) {
+    check(val);
+  }
+
+  return [...new Set(candidates)];
+}
+
+// ─── Registry lookup ──────────────────────────────────────────────────────────
+
+/**
+ * Scan the ecosystem directory for all processing-registry.yaml files.
+ */
+export function findAllRegistries(): { offer: string; regPath: string }[] {
+  const result: { offer: string; regPath: string }[] = [];
+
+  if (!existsSync(ECOSYSTEM)) return result;
+
+  try {
+    const niches = readdirSync(ECOSYSTEM).filter((d) => {
+      if (d.startsWith('.')) return false;
+      try {
+        return statSync(join(ECOSYSTEM, d)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+
+    for (const niche of niches) {
+      let offers: string[] = [];
+      try {
+        offers = readdirSync(join(ECOSYSTEM, niche)).filter((d) => {
+          if (d.startsWith('.')) return false;
+          try {
+            return statSync(join(ECOSYSTEM, niche, d)).isDirectory();
+          } catch {
+            return false;
+          }
+        });
+      } catch {
+        continue;
+      }
+
+      for (const offer of offers) {
+        const rp = join(ECOSYSTEM, niche, offer, REGISTRY_FILENAME);
+        if (existsSync(rp)) result.push({ offer, regPath: rp });
+      }
+    }
+  } catch {
+    /* scan failed */
+  }
+
+  return result;
+}
+
+/**
+ * Parse YAML registry file into structured RegistryEntry objects.
+ */
+export function parseEntries(content: string): RegistryEntry[] {
+  const entries: RegistryEntry[] = [];
+  const blocks = content.split(/\n  - hash:/);
+
+  for (let i = 1; i < blocks.length; i++) {
+    const block = blocks[i];
+    const get = (key: string): string | undefined => {
+      const m = block.match(new RegExp(`^\\s*${key}:\\s*["']?([^"'\\n]+)["']?`, 'm'));
+      return m ? m[1].trim() : undefined;
+    };
+    const getNum = (key: string): number | undefined => {
+      const m = block.match(new RegExp(`^\\s*${key}:\\s*(\\d+)`, 'm'));
+      return m ? parseInt(m[1], 10) : undefined;
+    };
+
+    const firstLine = block.split('\n')[0].trim().replace(/^["']|["']$/g, '');
+    const entry: RegistryEntry = {
+      hash: firstLine,
+      path: get('path') || '',
+      date: get('date') || '',
+      source: get('source') || '',
+      offer: get('offer') || '',
+      type: get('type') || '',
+      extracted_count: getNum('extracted_count'),
+      confidence: get('confidence'),
+      ttl_days: getNum('ttl_days'),
+    };
+
+    if (entry.hash && entry.path && entry.date) entries.push(entry);
+  }
+
+  return entries;
+}
+
+/**
+ * Look up a target URL/path across all registries.
+ * Returns a matching entry if found within TTL, otherwise null.
+ */
+export function lookupTarget(target: string): RegistryEntry | null {
+  const targetHash = hashInput(target);
+  const registries = findAllRegistries();
+
+  for (const { regPath } of registries) {
+    try {
+      const content = readFileSync(regPath, 'utf-8');
+      const entries = parseEntries(content);
+
+      const match = entries.find(
+        (e) => e.hash === targetHash || e.path === target || e.path.includes(target),
+      );
+
+      if (match) {
+        const age = daysAgo(match.date);
+        const ttl = match.ttl_days ?? DEFAULT_TTL_DAYS;
+        if (age <= ttl) return match;
+      }
+    } catch {
+      /* skip */
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check all targets from a tool call against the registry.
+ * Returns an array of duplicate warnings (empty if none found).
+ */
+export function checkForDuplicates(input: HookInput): DuplicateWarning[] {
+  if (!isExtractionTool(input.tool_name)) return [];
+
+  const targets = extractTargets(input.tool_input);
+  if (targets.length === 0) return [];
+
+  const warnings: DuplicateWarning[] = [];
+
+  for (const target of targets) {
+    const match = lookupTarget(target);
+    if (match) {
+      warnings.push({ target, entry: match, agedays: daysAgo(match.date) });
+    }
+  }
+
+  return warnings;
+}
+
+/**
+ * Format a set of duplicate warnings into a human-readable stderr message.
+ */
+export function formatWarnings(warnings: DuplicateWarning[]): string {
+  const lines: string[] = ['\n[PROCESSING-CHECK] Duplicate extraction detected:'];
+
+  for (const { target, entry, agedays } of warnings) {
+    const ttl = entry.ttl_days ?? DEFAULT_TTL_DAYS;
+    const countStr =
+      entry.extracted_count !== undefined ? ` (${entry.extracted_count} items extracted)` : '';
+    const confStr = entry.confidence ? ` [${entry.confidence}]` : '';
+
+    lines.push(
+      `WARNING [REGISTRY] Already processed ${entry.source}/${entry.type}${confStr}: ${target.slice(0, 80)}\n` +
+        `  Offer: ${entry.offer} | Processed: ${entry.date.split('T')[0]} (${agedays}d ago, TTL ${ttl}d)${countStr}\n` +
+        `  Re-register after TTL or use: bun run scripts/processing-registry.ts reset ${entry.offer} --confirm`,
+    );
+  }
+
+  lines.push('  To skip: ignore this warning and proceed.');
+  lines.push('  To track new results: re-register with updated --count.\n');
+
+  return lines.join('\n');
+}

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

@@ -0,0 +1,157 @@
+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 repetition_detector_exports = {};
+__export(repetition_detector_exports, {
+  LAST_N_TO_COMPARE: () => LAST_N_TO_COMPARE,
+  MAX_ENTRIES: () => MAX_ENTRIES,
+  PROMPTS_FILE: () => PROMPTS_FILE,
+  SESSION_DIR: () => SESSION_DIR,
+  SIMILARITY_THRESHOLD: () => SIMILARITY_THRESHOLD,
+  TRUNCATE_LENGTH: () => TRUNCATE_LENGTH,
+  appendPrompt: () => appendPrompt,
+  detectRepetition: () => detectRepetition,
+  ensureSessionDir: () => ensureSessionDir,
+  formatWarningMessage: () => formatWarningMessage,
+  jaccardSimilarity: () => jaccardSimilarity,
+  readPreviousPrompts: () => readPreviousPrompts,
+  tokenize: () => tokenize,
+  truncate: () => truncate
+});
+module.exports = __toCommonJS(repetition_detector_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_os = require("os");
+const HOME = (0, import_os.homedir)();
+const SESSION_DIR = (0, import_path.join)(HOME, ".claude/session-state");
+const PROMPTS_FILE = (0, import_path.join)(SESSION_DIR, "user-prompts.jsonl");
+const SIMILARITY_THRESHOLD = 0.6;
+const MAX_ENTRIES = 10;
+const LAST_N_TO_COMPARE = 5;
+const TRUNCATE_LENGTH = 120;
+function tokenize(text) {
+  const normalized = text.toLowerCase().replace(/[^\w\sáàãâéêíóôõúüçñ]/g, " ").replace(/\s+/g, " ").trim();
+  const words = normalized.split(" ").filter((w) => w.length > 2);
+  return new Set(words);
+}
+function jaccardSimilarity(a, b) {
+  if (a.size === 0 && b.size === 0) return 0;
+  let intersection = 0;
+  for (const word of a) {
+    if (b.has(word)) intersection++;
+  }
+  const union = a.size + b.size - intersection;
+  if (union === 0) return 0;
+  return intersection / union;
+}
+function truncate(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "...";
+}
+function ensureSessionDir() {
+  if (!(0, import_fs.existsSync)(SESSION_DIR)) {
+    (0, import_fs.mkdirSync)(SESSION_DIR, { recursive: true });
+  }
+}
+function readPreviousPrompts() {
+  try {
+    if (!(0, import_fs.existsSync)(PROMPTS_FILE)) return [];
+    const content = (0, import_fs.readFileSync)(PROMPTS_FILE, "utf-8").trim();
+    if (!content) return [];
+    const entries = [];
+    for (const line of content.split("\n")) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry && typeof entry.prompt === "string") {
+          entries.push(entry);
+        }
+      } catch {
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+function appendPrompt(prompt, existingEntries) {
+  ensureSessionDir();
+  const newEntry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    prompt
+  };
+  const allEntries = [...existingEntries, newEntry];
+  const trimmed = allEntries.slice(-MAX_ENTRIES);
+  const content = trimmed.map((e) => JSON.stringify(e)).join("\n") + "\n";
+  (0, import_fs.writeFileSync)(PROMPTS_FILE, content);
+}
+function detectRepetition(currentPrompt) {
+  const previousEntries = readPreviousPrompts();
+  const recentEntries = previousEntries.slice(-LAST_N_TO_COMPARE);
+  const currentTokens = tokenize(currentPrompt);
+  let highestSimilarity = 0;
+  let mostSimilarPrompt = "";
+  if (currentTokens.size >= 3) {
+    for (const entry of recentEntries) {
+      const previousTokens = tokenize(entry.prompt);
+      if (previousTokens.size < 3) continue;
+      const similarity = jaccardSimilarity(currentTokens, previousTokens);
+      if (similarity > highestSimilarity) {
+        highestSimilarity = similarity;
+        mostSimilarPrompt = entry.prompt;
+      }
+    }
+  }
+  appendPrompt(currentPrompt, previousEntries);
+  return {
+    detected: highestSimilarity > SIMILARITY_THRESHOLD,
+    similarity: highestSimilarity,
+    mostSimilarPrompt,
+    currentPrompt
+  };
+}
+function formatWarningMessage(result) {
+  const similarityPct = Math.round(result.similarity * 100);
+  return `
+\u26A0\uFE0F REGRA 2x DETECTADA (similaridade: ${similarityPct}%): Usuario repetiu instrucao similar.
+Prompt anterior: "${truncate(result.mostSimilarPrompt, TRUNCATE_LENGTH)}"
+Prompt atual: "${truncate(result.currentPrompt, TRUNCATE_LENGTH)}"
+
+ACAO OBRIGATORIA:
+1. PARE imediatamente
+2. Releia o pedido ORIGINAL com atencao
+3. Faca EXATAMENTE o que foi pedido
+4. NAO justifique, NAO explique \u2014 apenas execute
+
+`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LAST_N_TO_COMPARE,
+  MAX_ENTRIES,
+  PROMPTS_FILE,
+  SESSION_DIR,
+  SIMILARITY_THRESHOLD,
+  TRUNCATE_LENGTH,
+  appendPrompt,
+  detectRepetition,
+  ensureSessionDir,
+  formatWarningMessage,
+  jaccardSimilarity,
+  readPreviousPrompts,
+  tokenize,
+  truncate
+});