atris 3.35.0 → 3.37.0

package/commands/search.js

@@ -0,0 +1,363 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const LAYERS = [
+  { key: 'features', dir: path.join('atris', 'features') },
+  { key: 'team', dir: path.join('atris', 'team') },
+  { key: 'wiki', dir: path.join('atris', 'wiki') },
+  { key: 'logs', dir: path.join('atris', 'logs') },
+];
+
+const STOPWORDS = new Set([
+  'a', 'an', 'and', 'are', 'as', 'at', 'for', 'from', 'in', 'is', 'it',
+  'of', 'on', 'or', 'the', 'to', 'where', 'who',
+]);
+
+const SYNONYM_MAP = {
+  billing: ['credits', 'stripe', 'subscription', 'connect', 'treasury'],
+  payments: ['credits', 'stripe', 'subscription', 'connect', 'treasury'],
+  payment: ['credits', 'stripe', 'subscription', 'connect', 'treasury'],
+  money: ['credits', 'stripe', 'subscription', 'connect', 'treasury'],
+  auth: ['oauth', 'identity', 'jwt', 'security', 'access'],
+  login: ['auth', 'oauth', 'identity', 'jwt', 'security', 'access'],
+  email: ['mail', 'inbox', 'ses', 'agent-mail', 'atrismail', 'postman'],
+  agents: ['agent', 'pulse', 'autopilot', 'fleet', 'member', 'persona', 'architect'],
+  database: ['db', 'schema', 'migration', 'supabase', 'sql'],
+  db: ['database', 'schema', 'migration', 'supabase', 'sql'],
+  slack: ['messaging', 'integration', 'integrations'],
+  messaging: ['slack', 'integration', 'integrations'],
+  pulse: ['autopilot', 'proactive-ops', 'autonomous'],
+  autonomous: ['pulse', 'autopilot', 'proactive-ops'],
+  browser: ['scraper', 'automation', 'browser-lead'],
+  tools: ['tool', 'toolkit', 'skill', 'skills'],
+  toolkit: ['tool', 'tools', 'skill', 'skills'],
+  apps: ['app', 'builder', 'workflow', 'create-app', 'app-pm', 'block-builder'],
+  workflow: ['app', 'apps', 'builder', 'create-app', 'app-pm', 'block-builder'],
+};
+
+function showSearchHelp() {
+  console.log('Usage: atris search <keyword> [--raw]');
+  console.log('Example: atris search auth');
+  console.log('  --raw  Print the full file:line dump instead of the compact answer');
+}
+
+function normalizeText(value) {
+  return String(value || '').toLowerCase().trim();
+}
+
+function toRelative(root, filePath) {
+  return path.relative(root, filePath).split(path.sep).join('/');
+}
+
+function queryTerms(query) {
+  const terms = new Set();
+  const normalized = normalizeText(query);
+  if (normalized) terms.add(normalized);
+
+  const tokens = normalized
+    .split(/[^a-z0-9._/-]+/)
+    .map(token => token.trim())
+    .filter(token => token && !STOPWORDS.has(token));
+
+  for (const token of tokens) {
+    terms.add(token);
+    if (token.endsWith('s') && token.length > 3) {
+      terms.add(token.slice(0, -1));
+    } else if (token.length > 3) {
+      terms.add(`${token}s`);
+    }
+    for (const synonym of SYNONYM_MAP[token] || []) {
+      terms.add(synonym);
+    }
+  }
+
+  return Array.from(terms)
+    .filter(Boolean)
+    .sort((a, b) => b.length - a.length || a.localeCompare(b));
+}
+
+function hasTerm(value, terms) {
+  const text = normalizeText(value);
+  return terms.some(term => text.includes(term));
+}
+
+function listMarkdownFiles(rootDir) {
+  if (!fs.existsSync(rootDir)) return [];
+  const files = [];
+
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    entries
+      .sort((a, b) => a.name.localeCompare(b.name))
+      .forEach((entry) => {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(fullPath);
+          return;
+        }
+        if (!entry.isFile()) return;
+        if (/\.md$/i.test(entry.name)) files.push(fullPath);
+      });
+  }
+
+  walk(rootDir);
+  return files;
+}
+
+function recencyMs(relativePath, stat) {
+  const match = relativePath.match(/(\d{4})-(\d{2})-(\d{2})/);
+  if (match) {
+    const ms = Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
+    if (Number.isFinite(ms)) return ms;
+  }
+  return Number(stat && stat.mtimeMs) || 0;
+}
+
+function scanLayer(root, layer, terms) {
+  const dir = path.join(root, layer.dir);
+  const result = {
+    key: layer.key,
+    dir: layer.dir.split(path.sep).join('/'),
+    exists: fs.existsSync(dir),
+    fileHits: [],
+    lineHits: [],
+  };
+
+  for (const filePath of listMarkdownFiles(dir)) {
+    let stat;
+    let content;
+    try {
+      stat = fs.statSync(filePath);
+      content = fs.readFileSync(filePath, 'utf8');
+    } catch {
+      continue;
+    }
+
+    const relativePath = toRelative(root, filePath);
+    const fileRecency = recencyMs(relativePath, stat);
+    const pathMatched = hasTerm(relativePath, terms);
+    const fileLineHits = [];
+
+    content.split(/\r?\n/).forEach((line, index) => {
+      if (!hasTerm(line, terms)) return;
+      const hit = {
+        layer: layer.key,
+        file: relativePath,
+        line: index + 1,
+        content: line.trim(),
+        recencyMs: fileRecency,
+        pathOnly: false,
+      };
+      fileLineHits.push(hit);
+      result.lineHits.push(hit);
+    });
+
+    if (pathMatched || fileLineHits.length > 0) {
+      result.fileHits.push({
+        layer: layer.key,
+        file: relativePath,
+        pathMatched,
+        lineHits: fileLineHits,
+        recencyMs: fileRecency,
+      });
+    }
+  }
+
+  return result;
+}
+
+function compareByRecency(a, b) {
+  return (b.recencyMs || 0) - (a.recencyMs || 0)
+    || a.file.localeCompare(b.file)
+    || (a.line || 0) - (b.line || 0);
+}
+
+function sortedFileHits(layerResult) {
+  return [...(layerResult.fileHits || [])].sort(compareByRecency);
+}
+
+function sortedLineHits(layerResult) {
+  return [...(layerResult.lineHits || [])].sort(compareByRecency);
+}
+
+function collectSearchResults(root, query) {
+  const terms = queryTerms(query);
+  const layers = {};
+  for (const layer of LAYERS) {
+    layers[layer.key] = scanLayer(root, layer, terms);
+  }
+  return { query, terms, layers };
+}
+
+function featurePath(file) {
+  const parts = file.split('/');
+  const index = parts.indexOf('features');
+  const slug = index >= 0 ? parts[index + 1] : null;
+  if (slug && slug !== 'README.md') return `atris/features/${slug}/`;
+  return file;
+}
+
+function ownerPath(root, file) {
+  const parts = file.split('/');
+  const index = parts.indexOf('team');
+  const member = index >= 0 && parts[index + 1]
+    ? `atris/team/${parts[index + 1]}/MEMBER.md`
+    : null;
+  if (member && fs.existsSync(path.join(root, member))) return member;
+  return path.basename(file) === 'MEMBER.md' ? file : null;
+}
+
+function selectedFeature(results) {
+  const hit = sortedFileHits(results.layers.features)[0];
+  return hit ? featurePath(hit.file) : 'none';
+}
+
+function selectedOwner(root, results) {
+  for (const hit of sortedFileHits(results.layers.team)) {
+    const member = ownerPath(root, hit.file);
+    if (member) return member;
+  }
+  return 'none';
+}
+
+function selectedWiki(results) {
+  const hit = sortedFileHits(results.layers.wiki)[0];
+  return hit ? hit.file : 'gap - not indexed yet';
+}
+
+function hitCount(layerResult) {
+  return (layerResult.fileHits || []).reduce((total, fileHit) => {
+    if (fileHit.lineHits.length > 0) return total + fileHit.lineHits.length;
+    return total + (fileHit.pathMatched ? 1 : 0);
+  }, 0);
+}
+
+function totalHitCount(results) {
+  return LAYERS.reduce((total, layer) => total + hitCount(results.layers[layer.key]), 0);
+}
+
+function truncateLine(value, max = 140) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 3))}...`;
+}
+
+function renderCompactSearch(root, results) {
+  const lines = [
+    `Feature: ${selectedFeature(results)}`,
+    `Owner: ${selectedOwner(root, results)}`,
+    `Wiki: ${selectedWiki(results)}`,
+  ];
+
+  const journalHits = sortedLineHits(results.layers.logs);
+  if (totalHitCount(results) === 0) {
+    lines.push('No matches found.');
+  }
+  if (journalHits.length === 0) {
+    lines.push('Journal: none');
+    return lines.join('\n');
+  }
+
+  const total = totalHitCount(results);
+  const limit = total > 5 ? 3 : 5;
+  lines.push(`Found ${journalHits.length} match${journalHits.length === 1 ? '' : 'es'}.`);
+  lines.push('Journal:');
+  for (const hit of journalHits.slice(0, limit)) {
+    lines.push(`- ${hit.file}:${hit.line}: ${truncateLine(hit.content)}`);
+  }
+  if (journalHits.length > limit) {
+    lines.push(`(${journalHits.length - limit} more journal hits; use --raw for full dump)`);
+  }
+  return lines.join('\n');
+}
+
+function rawHits(results) {
+  const hits = [];
+  for (const layer of LAYERS) {
+    for (const fileHit of sortedFileHits(results.layers[layer.key])) {
+      if (fileHit.lineHits.length > 0) {
+        hits.push(...fileHit.lineHits.sort((a, b) => (a.line || 0) - (b.line || 0)));
+      } else if (fileHit.pathMatched) {
+        hits.push({
+          layer: layer.key,
+          file: fileHit.file,
+          line: 1,
+          content: `(path match) ${fileHit.file}`,
+          recencyMs: fileHit.recencyMs,
+          pathOnly: true,
+        });
+      }
+    }
+  }
+  return hits;
+}
+
+function renderRawSearch(results) {
+  const hits = rawHits(results);
+  const lines = [
+    `Searching for "${results.query}" in atris/features, atris/team, atris/wiki, atris/logs...`,
+    '',
+  ];
+
+  if (hits.length === 0) {
+    lines.push('No matches found.');
+    return lines.join('\n');
+  }
+
+  lines.push(`Found ${hits.length} match${hits.length === 1 ? '' : 'es'}:`);
+  lines.push('');
+  for (const hit of hits) {
+    lines.push(`${hit.file}:${hit.line}`);
+    lines.push(`  ${truncateLine(hit.content, 100)}`);
+    lines.push('');
+  }
+  return lines.join('\n').trimEnd();
+}
+
+function parseSearchArgs(args) {
+  const argv = Array.isArray(args) ? args : [];
+  const helpIndex = argv.findIndex(arg => arg === '--help' || arg === '-h');
+  const raw = argv.includes('--raw');
+  const query = argv.filter(arg => arg !== '--raw' && arg !== '--help' && arg !== '-h').join(' ').trim();
+  return { helpIndex, raw, query, argCount: argv.length };
+}
+
+function searchCommand(args = [], options = {}) {
+  const { helpIndex, raw, query, argCount } = parseSearchArgs(args);
+
+  if (helpIndex >= 0) {
+    showSearchHelp();
+    return argCount === 1 ? 0 : 1;
+  }
+
+  if (!query) {
+    showSearchHelp();
+    return 1;
+  }
+
+  const root = options.root || process.cwd();
+  const results = collectSearchResults(root, query);
+  if (totalHitCount(results) === 0 && !fs.existsSync(path.join(root, 'atris'))) {
+    // Outside a workspace the empty scan rows are noise; lead with the way in.
+    console.log('No atris folder here. Run atris init to set one up.');
+    return 0;
+  }
+  console.log(raw ? renderRawSearch(results) : renderCompactSearch(root, results));
+  return 0;
+}
+
+module.exports = {
+  collectSearchResults,
+  renderCompactSearch,
+  renderRawSearch,
+  searchCommand,
+  showSearchHelp,
+};

package/commands/skill.js

@@ -123,6 +123,52 @@ function findReadableSkills() {
 
 // --- Audit Checks ---
 
+function stripMarkdownCode(content) {
+  let fenceLength = 0;
+
+  return content.split('\n').map((line) => {
+    if (fenceLength > 0) {
+      const closingFence = line.match(/^ {0,3}(`+)[ \t]*$/);
+      if (closingFence && closingFence[1].length >= fenceLength) fenceLength = 0;
+      return '';
+    }
+
+    const openingFence = line.match(/^ {0,3}(`{3,})([^`]*)$/);
+    if (openingFence) {
+      fenceLength = openingFence[1].length;
+      return '';
+    }
+
+    let prose = '';
+    for (let index = 0; index < line.length;) {
+      if (line[index] !== '`') {
+        prose += line[index++];
+        continue;
+      }
+
+      const start = index;
+      while (line[index] === '`') index++;
+      const delimiterLength = index - start;
+      let closingStart = index;
+
+      while (closingStart < line.length) {
+        closingStart = line.indexOf('`', closingStart);
+        if (closingStart === -1) break;
+        let closingEnd = closingStart;
+        while (line[closingEnd] === '`') closingEnd++;
+        if (closingEnd - closingStart === delimiterLength) {
+          index = closingEnd;
+          break;
+        }
+        closingStart = closingEnd;
+      }
+
+      if (closingStart === -1) prose += line.slice(start, index);
+    }
+    return prose;
+  }).join('\n');
+}
+
 function runAuditChecks(skill) {
   const fm = skill.frontmatter || {};
   const checks = [];
@@ -183,9 +229,7 @@ function runAuditChecks(skill) {
   });
 
   // 7. no XML tags in content (skip placeholders like <name>, <keyword>, code blocks)
-  const proseContent = skill.content
-    .replace(/```[\s\S]*?```/g, '')   // fenced code blocks
-    .replace(/`[^`\n]*`/g, '');        // inline code spans
+  const proseContent = stripMarkdownCode(skill.content);
   const xmlMatches = proseContent.match(/<[a-zA-Z][^>]*>/g) || [];
   // Single-letter tags like <X>/<N> are prose placeholders, not real XML.
   const placeholders = /^<(name|keyword|placeholder|value|type|path|file|dir|id|url|tag|description|your-|user-|project-|skill-|[a-zA-Z]>)/i;

package/commands/slop.js

@@ -32,6 +32,9 @@ const RULES = [
   { id: 'ai-purple-gradient', sev: 'error',
     re: /((from|via|to)-(purple|violet|indigo|fuchsia)-\d{2,3}\b|linear-gradient\([^)]*(#6366f1|#8b5cf6|#a855f7|#7c3aed|#4f46e5|\bpurple\b|\bviolet\b|\bindigo\b))/i,
     why: 'purple/indigo gradient: default "AI startup" palette' },
+  { id: 'rainbow-gradient', sev: 'warn',
+    re: /\bfrom-([a-z]+)-(?:[3-6]00)\b[^"'`]{0,60}\bto-(?!\1-)([a-z]+)-(?:[3-6]00)\b/i,
+    why: 'saturated two-color gradient fill across different hues (pink to orange, blue to cyan): the rainbow CTA reflex; use one solid brand color' },
   { id: 'ai-indigo-brand', sev: 'warn',
     re: /(#6366f1|#4f46e5|#4338ca|(?:bg|text|border|from|to|ring)-indigo-(?:500|600|700)\b)/i,
     why: 'canonical AI indigo used as brand color' },
@@ -44,6 +47,9 @@ const RULES = [
   { id: 'mega-shadow', sev: 'warn',
     re: /(shadow-2xl\b|box-shadow:\s*0\s+\d{2,}px)/i,
     why: 'oversized generic drop shadow (depth-by-blur)' },
+  { id: 'colored-glow-shadow', sev: 'warn',
+    re: /\bshadow-(?:indigo|violet|purple|fuchsia|blue|sky|cyan|pink|rose|emerald|green|teal)-(?:400|500|600)(?:\/\d{1,3})?\b/i,
+    why: 'colored glowing drop shadow under a button (shadow-<hue>-500): the neon-glow AI reflex; keep shadows soft and neutral' },
   { id: 'side-stripe-card', sev: 'warn',
     re: /border-(?:left|l)-(?:4|8|\[\d+px\])\b|border-left:\s*[3-9]px\s+solid/i,
     why: 'accent side-stripe on a card: generated layout reflex' },
@@ -53,6 +59,15 @@ const RULES = [
   { id: 'pulse-animation', sev: 'warn',
     re: /animation:[^;]*\binfinite\b|@keyframes\s+(pulse|ping|blink|glow|throb)\b|\banimate-(pulse|ping|bounce)\b/i,
     why: 'looping pulse/ping/glow animation: distracting live-status reflex' },
+  { id: 'hover-lift', sev: 'warn',
+    re: /\bhover:(?:-translate-y-(?:0\.5|[1-9]\d?)|scale-1(?:1[0-9]|[2-9]\d))\b/,
+    why: 'card lifts/over-grows on hover (translate-y shift or scale past 1.05): the generated-card reflex; keep hover scale subtle and never shift content' },
+  { id: 'decorative-blur-blob', sev: 'warn',
+    re: /\bblur-3xl\b|filter:\s*blur\(\s*(?:6[4-9]|[7-9]\d|\d{3,})px\)/i,
+    why: 'giant blurred gradient orb behind the hero (blur-3xl / 64px+ blur): the AI aurora-blob background reflex' },
+  { id: 'dark-hero-gradient', sev: 'warn',
+    re: /\b(?:from|via)-(?:slate|gray|zinc|neutral|stone)-9(?:00|50)\b[^"'`]{0,80}\bto-(?:black|(?:slate|gray|zinc|neutral|stone)-950)\b/i,
+    why: 'near-black slate/gray hero gradient fading to black: the dark premium SaaS template look' },
   { id: 'eyebrow-caps', sev: 'warn',
     re: /text-transform:\s*uppercase\b|\buppercase\b[^"'`]{0,30}tracking-|tracking-[^"'`]{0,30}\buppercase\b/i,
     why: 'tracked all-caps eyebrow/label: dated reflex; use sentence case' },
@@ -66,6 +81,23 @@ const RULES = [
   { id: 'hype-copy', sev: 'error',
     re: /\b(boost your productivity|supercharge|unleash|game[- ]?chang(?:er|ing)|seamlessly|effortlessly|revolutioniz(?:e|ing)|take your .{1,30} to the next level|elevate your|cutting[- ]edge|powered by ai|next[- ]generation)\b/i,
     why: 'hype/marketing slop phrase: say the specific thing instead' },
+  { id: 'kicker-dot-caps', sev: 'error',
+    re: /[●◉]\s*[A-Z][A-Z0-9]+(?:\s+[A-Z0-9]+)*\b/,
+    notFiles: /\.(md|mdx|txt)$/i, // prose/wireframe docs use ● as radio buttons and transport glyphs
+    why: 'dot char + all-caps label: the status-dot eyebrow kicker, the #1 banned hero pattern' },
+];
+
+// Pair rules: two regexes that must BOTH hit within a small line window. Catches
+// composites that span JSX lines (a dot element on one line, its label on the next).
+const PAIR_RULES = [
+  { id: 'hero-kicker', sev: 'error', span: 4,
+    a: /rounded-full[^"'`]{0,80}\b[wh]-(?:1(?:\.5)?|2(?:\.5)?|3)\b|\b[wh]-(?:1(?:\.5)?|2(?:\.5)?|3)\b[^"'`]{0,80}rounded-full/i,
+    b: /font-mono|tracking-(?:wide(?:r|st)?|\[)|text-\[?1[01]px|letter-spacing:\s*0?\.\d/i,
+    why: 'tiny status dot next to a small mono/tracked kicker label: banned hero-kicker composite' },
+  { id: 'pastel-icon-tile', sev: 'warn', span: 2,
+    a: /\bbg-(?:indigo|violet|purple|fuchsia|blue|sky|cyan|teal|emerald|green|lime|amber|orange|rose|pink|red)-(?:50|100)\b/i,
+    b: /\brounded(?:-(?:sm|md|lg|xl|2xl))?\b[^"'`]{0,80}\b(?:size-|[wh]-)(?:8|9|10|11|12|14|16)\b|\b(?:size-|[wh]-)(?:8|9|10|11|12|14|16)\b[^"'`]{0,80}\brounded(?:-(?:sm|md|lg|xl|2xl))?\b/i,
+    why: 'pastel-tinted rounded icon tile (small light-100 square holding an icon): the generated feature-card reflex' },
 ];
 
 const ICON = { error: '✗', warn: '⚠' }; // ✗  ⚠
@@ -167,7 +199,7 @@ function walk(target, out) {
   return out;
 }
 
-function scanFile(file, rules = RULES) {
+function scanFile(file, rules = RULES, pairRules = PAIR_RULES) {
   const findings = [];
   let text;
   try { text = fs.readFileSync(file, 'utf8'); } catch { return findings; }
@@ -175,6 +207,7 @@ function scanFile(file, rules = RULES) {
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     for (const rule of rules) {
+      if (rule.notFiles && rule.notFiles.test(file)) continue;
       const m = rule.re.exec(line);
       if (m) {
         findings.push({
@@ -184,6 +217,21 @@ function scanFile(file, rules = RULES) {
       }
     }
   }
+  for (const pr of pairRules) {
+    for (let i = 0; i < lines.length; i++) {
+      if (!pr.a.test(lines[i])) continue;
+      const lo = Math.max(0, i - pr.span), hi = Math.min(lines.length - 1, i + pr.span);
+      for (let j = lo; j <= hi; j++) {
+        if (pr.b.test(lines[j])) {
+          findings.push({
+            file, line: i + 1, rule: pr.id, sev: pr.sev, why: pr.why,
+            snippet: lines[i].trim().slice(0, 48),
+          });
+          break;
+        }
+      }
+    }
+  }
   return findings;
 }
 
@@ -304,4 +352,4 @@ function slopCommand(argv) {
   return 0;
 }
 
-module.exports = { slopCommand, detect, scanFile, RULES, loadProjectRules, addProjectRule, gitChangedLines, applyFixes, installHook };
+module.exports = { slopCommand, detect, scanFile, RULES, PAIR_RULES, loadProjectRules, addProjectRule, gitChangedLines, applyFixes, installHook };

package/commands/soul.js

@@ -121,7 +121,7 @@ function displaySoul(soul) {
   const line = '─'.repeat(W);
 
   console.log(`\n  ┌${line}┐`);
-  console.log(`  │ ${'◉ SOUL — ' + soul.project}${' '.repeat(Math.max(0, W - 10 - soul.project.length))}│`);
+  console.log(`  │ ${'soul · ' + soul.project}${' '.repeat(Math.max(0, W - 8 - soul.project.length))}│`);
   console.log(`  ├${line}┤`);
 
   // Identity