atris 3.16.1 → 3.17.0

package/commands/deck.js

@@ -0,0 +1,135 @@
+// atris deck — generate a premium, on-brand Google Slides deck from a plain
+// content spec, using the Atris deck engine (lib/slides-deck.js). The pitch:
+// describe the deck, get the design system for free. No Arial-on-white slop.
+//
+// Usage:
+//   atris deck themes                         list design themes
+//   atris deck build <spec.json> [--title T] [--theme terminal|paper] [--update ID]
+//   atris deck sample [--theme paper]         print a starter spec to stdout
+//
+// A spec is JSON: { theme, brand:{name,accent}, slides:[ {type,...} ] }.
+// Slide types: title, statement, columns, panel, chips, bignumber, close.
+
+const fs = require('fs');
+const https = require('https');
+const os = require('os');
+const { buildDeck, THEMES } = require('../lib/slides-deck');
+
+const BASE = 'api.atris.ai';
+const PFX = '/api/integrations/google-slides';
+
+function token() {
+  try { return require(os.homedir() + '/.atris/credentials.json').token; }
+  catch { return null; }
+}
+function api(method, path, body, tok) {
+  return new Promise((resolve, reject) => {
+    const data = body ? JSON.stringify(body) : null;
+    const req = https.request({ host: BASE, path: PFX + path, method,
+      headers: { Authorization: 'Bearer ' + tok, 'Content-Type': 'application/json',
+        ...(data ? { 'Content-Length': Buffer.byteLength(data) } : {}) } },
+      (res) => { let b = ''; res.on('data', (c) => (b += c)); res.on('end', () => {
+        let j; try { j = JSON.parse(b); } catch { j = b; }
+        if (res.statusCode >= 300) reject(new Error('HTTP ' + res.statusCode + ': ' + (typeof j === 'string' ? j : JSON.stringify(j)).slice(0, 600)));
+        else resolve(j); }); });
+    req.on('error', reject); if (data) req.write(data); req.end();
+  });
+}
+
+const SAMPLE = {
+  theme: 'terminal',
+  brand: { name: 'Sentinel', accent: '.' },
+  slides: [
+    { type: 'title', headline: 'Read your incidents in the **dark.**',
+      sub: "On-call shouldn't mean panic. Every alert ranked by blast radius, in one calm view.",
+      panel: { header: { title: 'Active incidents', meta: 'updated 12s ago' },
+        rows: [
+          { title: 'Checkout latency spike', sub: 'api-gateway · us-east-1', value: '42%', valueSub: 'of traffic', sev: 0, active: true },
+          { title: 'Stale read replica', sub: 'orders-db · eu-west-2', value: '8%', valueSub: 'of traffic', sev: 1 },
+          { title: 'Elevated 4xx on search', sub: 'search-svc · global', value: '1.2%', valueSub: 'of traffic', sev: 2 },
+        ], footer: { left: '3 active, 1 worth a page', right: 'View all' } } },
+    { type: 'statement', text: "On-call shouldn't mean **panic.**",
+      sub: 'So the console is calm by default. One screen, ranked by real impact.' },
+    { type: 'columns', heading: 'What makes it calm', columns: [
+      { h: 'Ranked by impact', b: 'Severity comes from real blast radius, so the top of the list is the thing to fix.' },
+      { h: 'Quiet by default', b: 'One page-worthy signal per incident. The rest stays in the log until you ask.' },
+      { h: 'Built for 3am', b: 'High contrast, keyboard-first, and readable before you are fully awake.' } ] },
+    { type: 'bignumber', number: '11 min', label: 'median time to first action', sub: 'down from 47 minutes before Sentinel.' },
+    { type: 'close', tagline: 'Read your incidents in the dark.',
+      buttons: [{ label: 'Open the console', primary: true }, { label: 'Read the docs' }], footer: 'sentinel.sh · 2026' },
+  ],
+};
+
+async function run(argv) {
+  const sub = argv[0];
+
+  if (sub === 'themes') {
+    console.log('\n  atris deck themes:\n');
+    for (const [name, t] of Object.entries(THEMES)) {
+      console.log(`  ${name.padEnd(10)} ${t.fonts.display} + ${t.fonts.body}  ·  accent ${t.color.accent}  bg ${t.color.bg}`);
+    }
+    console.log('\n  slide types: title, statement, columns, panel, chips, bignumber, close\n');
+    return 0;
+  }
+
+  if (sub === 'sample') {
+    const theme = flag(argv, '--theme') || 'terminal';
+    console.log(JSON.stringify({ ...SAMPLE, theme }, null, 2));
+    return 0;
+  }
+
+  if (sub === 'build') {
+    const specPath = argv.slice(1).find((a) => !a.startsWith('-'));
+    if (!specPath) { console.error('  usage: atris deck build <spec.json> [--title T] [--theme x] [--update ID]'); return 2; }
+    let spec;
+    try { spec = JSON.parse(fs.readFileSync(specPath, 'utf8')); }
+    catch (e) { console.error(`  cannot read spec: ${e.message}`); return 2; }
+    const themeOverride = flag(argv, '--theme'); if (themeOverride) spec.theme = themeOverride;
+    if (!THEMES[spec.theme]) { console.error(`  unknown theme "${spec.theme}". try: ${Object.keys(THEMES).join(', ')}`); return 2; }
+    const title = flag(argv, '--title') || `${(spec.brand && spec.brand.name) || 'Atris'} deck`;
+
+    const tok = token();
+    if (!tok) { console.error('  no credentials at ~/.atris/credentials.json — run `atris login` and connect Google Drive.'); return 1; }
+
+    const { requests } = buildDeck(spec);
+
+    let id, firstSlide;
+    const updateId = flag(argv, '--update');
+    if (updateId) {
+      id = updateId;
+      const got = await api('GET', `/presentations/${id}`, null, tok);
+      const slides = got.slides || (got.presentation && got.presentation.slides) || [];
+      firstSlide = slides[0] && slides[0].objectId;
+    } else {
+      const pres = await api('POST', '/presentations', { title }, tok);
+      id = pres.presentationId || pres.id || (pres.presentation && pres.presentation.presentationId);
+      const slides = pres.slides || (pres.presentation && pres.presentation.slides) || [];
+      firstSlide = slides[0] && slides[0].objectId;
+    }
+
+    const reqs = firstSlide ? [...requests, { deleteObject: { objectId: firstSlide } }] : requests;
+    console.log(`  building ${spec.slides.length} slides (${spec.theme}) · ${reqs.length} ops...`);
+    await api('POST', `/presentations/${id}/batch-update`, { requests: reqs }, tok);
+
+    const url = `https://docs.google.com/presentation/d/${id}/edit`;
+    console.log(`\n  ✓ deck ready: ${url}\n`);
+    return 0;
+  }
+
+  console.log(`
+  atris deck — premium Google Slides from a plain content spec
+
+    atris deck sample [--theme paper] > my.json   start from a sample spec
+    atris deck build my.json [--title "Q3 review"] create the deck, print the URL
+    atris deck build my.json --update <id>         rebuild into an existing deck
+    atris deck themes                              list design themes
+
+  Design system is baked in: distinctive fonts, one accent, real data panels,
+  and no AI tells (em dashes sanitized, sentence-case labels, no gradient text).
+`);
+  return 0;
+}
+
+function flag(argv, name) { const i = argv.indexOf(name); return i !== -1 ? argv[i + 1] : null; }
+
+module.exports = { run, SAMPLE };

package/commands/init.js

@@ -42,6 +42,26 @@ function detectProjectContext(projectRoot = process.cwd()) {
     }
   }
 
+  // Python frameworks may be declared in requirements.txt OR pyproject.toml
+  // (the modern standard). Read whichever exist so a pyproject-only Django/FastAPI
+  // project isn't mislabeled as plain "python".
+  const detectPythonFramework = () => {
+    try {
+      let text = '';
+      for (const f of ['requirements.txt', 'pyproject.toml']) {
+        const p = path.join(projectRoot, f);
+        if (fs.existsSync(p)) text += fs.readFileSync(p, 'utf8') + '\n';
+      }
+      const lower = text.toLowerCase();
+      if (lower.includes('django')) return 'django';
+      if (lower.includes('flask')) return 'flask';
+      if (lower.includes('fastapi')) return 'fastapi';
+      return 'python';
+    } catch (e) {
+      return 'python';
+    }
+  };
+
   // Check for framework indicators
   const frameworks = {
     'package.json': () => {
@@ -62,17 +82,8 @@ function detectProjectContext(projectRoot = process.cwd()) {
         return 'nodejs';
       }
     },
-    'requirements.txt': () => {
-      try {
-        const req = fs.readFileSync(path.join(projectRoot, 'requirements.txt'), 'utf8');
-        if (req.includes('django')) return 'django';
-        if (req.includes('flask')) return 'flask';
-        if (req.includes('fastapi')) return 'fastapi';
-        return 'python';
-      } catch (e) {
-        return 'python';
-      }
-    },
+    'requirements.txt': detectPythonFramework,
+    'pyproject.toml': detectPythonFramework,
     'Gemfile': () => {
       try {
         const gemfile = fs.readFileSync(path.join(projectRoot, 'Gemfile'), 'utf8');

package/commands/lesson.js

@@ -1,6 +1,76 @@
 const fs = require('fs');
 const path = require('path');
 const { writeLesson } = require('./autopilot');
+const { detectLessonContradictions } = require('../lib/lesson-contradiction');
+const taskDb = require('../lib/task-db');
+
+function sweepLessons(args) {
+  const cwd = process.cwd();
+  const json = args.includes('--json');
+  const dryRun = args.includes('--dry-run');
+
+  const contradictions = detectLessonContradictions(cwd);
+
+  if (json) {
+    console.log(JSON.stringify({
+      ok: true,
+      action: 'lesson_sweep',
+      dry_run: dryRun,
+      contradictions_found: contradictions.length,
+      tasks_created: dryRun ? 0 : contradictions.length,
+      contradictions: contradictions.map(c => ({
+        type: c.type,
+        slug: c.slug,
+        evidence: c.evidence,
+      })),
+    }, null, 2));
+    return;
+  }
+
+  if (dryRun) {
+    console.log(`found ${contradictions.length} lesson contradiction(s):`);
+    for (const c of contradictions) {
+      console.log(`- [${c.type}] ${c.slug}: ${c.evidence}`);
+    }
+    console.log('(dry-run: no tasks created)');
+    return;
+  }
+
+  // Create idempotent dissolve tasks for each contradiction
+  let created = 0;
+  const db = taskDb.open();
+  try {
+    const workspaceRoot = taskDb.workspaceRoot(cwd);
+    for (const contradiction of contradictions) {
+      const sourceKey = `lesson-contradiction-${contradiction.slug}`;
+      const title = `dissolve lesson: ${contradiction.slug} (${contradiction.type})`;
+
+      const result = db.prepare(
+        'SELECT id FROM tasks WHERE workspace_root = ? AND source_key = ?'
+      ).get(workspaceRoot, sourceKey);
+
+      if (!result) {
+        taskDb.addTask(db, {
+          title,
+          tag: 'lesson-contradiction',
+          workspaceRoot,
+          sourceKey,
+          metadata: {
+            lesson_slug: contradiction.slug,
+            contradiction_type: contradiction.type,
+            evidence: contradiction.evidence,
+          },
+          status: 'open',
+        });
+        created++;
+      }
+    }
+  } finally {
+    db.close();
+  }
+
+  console.log(`created ${created} idempotent dissolve task(s) from ${contradictions.length} contradiction(s)`);
+}
 
 function mineLessons(args) {
   const { loadHistory, mineProofPolicy, writePolicyLessons, syncLessonsMd } = require('../lib/policy-lessons');
@@ -52,10 +122,16 @@ function lessonAtris(subcommand, ...args) {
     return;
   }
 
+  if (subcommand === 'sweep') {
+    sweepLessons(args);
+    return;
+  }
+
   if (subcommand !== 'add') {
     console.log('');
     console.log('  Usage: atris lesson add <slug> <pass|fail> "<text>"');
     console.log('         atris lesson mine [--json] [--dry-run]');
+    console.log('         atris lesson sweep [--json] [--dry-run]');
     console.log('');
     process.exit(subcommand ? 1 : 0);
   }