atris 3.15.56 → 3.16.0

package/commands/integrations.js

@@ -8,6 +8,7 @@
  *   atris calendar yesterday - Show yesterday's events
  *   atris calendar week     - Show this week's events
  *   atris calendar date YYYY-MM-DD - Show events on a date
+ *   atris calendar search <query> [--days 30] [--limit 20] [--timeout-ms 10000] [--json] - Search upcoming events
  *   atris twitter post      - Post a tweet (interactive)
  *   atris slack channels    - List Slack channels
  *   atris slack messages <channel> [--limit 20] - Read recent messages
@@ -21,6 +22,8 @@ const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
+const CALENDAR_CACHE_PATH = path.join(os.homedir(), '.atris', 'calendar-events-cache.json');
+
 async function getAuth() {
   const ensured = await ensureValidCredentials(apiRequestJson);
   const creds = ensured.error ? null : ensured.credentials;
@@ -209,6 +212,166 @@ function formatCalendarEvents(label, events) {
   console.log('─'.repeat(50));
 }
 
+function parseCalendarSearchArgs(args = []) {
+  const values = [];
+  const options = { days: 30, limit: 20, timeoutMs: 10000, json: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--json') {
+      options.json = true;
+    } else if (arg === '--days' || arg === '-d') {
+      const parsed = Number.parseInt(args[i + 1], 10);
+      if (Number.isFinite(parsed) && parsed > 0) options.days = Math.min(parsed, 365);
+      i += 1;
+    } else if (arg === '--limit' || arg === '-n') {
+      const parsed = Number.parseInt(args[i + 1], 10);
+      if (Number.isFinite(parsed) && parsed > 0) options.limit = Math.min(parsed, 100);
+      i += 1;
+    } else if (arg === '--timeout-ms' || arg === '--timeout') {
+      const parsed = Number.parseInt(args[i + 1], 10);
+      if (Number.isFinite(parsed) && parsed > 0) options.timeoutMs = Math.min(parsed, 60000);
+      i += 1;
+    } else {
+      values.push(arg);
+    }
+  }
+  return { query: values.join(' ').trim(), ...options };
+}
+
+function calendarAttendeesText(attendees) {
+  if (!Array.isArray(attendees)) return '';
+  return attendees
+    .map((attendee) => {
+      if (typeof attendee === 'string') return attendee;
+      return [
+        attendee.email,
+        attendee.displayName,
+        attendee.name,
+        attendee.responseStatus,
+      ].filter(Boolean).join(' ');
+    })
+    .filter(Boolean)
+    .join(' ');
+}
+
+function calendarSearchText(event = {}) {
+  return [
+    event.summary,
+    event.title,
+    event.location,
+    event.description,
+    calendarAttendeesText(event.attendees),
+  ].filter(Boolean).join(' ').toLowerCase();
+}
+
+function filterCalendarEventsForSearch(events = [], query = '', limit = 20) {
+  const terms = String(query || '').toLowerCase().split(/\s+/).filter(Boolean);
+  if (!terms.length) return [];
+  return events
+    .filter((event) => {
+      const haystack = calendarSearchText(event);
+      return terms.every((term) => haystack.includes(term));
+    })
+    .slice(0, limit);
+}
+
+function compactCalendarEvent(event = {}) {
+  return {
+    id: event.id || event.event_id || '',
+    start: calendarEventTimeValue(event.start || event.start_time || event.startTime),
+    end: calendarEventTimeValue(event.end || event.end_time || event.endTime),
+    summary: event.summary || event.title || '(no title)',
+    location: event.location || '',
+    htmlLink: event.htmlLink || event.link || '',
+  };
+}
+
+function calendarCachePacket(events = [], meta = {}) {
+  return {
+    ok: true,
+    updatedAt: new Date().toISOString(),
+    source: meta.source || 'live',
+    days: meta.days || null,
+    count: events.length,
+    events: events.map(compactCalendarEvent),
+  };
+}
+
+function writeCalendarEventsCache(events = [], meta = {}) {
+  const rows = Array.isArray(events) ? events : [];
+  try {
+    fs.mkdirSync(path.dirname(CALENDAR_CACHE_PATH), { recursive: true });
+    fs.writeFileSync(CALENDAR_CACHE_PATH, `${JSON.stringify(calendarCachePacket(rows, meta), null, 2)}\n`, 'utf8');
+    return CALENDAR_CACHE_PATH;
+  } catch {
+    return '';
+  }
+}
+
+function readCalendarEventsCache() {
+  try {
+    const packet = JSON.parse(fs.readFileSync(CALENDAR_CACHE_PATH, 'utf8'));
+    const events = Array.isArray(packet.events) ? packet.events : [];
+    return {
+      ok: true,
+      path: CALENDAR_CACHE_PATH,
+      updatedAt: packet.updatedAt || '',
+      events,
+    };
+  } catch {
+    return { ok: false, path: CALENDAR_CACHE_PATH, updatedAt: '', events: [] };
+  }
+}
+
+function formatCalendarSearchResults(query, matches, {
+  json = false,
+  total = matches.length,
+  source = 'live',
+  liveOk = true,
+  cacheUpdatedAt = '',
+  error = '',
+} = {}) {
+  if (json) {
+    console.log(JSON.stringify({
+      ok: true,
+      query,
+      source,
+      liveOk,
+      cacheUpdatedAt,
+      error,
+      totalEvents: total,
+      matchCount: matches.length,
+      matches: matches.map(compactCalendarEvent),
+    }, null, 2));
+    return;
+  }
+
+  if (!matches.length) {
+    console.log(`No upcoming events matched "${query}".`);
+    return;
+  }
+
+  console.log(`Found ${matches.length} upcoming event(s) matching "${query}":\n`);
+  formatCalendarEvents('matching your search', matches);
+}
+
+function formatCalendarSearchError(query, message, { json = false, status = 0 } = {}) {
+  if (json) {
+    console.log(JSON.stringify({
+      ok: false,
+      query,
+      status,
+      error: message || 'Failed to fetch events',
+      totalEvents: 0,
+      matchCount: 0,
+      matches: [],
+    }, null, 2));
+    return;
+  }
+  console.error(`Error: ${message || 'Failed to fetch events'}`);
+  process.exit(1);
+}
+
 async function calendarRange(label, { timeMin, timeMax, days } = {}) {
   const { token, email } = await getAuth();
 
@@ -236,9 +399,63 @@ async function calendarRange(label, { timeMin, timeMax, days } = {}) {
   }
 
   const events = result.data?.events || result.data || [];
+  writeCalendarEventsCache(events, { source: 'calendarRange', days: days || null });
   formatCalendarEvents(label.toLowerCase(), events);
 }
 
+async function calendarSearch(args = []) {
+  const { query, days, limit, timeoutMs, json } = parseCalendarSearchArgs(args);
+  if (!query) {
+    console.error('Usage: atris calendar search <query> [--days 30] [--limit 20] [--timeout-ms 10000] [--json]');
+    process.exit(1);
+  }
+
+  const credentials = loadCredentials();
+  const token = credentials && credentials.token;
+  const email = credentials && credentials.email || 'unknown';
+  if (!token) {
+    formatCalendarSearchError(query, 'Not logged in. Run: atris login', { json, status: 401 });
+    return;
+  }
+  const result = await apiRequestJson(`/integrations/google-calendar/events?days=${encodeURIComponent(String(days))}`, {
+    method: 'GET',
+    token,
+    timeoutMs,
+    retries: 0,
+  });
+
+  if (!result.ok) {
+    const cache = readCalendarEventsCache();
+    if (json && cache.ok) {
+      const matches = filterCalendarEventsForSearch(cache.events, query, limit);
+      formatCalendarSearchResults(query, matches, {
+        json,
+        total: cache.events.length,
+        source: 'cache',
+        liveOk: false,
+        cacheUpdatedAt: cache.updatedAt,
+        error: result.error || 'Failed to fetch events',
+      });
+      return;
+    }
+    if (result.status === 400 || result.status === 401) {
+      formatCalendarSearchError(
+        query,
+        `Calendar not connected for ${email}. Connect at: https://atris.ai/dashboard/settings`,
+        { json, status: result.status },
+      );
+    } else {
+      formatCalendarSearchError(query, result.error || 'Failed to fetch events', { json, status: result.status || 0 });
+    }
+    return;
+  }
+
+  const events = result.data?.events || result.data || [];
+  writeCalendarEventsCache(events, { source: 'calendarSearch', days });
+  const matches = filterCalendarEventsForSearch(events, query, limit);
+  formatCalendarSearchResults(query, matches, { json, total: events.length, source: 'live', liveOk: true });
+}
+
 async function calendarToday() {
   await calendarRange("Today's events", { days: 1 });
 }
@@ -272,12 +489,16 @@ async function calendarCommand(subcommand, ...args) {
     case 'date':
       await calendarDate(args[0]);
       break;
+    case 'search':
+      await calendarSearch(args);
+      break;
     default:
       console.log('Calendar commands:');
       console.log('  atris calendar today          - Show today\'s events');
       console.log('  atris calendar yesterday      - Show yesterday\'s events');
       console.log('  atris calendar week           - Show this week\'s events');
       console.log('  atris calendar date YYYY-MM-DD - Show events on a date');
+      console.log('  atris calendar search <query> [--days 30] [--limit 20] [--timeout-ms 10000] [--json] - Search upcoming events');
   }
 }
 
@@ -1233,4 +1454,11 @@ module.exports = {
   imessageCommand,
   imessageDoctor,
   integrationsStatus,
+  parseCalendarSearchArgs,
+  filterCalendarEventsForSearch,
+  formatCalendarSearchResults,
+  formatCalendarSearchError,
+  writeCalendarEventsCache,
+  readCalendarEventsCache,
+  CALENDAR_CACHE_PATH,
 };

package/commands/lesson.js

@@ -2,6 +2,44 @@ const fs = require('fs');
 const path = require('path');
 const { writeLesson } = require('./autopilot');
 
+function mineLessons(args) {
+  const { loadHistory, mineProofPolicy, writePolicyLessons, syncLessonsMd } = require('../lib/policy-lessons');
+  const root = process.cwd();
+  const json = args.includes('--json');
+  const dryRun = args.includes('--dry-run');
+  const history = loadHistory(root);
+  const mined = mineProofPolicy(history);
+  let statePath = null;
+  let lessonsMd = { path: null, written: [] };
+  if (!dryRun) {
+    statePath = writePolicyLessons(root, mined);
+    lessonsMd = syncLessonsMd(root, mined);
+  }
+  if (json) {
+    console.log(JSON.stringify({
+      ok: true,
+      action: 'lesson_mine',
+      dry_run: dryRun,
+      state_path: statePath,
+      lessons_md_path: lessonsMd.path,
+      lessons_md_written: lessonsMd.written,
+      ...mined,
+    }, null, 2));
+    return;
+  }
+  const { sources } = mined;
+  console.log(`mined ${mined.lessons.length} policy lesson(s) from ${sources.career_xp_receipts} receipts / ${sources.task_episodes} episodes / ${sources.scorecards} scorecards (${sources.human_reviewed_episodes} human-reviewed)`);
+  for (const lesson of mined.lessons) {
+    console.log(`- policy-${lesson.id}: ${lesson.lesson}`);
+  }
+  if (dryRun) {
+    console.log('(dry-run: nothing written)');
+  } else {
+    console.log(`state: ${statePath}`);
+    console.log(`lessons.md: ${lessonsMd.written.length ? lessonsMd.written.map((id) => `policy-${id}`).join(', ') : 'no entries written'}`);
+  }
+}
+
 function lessonAtris(subcommand, ...args) {
   const atrisDir = path.join(process.cwd(), 'atris');
   if (!fs.existsSync(atrisDir)) {
@@ -9,9 +47,15 @@ function lessonAtris(subcommand, ...args) {
     process.exit(1);
   }
 
+  if (subcommand === 'mine') {
+    mineLessons(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('');
     process.exit(subcommand ? 1 : 0);
   }