atris 3.15.54 → 3.15.56

package/commands/integrations.js

@@ -5,9 +5,13 @@
  *   atris gmail inbox       - List recent emails
  *   atris gmail read <id>   - Read specific email
  *   atris calendar today    - Show today's events
+ *   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 twitter post      - Post a tweet (interactive)
  *   atris slack channels    - List Slack channels
+ *   atris slack messages <channel> [--limit 20] - Read recent messages
+ *   atris slack search <query> [--limit 20] - Search Slack messages
  */
 
 const { loadCredentials, ensureValidCredentials } = require('../utils/auth');
@@ -137,12 +141,85 @@ async function gmailCommand(subcommand, ...args) {
 // CALENDAR
 // ============================================================================
 
-async function calendarToday() {
+function localDayBounds(offsetDays = 0) {
+  const start = new Date();
+  start.setHours(0, 0, 0, 0);
+  start.setDate(start.getDate() + offsetDays);
+  const end = new Date(start);
+  end.setDate(end.getDate() + 1);
+  return { start, end };
+}
+
+function localDateBounds(dateText) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(String(dateText || ''))) {
+    console.error('Usage: atris calendar date YYYY-MM-DD');
+    process.exit(1);
+  }
+  const start = new Date(`${dateText}T00:00:00`);
+  if (Number.isNaN(start.getTime())) {
+    console.error('Invalid date. Use YYYY-MM-DD.');
+    process.exit(1);
+  }
+  const end = new Date(start);
+  end.setDate(end.getDate() + 1);
+  return { start, end };
+}
+
+function calendarEventTimeValue(value) {
+  if (!value) return '';
+  if (typeof value === 'string') return value;
+  return value.dateTime || value.date || '';
+}
+
+function isDateOnly(value) {
+  return /^\d{4}-\d{2}-\d{2}$/.test(String(value || ''));
+}
+
+function formatCalendarTimeRange(event) {
+  const start = calendarEventTimeValue(event.start || event.start_time || event.startTime);
+  const end = calendarEventTimeValue(event.end || event.end_time || event.endTime);
+  if (!start || isDateOnly(start)) return 'All day';
+  const startDate = new Date(start);
+  if (Number.isNaN(startDate.getTime())) return 'Time unavailable';
+  const startText = startDate.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+  if (!end || isDateOnly(end)) return startText;
+  const endDate = new Date(end);
+  if (Number.isNaN(endDate.getTime())) return startText;
+  return `${startText}-${endDate.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' })}`;
+}
+
+function formatCalendarEvents(label, events) {
+  if (events.length === 0) {
+    console.log(`No events ${label}. 🎉`);
+    return;
+  }
+
+  console.log('─'.repeat(50));
+
+  for (const event of events) {
+    const time = formatCalendarTimeRange(event);
+    const title = event.summary || '(no title)';
+
+    console.log(`${time}  ${title}`);
+    if (event.location) {
+      console.log(`        📍 ${event.location}`);
+    }
+  }
+
+  console.log('─'.repeat(50));
+}
+
+async function calendarRange(label, { timeMin, timeMax, days } = {}) {
   const { token, email } = await getAuth();
 
-  console.log('📅 Today\'s events:\n');
+  console.log(`📅 ${label}:\n`);
 
-  const result = await apiRequestJson('/integrations/google-calendar/events/today', {
+  const params = new URLSearchParams();
+  if (timeMin) params.set('time_min', timeMin);
+  if (timeMax) params.set('time_max', timeMax);
+  if (days) params.set('days', String(days));
+  const suffix = params.toString() ? `?${params.toString()}` : '';
+  const result = await apiRequestJson(`/integrations/google-calendar/events${suffix}`, {
     method: 'GET',
     token,
   });
@@ -159,26 +236,25 @@ async function calendarToday() {
   }
 
   const events = result.data?.events || result.data || [];
+  formatCalendarEvents(label.toLowerCase(), events);
+}
 
-  if (events.length === 0) {
-    console.log('No events today. 🎉');
-    return;
-  }
-
-  console.log('─'.repeat(50));
+async function calendarToday() {
+  await calendarRange("Today's events", { days: 1 });
+}
 
-  for (const event of events) {
-    const start = event.start?.dateTime || event.start?.date || '';
-    const time = start ? new Date(start).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' }) : 'All day';
-    const title = event.summary || '(no title)';
+async function calendarYesterday() {
+  const { start, end } = localDayBounds(-1);
+  await calendarRange("Yesterday's events", { timeMin: start.toISOString(), timeMax: end.toISOString() });
+}
 
-    console.log(`${time}  ${title}`);
-    if (event.location) {
-      console.log(`        📍 ${event.location}`);
-    }
-  }
+async function calendarWeek() {
+  await calendarRange("This week's events", { days: 7 });
+}
 
-  console.log('─'.repeat(50));
+async function calendarDate(dateText) {
+  const { start, end } = localDateBounds(dateText);
+  await calendarRange(`Events on ${dateText}`, { timeMin: start.toISOString(), timeMax: end.toISOString() });
 }
 
 async function calendarCommand(subcommand, ...args) {
@@ -186,13 +262,22 @@ async function calendarCommand(subcommand, ...args) {
     case 'today':
       await calendarToday();
       break;
+    case 'yesterday':
+    case 'yday':
+      await calendarYesterday();
+      break;
     case 'week':
-      console.log('Week view coming soon...');
+      await calendarWeek();
+      break;
+    case 'date':
+      await calendarDate(args[0]);
       break;
     default:
       console.log('Calendar commands:');
-      console.log('  atris calendar today    - Show today\'s events');
-      console.log('  atris calendar week     - Show this week\'s events');
+      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');
   }
 }
 
@@ -270,7 +355,7 @@ async function slackChannels() {
 
   console.log('💬 Fetching Slack channels...\n');
 
-  const result = await apiRequestJson('/integrations/slack/channels', {
+  const result = await apiRequestJson('/integrations/slack/me/channels', {
     method: 'GET',
     token,
   });
@@ -298,8 +383,137 @@ async function slackChannels() {
   for (const ch of channels) {
     const name = ch.name || ch.id;
     const priv = ch.is_private ? '🔒' : '#';
-    console.log(`  ${priv} ${name}`);
+    console.log(`  ${priv} ${name}  ${ch.id || ''}`.trimEnd());
+  }
+}
+
+async function slackDms() {
+  const token = await getAuthToken();
+
+  console.log('💬 Fetching Slack DMs...\n');
+
+  const result = await apiRequestJson('/integrations/slack/me/dms', {
+    method: 'GET',
+    token,
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to fetch DMs'}`);
+    process.exit(1);
+  }
+
+  const dms = result.data?.dms || result.data?.channels || result.data || [];
+  if (!dms.length) {
+    console.log('No DMs found.');
+    return;
+  }
+  for (const dm of dms) {
+    const name = dm.name || dm.user_name || dm.user || dm.id;
+    console.log(`  ${name}  ${dm.id || ''}`.trimEnd());
+  }
+}
+
+function parseLimit(args, fallback = 20) {
+  const idx = args.findIndex((arg) => arg === '--limit' || arg === '-n');
+  const raw = idx >= 0 ? args[idx + 1] : '';
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, 100) : fallback;
+}
+
+function argsWithoutLimit(args = []) {
+  const out = [];
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === '--limit' || args[i] === '-n') {
+      i += 1;
+      continue;
+    }
+    out.push(args[i]);
+  }
+  return out;
+}
+
+async function slackPersonalChannels(token) {
+  const result = await apiRequestJson('/integrations/slack/me/channels', {
+    method: 'GET',
+    token,
+  });
+  if (!result.ok) return [];
+  return result.data?.channels || result.data || [];
+}
+
+async function resolveSlackChannel(token, channel) {
+  const text = String(channel || '').trim();
+  if (!text) return '';
+  if (/^[A-Z][A-Z0-9]{5,}$/.test(text)) return text;
+  const wanted = text.replace(/^#/, '').toLowerCase();
+  const channels = await slackPersonalChannels(token);
+  const match = channels.find((ch) => String(ch.name || '').toLowerCase() === wanted || String(ch.id || '').toLowerCase() === wanted);
+  return match?.id || text;
+}
+
+function formatSlackMessages(messages) {
+  if (!messages.length) {
+    console.log('No Slack messages found.');
+    return;
+  }
+  console.log('─'.repeat(60));
+  for (const message of messages) {
+    const author = message.user_name || message.username || message.user || message.sender || 'unknown';
+    const ts = message.datetime || message.time || message.ts || message.created_at || '';
+    const text = String(message.text || message.content || message.message || '').replace(/\s+/g, ' ').trim();
+    console.log(`${ts}  ${author}: ${text || '(no text)'}`);
   }
+  console.log('─'.repeat(60));
+}
+
+async function slackMessages(channel, args = []) {
+  if (!channel) {
+    console.error('Usage: atris slack messages <channel-or-id> [--limit 20]');
+    process.exit(1);
+  }
+  const token = await getAuthToken();
+  const limit = parseLimit(args);
+  const channelId = await resolveSlackChannel(token, channel);
+
+  console.log(`💬 Reading Slack messages from ${channel}...\n`);
+
+  const result = await apiRequestJson(`/integrations/slack/me/messages/${encodeURIComponent(channelId)}?limit=${limit}`, {
+    method: 'GET',
+    token,
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to fetch Slack messages'}`);
+    process.exit(1);
+  }
+
+  const messages = result.data?.messages || result.data || [];
+  formatSlackMessages(messages);
+}
+
+async function slackSearch(query, args = []) {
+  if (!query) {
+    console.error('Usage: atris slack search <query> [--limit 20]');
+    process.exit(1);
+  }
+  const token = await getAuthToken();
+  const limit = parseLimit(args);
+  const q = encodeURIComponent(query);
+
+  console.log(`💬 Searching Slack for "${query}"...\n`);
+
+  const result = await apiRequestJson(`/integrations/slack/me/search?q=${q}&count=${limit}`, {
+    method: 'GET',
+    token,
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to search Slack messages'}`);
+    process.exit(1);
+  }
+
+  const messages = result.data?.messages || result.data?.results || result.data || [];
+  formatSlackMessages(messages);
 }
 
 async function slackCommand(subcommand, ...args) {
@@ -308,9 +522,22 @@ async function slackCommand(subcommand, ...args) {
     case 'list':
       await slackChannels();
       break;
+    case 'dms':
+      await slackDms();
+      break;
+    case 'messages':
+    case 'read':
+      await slackMessages(args[0], args.slice(1));
+      break;
+    case 'search':
+      await slackSearch(argsWithoutLimit(args).join(' '), args);
+      break;
     default:
       console.log('Slack commands:');
-      console.log('  atris slack channels    - List Slack channels');
+      console.log('  atris slack channels             - List Slack channels');
+      console.log('  atris slack dms                  - List Slack DMs');
+      console.log('  atris slack messages <channel>   - Read recent messages');
+      console.log('  atris slack search <query>       - Search Slack messages');
   }
 }
 

package/commands/xp.js

@@ -1123,6 +1123,36 @@ function workspaceName(workspace) {
   return path.basename(workspace) || workspace;
 }
 
+function booleanSetting(value) {
+  if (value === true || value === false) return value;
+  const text = String(value || '').trim().toLowerCase();
+  if (['1', 'true', 'yes', 'public', 'global'].includes(text)) return true;
+  if (['0', 'false', 'no', 'private', 'internal', 'org'].includes(text)) return false;
+  return null;
+}
+
+function agentXpPublicBinding(binding = {}) {
+  const nested = binding.agentxp && typeof binding.agentxp === 'object' ? binding.agentxp : {};
+  const explicit = booleanSetting(
+    binding.agentxp_public
+    ?? binding.public_agentxp
+    ?? binding.agentxp_public_leaderboard
+    ?? nested.public
+    ?? nested.public_agentxp
+  );
+  if (explicit !== null) return explicit;
+
+  const visibility = slugify(binding.agentxp_visibility || nested.visibility);
+  if (visibility === 'public') return true;
+  if (['internal', 'private'].includes(visibility)) return false;
+
+  const scope = slugify(binding.agentxp_scope || nested.scope);
+  if (scope === 'global') return true;
+  if (['org', 'internal', 'private'].includes(scope)) return false;
+
+  return null;
+}
+
 function publicWorkspaceBinding(workspace) {
   const binding = readJsonFile(path.join(workspace, BUSINESS_BINDING_FILE), null);
   if (!binding || typeof binding !== 'object') return null;
@@ -1130,6 +1160,7 @@ function publicWorkspaceBinding(workspace) {
   const workspaceId = String(binding.workspace_id || '').trim();
   const businessSlug = slugify(binding.slug || binding.business_slug || binding.name);
   const workspaceTemplate = slugify(binding.workspace_template || binding.organization_type || binding.computer_type);
+  const agentxpPublic = agentXpPublicBinding(binding);
   if (!businessId && !workspaceId && !businessSlug) return null;
   return {
     business_id: businessId || null,
@@ -1138,6 +1169,7 @@ function publicWorkspaceBinding(workspace) {
     workspace_template: workspaceTemplate || null,
     computer: businessSlug || workspaceName(workspace),
     computer_slug: businessSlug || slugify(workspaceName(workspace)),
+    ...(agentxpPublic === null ? {} : { agentxp_public: agentxpPublic }),
   };
 }
 
@@ -1727,10 +1759,34 @@ function loadLocalPayload(args) {
   return normalizeLocalScore(JSON.parse(result.stdout), workspace);
 }
 
-function publicAgentXp(value) {
+function earnedAgentXp(value) {
+  return Math.max(0, asNumber(value));
+}
+
+function currentFormScore(value) {
   return Math.max(0, Math.min(99, asNumber(value)));
 }
 
+function agentXpLevelProgress(totalXp) {
+  const levelXp = Math.max(0, asNumber(totalXp));
+  const level = levelFromXp(levelXp);
+  const currentLevelFloor = (level - 1) * LEVEL_XP;
+  const nextLevelXp = level * LEVEL_XP;
+  const xpIntoLevel = levelXp - currentLevelFloor;
+  return {
+    schema: 'atris.agentxp_level_progress.v1',
+    level,
+    stage: `Level ${level}`,
+    level_xp: levelXp,
+    current_level_floor: currentLevelFloor,
+    next_level_xp: nextLevelXp,
+    xp_into_level: xpIntoLevel,
+    xp_to_next: Math.max(0, nextLevelXp - levelXp),
+    progress_pct: Math.max(0, Math.min(99, Math.round((xpIntoLevel / LEVEL_XP) * 100))),
+    uncapped: true,
+  };
+}
+
 function verifiedProjection(projection) {
   return projection?.integrity_status === 'verified'
     && projection?.integrity?.status === 'verified';
@@ -1768,19 +1824,22 @@ function uniqueTruthy(values) {
   return Array.from(new Set(values.map(value => String(value || '').trim()).filter(Boolean))).sort();
 }
 
-function syncAttribution(workspaces) {
+function syncAttribution(workspaces, options = {}) {
   const included = workspaces.filter(workspace => workspace.included !== false);
   const scoped = included.length ? included : workspaces;
   const businessIds = uniqueTruthy(scoped.map(workspace => workspace.business_id));
   const workspaceIds = uniqueTruthy(scoped.map(workspace => workspace.workspace_id));
   const businessSlugs = uniqueTruthy(scoped.map(workspace => workspace.business_slug || workspace.computer_slug));
   const templates = uniqueTruthy(scoped.map(workspace => workspace.workspace_template));
+  const explicitPublic = typeof options.publicAgentXp === 'boolean' ? options.publicAgentXp : null;
+  const workspacePublic = scoped.length === 1 && scoped[0]?.agentxp_public === true;
+  const agentxpPublic = explicitPublic === null ? (workspacePublic ? true : null) : explicitPublic;
 
   if (businessIds.length > 1) {
-    return { attribution_scope: 'multi_business', computer: 'multiple-workspaces' };
+    return { attribution_scope: 'multi_business', computer: 'multiple-workspaces', agentxp_public: explicitPublic === true };
   }
   if (businessIds.length === 0 && scoped.length > 1 && businessSlugs.length > 1) {
-    return { attribution_scope: 'multi_workspace', computer: 'multiple-workspaces' };
+    return { attribution_scope: 'multi_workspace', computer: 'multiple-workspaces', agentxp_public: explicitPublic === true };
   }
 
   const businessId = businessIds[0] || null;
@@ -1794,9 +1853,32 @@ function syncAttribution(workspaces) {
     business_slug: businessSlug,
     workspace_template: workspaceTemplate,
     computer: businessSlug || scoped[0]?.computer || scoped[0]?.name || 'local',
+    agentxp_public: agentxpPublic,
+  };
+}
+
+function syncScopeFields(attribution = {}) {
+  const attributionScope = slugify(attribution.attribution_scope);
+  const orgId = String(attribution.business_id || attribution.business_slug || '').trim() || null;
+  const businessBound = Boolean(orgId) || attributionScope === 'business-bound' || attributionScope === 'multi-business';
+  const publicAgentXp = typeof attribution.agentxp_public === 'boolean'
+    ? attribution.agentxp_public
+    : !businessBound;
+  return {
+    scope: publicAgentXp ? 'global' : (businessBound ? 'org' : 'global'),
+    org_id: orgId,
+    computer_id: String(attribution.workspace_id || attribution.computer || 'local').trim() || 'local',
+    visibility: publicAgentXp ? 'public' : 'internal',
+    public_agentxp: publicAgentXp,
   };
 }
 
+function publicAgentXpOverride(args = []) {
+  if (hasFlag(args, '--public')) return true;
+  if (hasFlag(args, '--private') || hasFlag(args, '--internal')) return false;
+  return null;
+}
+
 function credentialHandle(credentials) {
   return slugify(
     credentials?.username
@@ -1849,26 +1931,30 @@ function syncPlayer(args, projection) {
 
 function buildAgentXpSyncPacket(args = []) {
   const localMode = hasFlag(args, '--local') || hasFlag(args, '--workspace') || hasFlag(args, '--operator');
-  const projectionArgs = args.filter(arg => !['--dry-run', '--no-post', '--packet'].includes(arg));
+  const projectionArgs = args.filter(arg => !['--dry-run', '--no-post', '--packet', '--public', '--private', '--internal'].includes(arg));
   const projection = hasFlag(args, '--all') || !localMode
     ? collectAllLocalXpProjection(projectionArgs)
     : collectLocalXpProjection(projectionArgs);
   const player = syncPlayer(args, projection);
   const workspaces = projectionWorkspaceSummaries(projection);
-  const attribution = syncAttribution(workspaces);
+  const attribution = syncAttribution(workspaces, { publicAgentXp: publicAgentXpOverride(args) });
+  const scopeFields = syncScopeFields(attribution);
   const totalXp = asNumber(projection.total_agent_xp ?? projection.agent_xp ?? projection.total_xp ?? projection.career_xp);
   const receiptsCount = asNumber(projection.receipts_count);
   const eligible = verifiedProjection(projection) && receiptsCount > 0 && totalXp > 0;
-  const publicXp = publicAgentXp(totalXp);
+  const publicXp = earnedAgentXp(totalXp);
+  const currentForm = currentFormScore(totalXp);
+  const levelProgress = agentXpLevelProgress(publicXp);
   const workspaceRootHash = sha256(workspaces.map(item => item.workspace_root_hash || item.name).sort().join(':'));
   const entry = {
     user_id: player,
     username: player,
     agent_xp: publicXp,
     career_xp: publicXp,
-    current_form: publicXp,
-    ovr: publicXp,
-    level: Math.max(1, asNumber(projection.level, 1)),
+    current_form: currentForm,
+    ovr: currentForm,
+    level: levelProgress.level,
+    level_progress: levelProgress,
     verified_receipts: receiptsCount,
     reviewed_tasks: receiptsCount,
     recent_verified_receipts: receiptsCount,
@@ -1883,12 +1969,17 @@ function buildAgentXpSyncPacket(args = []) {
     schema: 'atris.agentxp_sync_packet.v1',
     generated_at: new Date().toISOString(),
     workspace_root_hash: workspaceRootHash,
+    scope: scopeFields.scope,
+    org_id: scopeFields.org_id,
     attribution_scope: attribution.attribution_scope,
     business_id: attribution.business_id || null,
     workspace_id: attribution.workspace_id || null,
     business_slug: attribution.business_slug || null,
     workspace_template: attribution.workspace_template || null,
+    computer_id: scopeFields.computer_id,
     computer: attribution.computer || projection.workspace_name || workspaces[0]?.name || 'local',
+    visibility: scopeFields.visibility,
+    public_agentxp: scopeFields.public_agentxp,
     operator: player,
     privacy: {
       raw_proofs_included: false,
@@ -1903,12 +1994,17 @@ function buildAgentXpSyncPacket(args = []) {
     local_evidence: {
       schema: 'atris.agentxp_local_evidence.v1',
       workspace_root_hash: workspaceRootHash,
+      scope: scopeFields.scope,
+      org_id: scopeFields.org_id,
       attribution_scope: attribution.attribution_scope,
       business_id: attribution.business_id || null,
       workspace_id: attribution.workspace_id || null,
       business_slug: attribution.business_slug || null,
       workspace_template: attribution.workspace_template || null,
+      computer_id: scopeFields.computer_id,
       computer: attribution.computer || null,
+      visibility: scopeFields.visibility,
+      public_agentxp: scopeFields.public_agentxp,
       workspaces,
       verified_workspace_count: asNumber(projection.verified_workspace_count, verifiedProjection(projection) ? 1 : 0),
       receipts_count: receiptsCount,
@@ -1933,12 +2029,17 @@ function buildAgentXpSyncPacket(args = []) {
     gm_projection: {
       schema: 'atris.gm_xp_projection.v1',
       workspace_root_hash: workspaceRootHash,
+      scope: scopeFields.scope,
+      org_id: scopeFields.org_id,
       attribution_scope: attribution.attribution_scope,
       business_id: attribution.business_id || null,
       workspace_id: attribution.workspace_id || null,
       business_slug: attribution.business_slug || null,
       workspace_template: attribution.workspace_template || null,
+      computer_id: scopeFields.computer_id,
       computer: attribution.computer || null,
+      visibility: scopeFields.visibility,
+      public_agentxp: scopeFields.public_agentxp,
       operator: player,
       player_score: {
         agent_xp: totalXp,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.15.54",
+  "version": "3.15.56",
   "main": "bin/atris.js",
   "bin": {
     "atris": "bin/atris.js",