swarmdo 1.30.0 → 1.37.0

package/v3/@swarmdo/cli/dist/src/commands/hotspots.js

@@ -13,7 +13,7 @@
  */
 import { execFileSync } from 'node:child_process';
 import { output } from '../output.js';
-import { parseGitLog, computeHotspots, formatHotspots } from '../hotspots/hotspots.js';
+import { parseGitLog, computeHotspots, formatHotspots, hotspotsToCsv } from '../hotspots/hotspots.js';
 const SORT_KEYS = ['risk', 'churn', 'commits', 'authors'];
 /** Read a numeric flag that the parser may deliver as a number OR a string. */
 function numFlag(v, def) {
@@ -33,6 +33,7 @@ async function run(ctx) {
     }
     // Global --format (text|json|table); text and table both render the table.
     const asJson = ctx.flags.format === 'json';
+    const asCsv = ctx.flags.csv === true; // dedicated flag (global --format has no csv choice)
     // Capture history: SOH-delimited header + numstat, no merges. `%aN` (not
     // `%an`) resolves author names through `.mailmap`, so name/email variants of
     // the same person fold into one identity — otherwise the author-spread factor
@@ -50,7 +51,10 @@ async function run(ctx) {
     }
     const now = Date.now();
     const spots = computeHotspots(parseGitLog(raw), now, { by, top: top > 0 ? top : undefined, minCommits });
-    if (asJson) {
+    if (asCsv) {
+        process.stdout.write(hotspotsToCsv(spots) + '\n');
+    }
+    else if (asJson) {
         process.stdout.write(JSON.stringify({ generated: new Date(now).toISOString(), by, count: spots.length, hotspots: spots }, null, 2) + '\n');
     }
     else {
@@ -72,10 +76,12 @@ export const hotspotsCommand = {
         { name: 'top', description: 'keep only the top N files (default 20; 0 = all)', type: 'string' },
         { name: 'min-commits', description: 'drop files with fewer than N commits (default 1)', type: 'string' },
         { name: 'by', description: `sort key: ${SORT_KEYS.join('|')} (default risk)`, type: 'string' },
+        { name: 'csv', description: 'export the ranking as CSV (for spreadsheets)', type: 'boolean' },
     ],
     examples: [
         { command: 'swarmdo hotspots src --since 90d', description: 'Risk hotspots under src/ in the last 90 days' },
         { command: 'swarmdo hotspots --by churn --top 10 --format json', description: 'Top-10 by churn as JSON' },
+        { command: 'swarmdo hotspots --csv > hotspots.csv', description: 'Export the risk ranking to CSV' },
     ],
     action: run,
 };

package/v3/@swarmdo/cli/dist/src/commands/index.js

@@ -100,6 +100,12 @@ const commandLoaders = {
     // Isolated git worktrees for parallel work (claude-squad/vibe-kanban demand)
     worktree: () => import('./worktree.js'),
     wt: () => import('./worktree.js'), // alias via loader key
+    // Cross-session agent mailbox (multiplayer swarms — dorsa_rohani demand)
+    comms: () => import('./comms.js'),
+    mailbox: () => import('./comms.js'), // alias via loader key
+    // Static audit of Claude Code permission rules (conflicts / dead / over-broad)
+    permissions: () => import('./permissions.js'),
+    perms: () => import('./permissions.js'), // alias via loader key
     // Export Claude Code sessions to Markdown (conversation-exporter demand)
     transcript: () => import('./transcript.js'),
     tx: () => import('./transcript.js'), // alias via loader key

package/v3/@swarmdo/cli/dist/src/commands/permissions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * permissions.ts — `swarmdo permissions` (alias `perms`) — audit Claude Code
+ * permission rules for conflicts, dead/shadowed rules, and over-broad grants.
+ *
+ * Complements `config lint` (which validates the hooks block): this reads the
+ * `permissions.allow` / `deny` / `ask` arrays from `.claude/settings.json` +
+ * `settings.local.json` (+ `~/.claude/settings.json` with `--global`), merges
+ * them into the effective ruleset Claude Code enforces, and runs the pure
+ * permissions/audit.ts analyzer. Read-only — never edits settings.
+ */
+import type { Command } from '../types.js';
+export declare const permissionsCommand: Command;
+export default permissionsCommand;
+//# sourceMappingURL=permissions.d.ts.map

package/v3/@swarmdo/cli/dist/src/commands/permissions.js

@@ -0,0 +1,92 @@
+/**
+ * permissions.ts — `swarmdo permissions` (alias `perms`) — audit Claude Code
+ * permission rules for conflicts, dead/shadowed rules, and over-broad grants.
+ *
+ * Complements `config lint` (which validates the hooks block): this reads the
+ * `permissions.allow` / `deny` / `ask` arrays from `.claude/settings.json` +
+ * `settings.local.json` (+ `~/.claude/settings.json` with `--global`), merges
+ * them into the effective ruleset Claude Code enforces, and runs the pure
+ * permissions/audit.ts analyzer. Read-only — never edits settings.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { output } from '../output.js';
+import { auditPermissions } from '../permissions/audit.js';
+const strArray = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string') : []);
+/** Extract permissions.allow/deny/ask from a settings file, or null if none. */
+function readPerms(file) {
+    try {
+        if (!existsSync(file))
+            return null;
+        const obj = JSON.parse(readFileSync(file, 'utf8'));
+        const perm = obj?.permissions;
+        if (!perm || typeof perm !== 'object')
+            return null;
+        const sets = { allow: strArray(perm.allow), deny: strArray(perm.deny), ask: strArray(perm.ask) };
+        return sets.allow.length + sets.deny.length + sets.ask.length > 0 ? sets : null;
+    }
+    catch {
+        return null;
+    }
+}
+export const permissionsCommand = {
+    name: 'permissions',
+    aliases: ['perms'],
+    description: 'Audit Claude Code permission rules (allow/deny/ask) for conflicts, dead/shadowed rules, and over-broad grants',
+    options: [
+        { name: 'global', description: 'Also include ~/.claude/settings.json', type: 'boolean' },
+        { name: 'strict', description: 'Exit 1 if any error-severity finding (CI gate)', type: 'boolean' },
+        { name: 'json', description: 'Machine-readable output', type: 'boolean' },
+    ],
+    examples: [
+        { command: 'swarmdo permissions', description: "Audit this project's permission rules" },
+        { command: 'swarmdo permissions --global --strict', description: 'Include user-global settings; fail on conflicts' },
+    ],
+    action: async (ctx) => {
+        const cwd = ctx.cwd || process.cwd();
+        const files = [join(cwd, '.claude', 'settings.json'), join(cwd, '.claude', 'settings.local.json')];
+        if (ctx.flags.global === true)
+            files.push(join(homedir(), '.claude', 'settings.json'));
+        const used = [];
+        const merged = { allow: [], deny: [], ask: [] };
+        for (const file of files) {
+            const p = readPerms(file);
+            if (!p)
+                continue;
+            used.push(file);
+            merged.allow.push(...(p.allow ?? []));
+            merged.deny.push(...(p.deny ?? []));
+            merged.ask.push(...(p.ask ?? []));
+        }
+        const totalRules = merged.allow.length + merged.deny.length + merged.ask.length;
+        if (used.length === 0) {
+            if (ctx.flags.json === true)
+                output.printJson({ files: [], rules: 0, findings: [] });
+            else
+                output.printInfo('No permission rules found in .claude/settings*.json.');
+            return { success: true };
+        }
+        const findings = auditPermissions(merged);
+        const errors = findings.filter((f) => f.severity === 'error').length;
+        const warns = findings.filter((f) => f.severity === 'warn').length;
+        if (ctx.flags.json === true) {
+            output.printJson({ files: used, rules: totalRules, findings });
+        }
+        else if (findings.length === 0) {
+            output.printSuccess(`permissions audit: ${totalRules} rule(s) across ${used.length} file(s) — no issues`);
+        }
+        else {
+            const icon = (s) => (s === 'error' ? '✖' : s === 'warn' ? '⚠' : '·');
+            output.writeln(output.bold('Permission audit') + output.dim(`  (${totalRules} rules, ${used.length} file${used.length === 1 ? '' : 's'})`));
+            for (const x of findings)
+                output.writeln(`  ${icon(x.severity)} ${output.dim(`[${x.rule}]`)} ${x.message}`);
+            output.writeln('');
+            output.writeln(`${errors} error${errors === 1 ? '' : 's'}, ${warns} warning${warns === 1 ? '' : 's'}, ${findings.length - errors - warns} info`);
+        }
+        const failed = ctx.flags.strict === true && errors > 0;
+        return { success: !failed, exitCode: failed ? 1 : 0, data: { rules: totalRules, findings } };
+    },
+};
+export default permissionsCommand;
+//# sourceMappingURL=permissions.js.map

package/v3/@swarmdo/cli/dist/src/commands/usage.js

@@ -24,8 +24,11 @@ import { forecastWindow, parseRateLimits, worstStatus, formatForecast, formatLim
 import { readFileSync } from 'node:fs';
 import { toCsv } from '../util/csv.js';
 import { projectMonthEnd, daysInMonthOf } from '../usage/spend-forecast.js';
+import { computeModelEfficiency } from '../usage/model-efficiency.js';
+import { detectSpikeDays } from '../usage/reflect.js';
 const VIEWS = {
     daily: { dimension: 'day', label: 'Date' },
+    weekly: { dimension: 'week', label: 'ISO week' },
     monthly: { dimension: 'month', label: 'Month' },
     models: { dimension: 'model', label: 'Model' },
     projects: { dimension: 'project', label: 'Project' },
@@ -401,6 +404,9 @@ function runReflectView(ctx, collection) {
         const k = `${e.model}\u0000${e.dateKey}`;
         const row = md.get(k) ?? { key: e.model, day: e.dateKey, totals: { costUsd: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, totalTokens: 0 } };
         row.totals.costUsd += e.costUsd;
+        row.totals.inputTokens += e.inputTokens; // needed for cache-savings pricing
+        row.totals.cacheWriteTokens += e.cacheWriteTokens;
+        row.totals.cacheReadTokens += e.cacheReadTokens;
         row.totals.totalTokens += e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
         md.set(k, row);
         // per-(project, day) fold (space separator is safe — dateKey is fixed-width)
@@ -439,9 +445,15 @@ function runReflectView(ctx, collection) {
     output.writeln(`  Total tokens       ${r.totals.totalTokens.toLocaleString()}`);
     if (r.busiestDay)
         output.writeln(`  Busiest day        ${r.busiestDay.day}  ${output.dim(`(${fmtCost(r.busiestDay.costUsd)}, ${r.busiestDay.totalTokens.toLocaleString()} tok)`)}`);
+    if (r.spikeDays.length) {
+        const top = r.spikeDays.slice(0, 3).map((s) => `${s.day} ${fmtCost(s.costUsd)} (${s.ratioToMedian.toFixed(1)}×)`).join(', ');
+        output.writeln(`  Spike days         ${top}  ${output.dim('vs median')}`);
+    }
     output.writeln(`  Longest streak     ${r.longestStreak} day${r.longestStreak === 1 ? '' : 's'}`);
     output.writeln(`  Avg / active day   ${fmtCost(r.avgCostPerActiveDay)}`);
     output.writeln(`  Cache read share   ${pctStr(r.cacheReadPct)}`);
+    if (r.cacheSavingsUsd > 0)
+        output.writeln(`  Cache saved        ${fmtCost(r.cacheSavingsUsd)}  ${output.dim('vs no caching')}`);
     if (delegation.toolCalls > 0) {
         output.writeln(`  Delegation         ${pctStr(delegation.ratio)}  ${output.dim(`(${delegation.taskCalls} of ${delegation.toolCalls} tool calls to subagents)`)}`);
     }
@@ -597,6 +609,16 @@ async function run(ctx) {
     }
     output.writeln(output.bold(`Claude Code usage — ${viewName}`) + (since || until ? output.dim(`  (${since ?? '…'} → ${until ?? '…'})`) : ''));
     renderTable(view.label, rows, grand);
+    if (viewName === 'models') {
+        // Effective cost per unit of useful output — surfaces models made expensive
+        // by heavy input/cache overhead, beyond their sticker output price.
+        const eff = computeModelEfficiency(aggregateUsage(collection.events, 'model'));
+        if (eff.length >= 2) {
+            const best = eff[0];
+            const worst = eff[eff.length - 1];
+            output.writeln(output.dim(`effective $/1M output — best ${best.model} ${fmtCost(best.costPerMOutput)}, worst ${worst.model} ${fmtCost(worst.costPerMOutput)}`));
+        }
+    }
     if (viewName === 'monthly') {
         // Month-end pace projection for the current calendar month.
         const today = localDateKey(new Date());
@@ -609,6 +631,16 @@ async function run(ctx) {
             output.writeln(output.dim(`${curMonth} on pace for ~${fmtCost(p.projectedUsd)}  (${fmtCost(p.monthToDateUsd)} over ${dom}/${p.daysInMonth} days · ~${fmtCost(p.remainingUsd)} to go)`));
         }
     }
+    if (viewName === 'sessions') {
+        // Outlier-session detection: a single runaway session (one work unit) is more
+        // actionable than a spike day. Run the same median-ratio detector over ALL
+        // sessions (not the top-N display slice) so the baseline is representative.
+        const spikes = detectSpikeDays(aggregateUsage(collection.events, 'session').map((r) => ({ day: r.key, costUsd: r.totals.costUsd })));
+        if (spikes.length > 0) {
+            const top = spikes.slice(0, 3).map((s) => `${s.day} ${fmtCost(s.costUsd)} (${s.ratioToMedian.toFixed(1)}× median)`).join(', ');
+            output.writeln(output.dim(`outlier sessions: ${top}`));
+        }
+    }
     output.writeln(output.dim(`${collection.filesScanned} transcript files · ${grand.entries} billed responses · sources: ${collection.dirsScanned.join(', ')}`));
     if (collection.unpricedModels.length > 0) {
         const { unpricedResponses, unpricedTokens } = unpricedStats(collection.events);
@@ -619,7 +651,7 @@ async function run(ctx) {
 export const usageCommand = {
     name: 'usage',
     aliases: ['cost'],
-    description: 'Claude Code token & cost analytics from local transcripts (daily|monthly|models|projects|sessions)',
+    description: 'Claude Code token & cost analytics from local transcripts (daily|weekly|monthly|models|projects|sessions)',
     options: [
         { name: 'since', description: 'inclusive start date (YYYY-MM-DD or YYYYMMDD)', type: 'string' },
         { name: 'until', description: 'inclusive end date (YYYY-MM-DD or YYYYMMDD)', type: 'string' },
@@ -630,6 +662,7 @@ export const usageCommand = {
     ],
     examples: [
         { command: 'swarmdo usage', description: 'Daily token/cost table across all local Claude Code sessions' },
+        { command: 'swarmdo usage weekly', description: 'Spend grouped by ISO week' },
         { command: 'swarmdo usage models --since 2026-07-01', description: 'Spend per model this month' },
         { command: 'swarmdo usage projects --json', description: 'Per-project totals as JSON' },
         { command: 'swarmdo usage monthly --csv > usage.csv', description: 'Export monthly spend to CSV' },

package/v3/@swarmdo/cli/dist/src/comms/mailbox.d.ts

@@ -0,0 +1,88 @@
+/**
+ * comms/mailbox.ts — pure engine for the cross-session agent mailbox (#44).
+ *
+ * A shared `.swarmdo/comms/store.json` lets any Claude Code session on the same
+ * repo/machine leave messages for another by session name ("multiplayer
+ * swarms"). This module is the pure, I/O-free core: the message model, immutable
+ * add, inbox filtering/ordering, read-state tracking, and retention. The command
+ * layer (`swarmdo comms`) supplies id/timestamp generation and fs persistence.
+ *
+ * A message addressed to `all` (case-insensitive) is a broadcast — it appears in
+ * every session's inbox.
+ */
+export interface Message {
+    id: string;
+    from: string;
+    to: string;
+    subject: string;
+    body: string;
+    /** ISO-8601 creation time. */
+    createdAt: string;
+    read: boolean;
+}
+export interface Mailbox {
+    messages: Record<string, Message>;
+    version: string;
+}
+/** The broadcast recipient — a message to this address reaches every inbox. */
+export declare const BROADCAST = "all";
+export declare function emptyMailbox(): Mailbox;
+/**
+ * Build a message. `id` and `createdAt` are injected (not generated here) so the
+ * engine stays pure and unit-testable; the command layer supplies a crypto id
+ * and the wall clock. from/to/subject are trimmed; a blank subject becomes
+ * '(no subject)'.
+ */
+export declare function createMessage(opts: {
+    id: string;
+    from: string;
+    to: string;
+    body: string;
+    createdAt: string;
+    subject?: string;
+}): Message;
+/** Immutably add a message. Same id is a no-op (idempotent delivery). */
+export declare function addMessage(box: Mailbox, msg: Message): Mailbox;
+export interface InboxFilter {
+    /** Recipient session name; matches this recipient plus `all` broadcasts. Omit for every message. */
+    to?: string;
+    /** Only messages from this sender (case-insensitive). */
+    from?: string;
+    /** Only unread messages. */
+    unreadOnly?: boolean;
+    /** Only messages created strictly after this ISO timestamp. */
+    since?: string;
+}
+/**
+ * Filter the mailbox to an inbox view, sorted NEWEST-FIRST (tiebreak by id).
+ * A `to` filter matches the named recipient and `all` broadcasts.
+ */
+export declare function filterInbox(box: Mailbox, filter?: InboxFilter): Message[];
+/** Count unread messages for a recipient (includes `all` broadcasts). */
+export declare function unreadCount(box: Mailbox, to?: string): number;
+/**
+ * Render a set of messages as a compact context block for hook delivery — the
+ * "surface new mail without polling" path. Returns '' for no messages (caller
+ * injects nothing). Each body is whitespace-collapsed and capped at maxBodyChars.
+ */
+export declare function renderInboxContext(messages: Message[], opts?: {
+    header?: string;
+    maxBodyChars?: number;
+}): string;
+/** Immutably mark the given ids read. Returns the new box + how many flipped unread→read. */
+export declare function markRead(box: Mailbox, ids: string[]): {
+    box: Mailbox;
+    marked: number;
+};
+/**
+ * Retention: drop READ messages older than maxAgeMs, then — if still over
+ * maxCount — drop the oldest READ messages until at the cap. UNREAD messages are
+ * never dropped (delivery is guaranteed until acknowledged). `nowMs` is injected
+ * to keep this pure.
+ */
+export declare function pruneMailbox(box: Mailbox, opts: {
+    maxAgeMs?: number;
+    maxCount?: number;
+    nowMs: number;
+}): Mailbox;
+//# sourceMappingURL=mailbox.d.ts.map

package/v3/@swarmdo/cli/dist/src/comms/mailbox.js

@@ -0,0 +1,138 @@
+/**
+ * comms/mailbox.ts — pure engine for the cross-session agent mailbox (#44).
+ *
+ * A shared `.swarmdo/comms/store.json` lets any Claude Code session on the same
+ * repo/machine leave messages for another by session name ("multiplayer
+ * swarms"). This module is the pure, I/O-free core: the message model, immutable
+ * add, inbox filtering/ordering, read-state tracking, and retention. The command
+ * layer (`swarmdo comms`) supplies id/timestamp generation and fs persistence.
+ *
+ * A message addressed to `all` (case-insensitive) is a broadcast — it appears in
+ * every session's inbox.
+ */
+/** The broadcast recipient — a message to this address reaches every inbox. */
+export const BROADCAST = 'all';
+export function emptyMailbox() {
+    return { messages: {}, version: '1.0.0' };
+}
+/**
+ * Build a message. `id` and `createdAt` are injected (not generated here) so the
+ * engine stays pure and unit-testable; the command layer supplies a crypto id
+ * and the wall clock. from/to/subject are trimmed; a blank subject becomes
+ * '(no subject)'.
+ */
+export function createMessage(opts) {
+    return {
+        id: opts.id,
+        from: (opts.from || '').trim() || 'unknown',
+        to: (opts.to || '').trim(),
+        subject: (opts.subject || '').trim() || '(no subject)',
+        body: opts.body ?? '',
+        createdAt: opts.createdAt,
+        read: false,
+    };
+}
+/** Immutably add a message. Same id is a no-op (idempotent delivery). */
+export function addMessage(box, msg) {
+    if (box.messages[msg.id])
+        return box;
+    return { ...box, messages: { ...box.messages, [msg.id]: msg } };
+}
+const eqCI = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
+/**
+ * Filter the mailbox to an inbox view, sorted NEWEST-FIRST (tiebreak by id).
+ * A `to` filter matches the named recipient and `all` broadcasts.
+ */
+export function filterInbox(box, filter = {}) {
+    const all = Object.values(box.messages || {});
+    const filtered = all.filter((m) => {
+        if (filter.to !== undefined && !(eqCI(m.to, filter.to) || eqCI(m.to, BROADCAST)))
+            return false;
+        if (filter.from !== undefined && !eqCI(m.from, filter.from))
+            return false;
+        if (filter.unreadOnly && m.read)
+            return false;
+        if (filter.since !== undefined && !(m.createdAt > filter.since))
+            return false;
+        return true;
+    });
+    return filtered.sort((a, b) => (a.createdAt < b.createdAt ? 1 : a.createdAt > b.createdAt ? -1 : a.id.localeCompare(b.id)));
+}
+/** Count unread messages for a recipient (includes `all` broadcasts). */
+export function unreadCount(box, to) {
+    return filterInbox(box, { to, unreadOnly: true }).length;
+}
+/**
+ * Render a set of messages as a compact context block for hook delivery — the
+ * "surface new mail without polling" path. Returns '' for no messages (caller
+ * injects nothing). Each body is whitespace-collapsed and capped at maxBodyChars.
+ */
+export function renderInboxContext(messages, opts = {}) {
+    if (!messages || messages.length === 0)
+        return '';
+    const header = opts.header ?? '## 📬 New messages (swarmdo comms)';
+    const maxBody = opts.maxBodyChars ?? 500;
+    const lines = [
+        header,
+        `You have ${messages.length} new message${messages.length === 1 ? '' : 's'} from other sessions:`,
+        '',
+    ];
+    for (const m of messages) {
+        const body = (m.body || '').replace(/\s+/g, ' ').trim();
+        const trimmed = body.length > maxBody ? body.slice(0, maxBody).trimEnd() + '…' : body;
+        lines.push(`- **from ${m.from}** — ${m.subject}: ${trimmed}`);
+    }
+    return lines.join('\n');
+}
+/** Immutably mark the given ids read. Returns the new box + how many flipped unread→read. */
+export function markRead(box, ids) {
+    const idSet = new Set(ids);
+    let marked = 0;
+    const messages = {};
+    for (const [id, m] of Object.entries(box.messages || {})) {
+        if (idSet.has(id) && !m.read) {
+            messages[id] = { ...m, read: true };
+            marked++;
+        }
+        else {
+            messages[id] = m;
+        }
+    }
+    return { box: marked ? { ...box, messages } : box, marked };
+}
+/**
+ * Retention: drop READ messages older than maxAgeMs, then — if still over
+ * maxCount — drop the oldest READ messages until at the cap. UNREAD messages are
+ * never dropped (delivery is guaranteed until acknowledged). `nowMs` is injected
+ * to keep this pure.
+ */
+export function pruneMailbox(box, opts) {
+    const entries = Object.values(box.messages || {});
+    const keep = new Map();
+    const droppableRead = [];
+    for (const m of entries) {
+        if (!m.read) {
+            keep.set(m.id, m);
+            continue;
+        }
+        const ageMs = opts.nowMs - Date.parse(m.createdAt);
+        if (opts.maxAgeMs !== undefined && Number.isFinite(ageMs) && ageMs > opts.maxAgeMs)
+            continue; // aged out
+        keep.set(m.id, m);
+        droppableRead.push(m);
+    }
+    if (opts.maxCount !== undefined && keep.size > opts.maxCount) {
+        // Drop oldest read first until at the cap (unread are never in droppableRead).
+        droppableRead.sort((a, b) => (a.createdAt < b.createdAt ? -1 : 1));
+        for (const m of droppableRead) {
+            if (keep.size <= opts.maxCount)
+                break;
+            keep.delete(m.id);
+        }
+    }
+    const messages = {};
+    for (const [id, m] of keep)
+        messages[id] = m;
+    return { ...box, messages };
+}
+//# sourceMappingURL=mailbox.js.map

package/v3/@swarmdo/cli/dist/src/comms/store.d.ts

@@ -0,0 +1,21 @@
+/**
+ * comms/store.ts — fs persistence + identity for the cross-session mailbox (#44).
+ *
+ * Shared by the `swarmdo comms` CLI command AND the comms_send/comms_inbox MCP
+ * tools so both read/write the SAME `.swarmdo/comms/store.json` under a given
+ * project root. The pure message logic lives in mailbox.ts; this is only I/O.
+ */
+import { type Mailbox } from './mailbox.js';
+/** Retention applied opportunistically on send: keep read messages ≤30d, ≤500 total. */
+export declare const RETENTION: {
+    maxAgeMs: number;
+    maxCount: number;
+};
+export declare function storePath(cwd: string): string;
+export declare function loadMailbox(cwd: string): Mailbox;
+export declare function saveMailbox(cwd: string, box: Mailbox): void;
+/** This session's name: explicit override → SWARMDO_SESSION → hostname → "me". */
+export declare function resolveSelf(flag?: unknown): string;
+/** Crypto-strong message id. */
+export declare function newMessageId(): string;
+//# sourceMappingURL=store.d.ts.map

package/v3/@swarmdo/cli/dist/src/comms/store.js

@@ -0,0 +1,44 @@
+/**
+ * comms/store.ts — fs persistence + identity for the cross-session mailbox (#44).
+ *
+ * Shared by the `swarmdo comms` CLI command AND the comms_send/comms_inbox MCP
+ * tools so both read/write the SAME `.swarmdo/comms/store.json` under a given
+ * project root. The pure message logic lives in mailbox.ts; this is only I/O.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { hostname } from 'node:os';
+import { emptyMailbox } from './mailbox.js';
+const STORE_REL = join('.swarmdo', 'comms', 'store.json');
+/** Retention applied opportunistically on send: keep read messages ≤30d, ≤500 total. */
+export const RETENTION = { maxAgeMs: 30 * 24 * 3600 * 1000, maxCount: 500 };
+export function storePath(cwd) {
+    return join(cwd, STORE_REL);
+}
+export function loadMailbox(cwd) {
+    try {
+        const p = storePath(cwd);
+        if (existsSync(p))
+            return JSON.parse(readFileSync(p, 'utf-8'));
+    }
+    catch {
+        /* corrupt/missing → fresh mailbox */
+    }
+    return emptyMailbox();
+}
+export function saveMailbox(cwd, box) {
+    const p = storePath(cwd);
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify(box, null, 2) + '\n', 'utf-8');
+}
+/** This session's name: explicit override → SWARMDO_SESSION → hostname → "me". */
+export function resolveSelf(flag) {
+    const f = typeof flag === 'string' ? flag.trim() : '';
+    return f || (process.env.SWARMDO_SESSION || '').trim() || hostname() || 'me';
+}
+/** Crypto-strong message id. */
+export function newMessageId() {
+    return 'msg_' + randomBytes(6).toString('hex');
+}
+//# sourceMappingURL=store.js.map

package/v3/@swarmdo/cli/dist/src/compact/compact.js

@@ -60,7 +60,10 @@ function collapseRepeats(lines, minRun) {
             j++;
         const run = j - i;
         out.push(lines[i]);
-        if (run >= minRun)
+        // `run > 1` guards the degenerate minRun=1 case: a single (non-repeated)
+        // line is a "run of 1" and must never get a `(×1)` marker — only genuine
+        // repeats (2+) collapse.
+        if (run > 1 && run >= minRun)
             out.push(`  … (×${run})`);
         else
             for (let k = 1; k < run; k++)

package/v3/@swarmdo/cli/dist/src/compact-snapshot/compact-snapshot.js

@@ -23,10 +23,15 @@ const DEFAULT_MAX_FILES = 12;
 export function porcelainPath(line) {
     if (!line || line.length < 4)
         return null;
+    const status = line.slice(0, 2); // XY status code
     let rest = line.slice(3); // strip the 2 status chars + the separating space
-    const arrow = rest.indexOf(' -> ');
-    if (arrow >= 0)
-        rest = rest.slice(arrow + 4); // rename/copy → destination path
+    // Only a rename/copy (status R or C) uses `<old> -> <new>`; for any other
+    // status a literal ` -> ` is part of the real filename and must NOT be split.
+    if (/[RC]/.test(status)) {
+        const arrow = rest.indexOf(' -> ');
+        if (arrow >= 0)
+            rest = rest.slice(arrow + 4); // destination path
+    }
     rest = rest.trim();
     if (rest.startsWith('"') && rest.endsWith('"') && rest.length >= 2) {
         rest = rest.slice(1, -1); // unwrap git's quoted path (escapes left as-is)

package/v3/@swarmdo/cli/dist/src/config-lint/lint.d.ts

@@ -31,7 +31,7 @@ export declare function lintSettingsHooks(file: string, obj: unknown): Finding[]
 /** .mcp.json: server entry SHAPES only (mcp doctor probes the runtime). */
 export declare function lintMcpConfig(file: string, obj: unknown): Finding[];
 /** Pre-1.4 layout leftovers: flat commands / unprefixed skill duplicates. */
-export declare function lintLegacyLayout(commandsRoot: string[], skills: string[]): Finding[];
+export declare function lintLegacyLayout(commandsRoot: string[], skills: string[], sdoCommands?: string[]): Finding[];
 export interface LintInput {
     swarmdoConfig?: {
         file: string;
@@ -46,6 +46,8 @@ export interface LintInput {
         raw: string | null;
     };
     commandsRoot?: string[];
+    /** entries under `.claude/commands/sDo/` — used to identify flat pre-1.4 twins */
+    sdoCommands?: string[];
     skills?: string[];
 }
 export interface LintReport {

package/v3/@swarmdo/cli/dist/src/config-lint/lint.js

@@ -158,11 +158,18 @@ export function lintMcpConfig(file, obj) {
     return out;
 }
 /** Pre-1.4 layout leftovers: flat commands / unprefixed skill duplicates. */
-export function lintLegacyLayout(commandsRoot, skills) {
+export function lintLegacyLayout(commandsRoot, skills, sdoCommands = []) {
     const out = [];
-    const flat = commandsRoot.filter((n) => n !== 'sDo');
+    // A flat command is a pre-1.4 swarmdo leftover ONLY if the same command also
+    // exists under sDo/ today (a twin) — mirroring the skill twin-check below.
+    // `.claude/commands/` is Claude Code's shared, ecosystem-wide slash-command
+    // dir, so a user's own command namespace or another plugin's coexisting with
+    // sDo/ must NOT be flagged merely for not being `sDo` (that was #66).
+    const base = (n) => n.replace(/\.md$/, '');
+    const sdoBase = new Set(sdoCommands.map(base));
+    const flat = commandsRoot.filter((n) => n !== 'sDo' && sdoBase.has(base(n)));
     if (flat.length > 0) {
-        out.push(f('.claude/commands', 'warn', 'pre-1.4-commands', `${flat.length} entr${flat.length === 1 ? 'y' : 'ies'} outside the sDo/ namespace (${flat.slice(0, 5).join(', ')}${flat.length > 5 ? ', …' : ''}) — swarmdo commands moved to /sDo:* in v1.4.0; re-run \`swarmdo init --force\` to migrate swarmdo-owned ones`));
+        out.push(f('.claude/commands', 'warn', 'pre-1.4-commands', `${flat.length} swarmdo command${flat.length === 1 ? '' : 's'} left flat outside the sDo/ namespace (${flat.slice(0, 5).join(', ')}${flat.length > 5 ? ', …' : ''}) — swarmdo commands moved to /sDo:* in v1.4.0; re-run \`swarmdo init --force\` to migrate them`));
     }
     const skillSet = new Set(skills);
     const dupes = skills.filter((s) => !s.startsWith('sdo-') && skillSet.has(`sdo-${s}`));
@@ -186,7 +193,7 @@ export function lintAll(input) {
         const { obj, findings: jf } = lintJson(input.mcpConfig.file, input.mcpConfig.raw);
         findings.push(...jf, ...lintMcpConfig(input.mcpConfig.file, obj));
     }
-    findings.push(...lintLegacyLayout(input.commandsRoot ?? [], input.skills ?? []));
+    findings.push(...lintLegacyLayout(input.commandsRoot ?? [], input.skills ?? [], input.sdoCommands ?? []));
     return {
         findings,
         errors: findings.filter((x) => x.severity === 'error').length,