swarmdo 1.58.6 → 1.58.12

package/v3/@swarmdo/cli/dist/src/integrations/skills-sync.d.ts

@@ -0,0 +1,120 @@
+/**
+ * skills-sync.ts — sync curated swarmdo skills into the cross-agent skill dirs.
+ *
+ * SKILL.md is a universal cross-agent standard (2026): Codex, pi, Copilot, and
+ * Cursor all read skills from a `<dir>/SKILL.md` layout with `name`+`description`
+ * YAML frontmatter. swarmdo already ships its surface as `sdo-*` skills, so the
+ * "integration" for these tools is a near-passthrough copy — no per-tool format
+ * conversion, no deprecated Codex `~/.codex/prompts` (removed in favour of skills)
+ * and no Copilot slash-command dir (Copilot CLI has none).
+ *
+ * Targets (GLOBAL scope — every project the user opens):
+ *   shared → ~/.agents/skills/     the cross-client convention (Codex, pi,
+ *                                  Copilot, Cursor all scan it)
+ *   codex  → ~/.codex/skills/      Codex's own global dir (guaranteed pickup)
+ *   pi     → ~/.pi/agent/skills/   pi's own global dir (guaranteed pickup)
+ *
+ * Every function here is PURE (data in → data out) so the whole surface is
+ * unit-testable and re-running the sync never duplicates or clobbers. All fs
+ * lives in the command layer (commands/integrations.ts).
+ *
+ * INVARIANT (do-not-break-Claude): nothing here targets `.claude/**` — the
+ * Claude Code skill surface is owned by `swarmdo init`/`efficiency` and is only
+ * ever the READ source, never a write target.
+ */
+export type SkillTarget = 'shared' | 'codex' | 'pi';
+export declare const SKILL_TARGETS: SkillTarget[];
+/**
+ * Curated essentials — the ~20 skills worth exposing to non-Claude agents.
+ * An explicit allowlist (not "everything minus internal") so the cross-agent
+ * surface stays a deliberate, stable set. Excludes: the swarmdo-internal
+ * `sdo-v3-*` build skills, `sdo-dual-mode` (no SKILL.md), and
+ * `sdo-caveman-compress` (Claude-slash-command-bound; bundles python bytecode).
+ */
+export declare const CURATED_SKILLS: string[];
+/** Manifest dropped at each target root so `--remove`/reconcile only ever
+ * touches the exact `sdo-*` dirs swarmdo installed — never a user's own or
+ * another tool's skills. */
+export declare const SKILLS_MANIFEST = ".swarmdo-skills.json";
+/**
+ * Intersect the curated allowlist with what's actually on disk, preserving
+ * curated order. Absent skills are silently skipped so a trimmed package (the
+ * standalone build ships a subset) never errors.
+ */
+export declare function curateSkills(available: readonly string[]): string[];
+/** The global skills root for a target under `home`. */
+export declare function skillTargetRoot(home: string, target: SkillTarget): string;
+/**
+ * Rewrite a skill's SKILL.md for cross-agent portability. The cross-agent spec
+ * requires `name` to equal the skill's directory name; swarmdo's source uses a
+ * pretty display name (`name: "Swarm Orchestration"`), so we force `name` to the
+ * `sdo-*` slug and preserve everything else (crucially `description`, the field
+ * agents match on to decide when to activate). Missing frontmatter is repaired.
+ */
+export declare function normalizeSkillMd(slug: string, raw: string): string;
+/** Serialize the ownership manifest (deterministic — no timestamps). */
+export declare function buildManifest(slugs: readonly string[], version: string): string;
+/** Read the skill slugs a prior sync recorded at a target root (null = none). */
+export declare function parseManifestSkills(raw: string | null): string[];
+export interface PlannedSkillWrite {
+    target: SkillTarget;
+    slug: string;
+    /** absolute path of the SKILL.md to write */
+    path: string;
+    content: string;
+}
+export interface PlannedManifest {
+    target: SkillTarget;
+    path: string;
+    content: string;
+}
+export interface StaleSkillDir {
+    target: SkillTarget;
+    slug: string;
+    /** absolute path of the skill directory to delete */
+    path: string;
+}
+export interface SkillSyncPlan {
+    writes: PlannedSkillWrite[];
+    manifests: PlannedManifest[];
+    /** dirs from a PRIOR sync that are no longer curated — pruned on --apply */
+    stale: StaleSkillDir[];
+}
+/**
+ * Plan a sync. Pure: given the curated skills (already read from the source) and
+ * the previously-installed slugs per target (from each manifest), produce the
+ * exact writes, per-root manifests, and the stale dirs to reconcile away. All
+ * curated skills are single-file SKILL.md (bundled-resource skills are excluded
+ * from the allowlist), so one write per skill per target.
+ */
+export declare function planSkillSync(opts: {
+    home: string;
+    targets: readonly SkillTarget[];
+    skills: ReadonlyArray<{
+        slug: string;
+        skillMd: string;
+    }>;
+    version: string;
+    previous?: ReadonlyArray<{
+        target: SkillTarget;
+        slugs: readonly string[];
+    }>;
+}): SkillSyncPlan;
+export interface SkillRemovePlan {
+    dirs: StaleSkillDir[];
+    manifests: PlannedManifest[];
+}
+/**
+ * Plan a full uninstall. Pure: given the installed slugs per target (from the
+ * manifests), produce every skill dir to delete plus the manifest files to drop.
+ * Only ever names slugs the manifest recorded, so a user's own skills in the
+ * same root are untouched.
+ */
+export declare function planSkillRemove(opts: {
+    home: string;
+    installed: ReadonlyArray<{
+        target: SkillTarget;
+        slugs: readonly string[];
+    }>;
+}): SkillRemovePlan;
+//# sourceMappingURL=skills-sync.d.ts.map

package/v3/@swarmdo/cli/dist/src/integrations/skills-sync.js

@@ -0,0 +1,180 @@
+/**
+ * skills-sync.ts — sync curated swarmdo skills into the cross-agent skill dirs.
+ *
+ * SKILL.md is a universal cross-agent standard (2026): Codex, pi, Copilot, and
+ * Cursor all read skills from a `<dir>/SKILL.md` layout with `name`+`description`
+ * YAML frontmatter. swarmdo already ships its surface as `sdo-*` skills, so the
+ * "integration" for these tools is a near-passthrough copy — no per-tool format
+ * conversion, no deprecated Codex `~/.codex/prompts` (removed in favour of skills)
+ * and no Copilot slash-command dir (Copilot CLI has none).
+ *
+ * Targets (GLOBAL scope — every project the user opens):
+ *   shared → ~/.agents/skills/     the cross-client convention (Codex, pi,
+ *                                  Copilot, Cursor all scan it)
+ *   codex  → ~/.codex/skills/      Codex's own global dir (guaranteed pickup)
+ *   pi     → ~/.pi/agent/skills/   pi's own global dir (guaranteed pickup)
+ *
+ * Every function here is PURE (data in → data out) so the whole surface is
+ * unit-testable and re-running the sync never duplicates or clobbers. All fs
+ * lives in the command layer (commands/integrations.ts).
+ *
+ * INVARIANT (do-not-break-Claude): nothing here targets `.claude/**` — the
+ * Claude Code skill surface is owned by `swarmdo init`/`efficiency` and is only
+ * ever the READ source, never a write target.
+ */
+import * as path from 'node:path';
+export const SKILL_TARGETS = ['shared', 'codex', 'pi'];
+/**
+ * Curated essentials — the ~20 skills worth exposing to non-Claude agents.
+ * An explicit allowlist (not "everything minus internal") so the cross-agent
+ * surface stays a deliberate, stable set. Excludes: the swarmdo-internal
+ * `sdo-v3-*` build skills, `sdo-dual-mode` (no SKILL.md), and
+ * `sdo-caveman-compress` (Claude-slash-command-bound; bundles python bytecode).
+ */
+export const CURATED_SKILLS = [
+    // memory + intelligence (swarmdo's core differentiator)
+    'sdo-agentdb-memory-patterns',
+    'sdo-agentdb-vector-search',
+    'sdo-agentdb-optimization',
+    'sdo-reasoningbank-intelligence',
+    // swarm + coordination
+    'sdo-swarm-orchestration',
+    'sdo-swarm-advanced',
+    'sdo-hive-mind-advanced',
+    'sdo-hooks-automation',
+    // github
+    'sdo-github-code-review',
+    'sdo-github-workflow-automation',
+    'sdo-github-multi-repo',
+    'sdo-github-release-management',
+    'sdo-github-project-management',
+    // methodology + quality
+    'sdo-sparc-methodology',
+    'sdo-verification-quality',
+    'sdo-pair-programming',
+    'sdo-performance-analysis',
+    // tooling
+    'sdo-stream-chain',
+    'sdo-browser',
+    'sdo-agentic-jujutsu',
+];
+/** Manifest dropped at each target root so `--remove`/reconcile only ever
+ * touches the exact `sdo-*` dirs swarmdo installed — never a user's own or
+ * another tool's skills. */
+export const SKILLS_MANIFEST = '.swarmdo-skills.json';
+/**
+ * Intersect the curated allowlist with what's actually on disk, preserving
+ * curated order. Absent skills are silently skipped so a trimmed package (the
+ * standalone build ships a subset) never errors.
+ */
+export function curateSkills(available) {
+    const have = new Set(available);
+    return CURATED_SKILLS.filter((s) => have.has(s));
+}
+/** The global skills root for a target under `home`. */
+export function skillTargetRoot(home, target) {
+    switch (target) {
+        case 'shared':
+            return path.join(home, '.agents', 'skills');
+        case 'codex':
+            return path.join(home, '.codex', 'skills');
+        case 'pi':
+            return path.join(home, '.pi', 'agent', 'skills');
+    }
+}
+/**
+ * Rewrite a skill's SKILL.md for cross-agent portability. The cross-agent spec
+ * requires `name` to equal the skill's directory name; swarmdo's source uses a
+ * pretty display name (`name: "Swarm Orchestration"`), so we force `name` to the
+ * `sdo-*` slug and preserve everything else (crucially `description`, the field
+ * agents match on to decide when to activate). Missing frontmatter is repaired.
+ */
+export function normalizeSkillMd(slug, raw) {
+    const nameLine = `name: "${slug}"`;
+    const fm = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*\r?\n/.exec(raw);
+    if (!fm) {
+        // No frontmatter — synthesize a minimal valid header.
+        return `---\n${nameLine}\ndescription: "swarmdo skill: ${slug}"\n---\n\n${raw.replace(/^\r?\n+/, '')}`;
+    }
+    const body = raw.slice(fm[0].length).replace(/^\r?\n+/, '');
+    let sawName = false;
+    const inner = fm[1].split(/\r?\n/).map((ln) => {
+        if (/^\s*name\s*:/.test(ln)) {
+            sawName = true;
+            return nameLine;
+        }
+        return ln;
+    });
+    if (!sawName)
+        inner.unshift(nameLine);
+    return `---\n${inner.join('\n')}\n---\n\n${body}`;
+}
+/** Serialize the ownership manifest (deterministic — no timestamps). */
+export function buildManifest(slugs, version) {
+    return (JSON.stringify({ managedBy: 'swarmdo integrations skills', version, skills: [...slugs] }, null, 2) + '\n');
+}
+/** Read the skill slugs a prior sync recorded at a target root (null = none). */
+export function parseManifestSkills(raw) {
+    if (!raw)
+        return [];
+    try {
+        const j = JSON.parse(raw);
+        return Array.isArray(j.skills) ? j.skills.filter((x) => typeof x === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Plan a sync. Pure: given the curated skills (already read from the source) and
+ * the previously-installed slugs per target (from each manifest), produce the
+ * exact writes, per-root manifests, and the stale dirs to reconcile away. All
+ * curated skills are single-file SKILL.md (bundled-resource skills are excluded
+ * from the allowlist), so one write per skill per target.
+ */
+export function planSkillSync(opts) {
+    const { home, targets, skills, version } = opts;
+    const prevByTarget = new Map();
+    for (const p of opts.previous ?? [])
+        prevByTarget.set(p.target, new Set(p.slugs));
+    const slugs = skills.map((s) => s.slug);
+    const nextSet = new Set(slugs);
+    const writes = [];
+    const manifests = [];
+    const stale = [];
+    for (const target of targets) {
+        const root = skillTargetRoot(home, target);
+        for (const { slug, skillMd } of skills) {
+            writes.push({
+                target,
+                slug,
+                path: path.join(root, slug, 'SKILL.md'),
+                content: normalizeSkillMd(slug, skillMd),
+            });
+        }
+        manifests.push({ target, path: path.join(root, SKILLS_MANIFEST), content: buildManifest(slugs, version) });
+        for (const old of prevByTarget.get(target) ?? []) {
+            if (!nextSet.has(old))
+                stale.push({ target, slug: old, path: path.join(root, old) });
+        }
+    }
+    return { writes, manifests, stale };
+}
+/**
+ * Plan a full uninstall. Pure: given the installed slugs per target (from the
+ * manifests), produce every skill dir to delete plus the manifest files to drop.
+ * Only ever names slugs the manifest recorded, so a user's own skills in the
+ * same root are untouched.
+ */
+export function planSkillRemove(opts) {
+    const dirs = [];
+    const manifests = [];
+    for (const { target, slugs } of opts.installed) {
+        const root = skillTargetRoot(opts.home, target);
+        for (const slug of slugs)
+            dirs.push({ target, slug, path: path.join(root, slug) });
+        manifests.push({ target, path: path.join(root, SKILLS_MANIFEST), content: '' });
+    }
+    return { dirs, manifests };
+}
+//# sourceMappingURL=skills-sync.js.map

package/v3/@swarmdo/cli/dist/src/usage/account-plan.d.ts

@@ -0,0 +1,48 @@
+/**
+ * account-plan.ts — decide what the statusline "cost" slot should mean for the
+ * currently-authenticated Claude account.
+ *
+ * Claude Code stores the active account in `~/.claude.json` under `oauthAccount`
+ * and OVERWRITES it on account switch — it never records history, and the
+ * transcript is account-blind. So the only reliable signal is "who is logged in
+ * right now", read live at render time. From that we pick the metric:
+ *
+ *   - subscription (Max/Team/Enterprise/Pro, flat fee) → a dollar figure is a
+ *     phantom you never pay; show rate-limit % instead.
+ *   - pay-as-you-go (API/console usage billing) → the dollar figure is real.
+ *
+ * Pure + injectable (no fs here) so it is unit-tested against literal account
+ * objects. The statusline shim reads the file and passes the object in.
+ */
+/** The subset of `~/.claude.json.oauthAccount` we look at (never tokens). */
+export interface OAuthAccountLike {
+    billingType?: unknown;
+    organizationType?: unknown;
+    /** shown only when the user opts into --show-account */
+    displayName?: unknown;
+    organizationName?: unknown;
+}
+export type Plan = 'subscription' | 'payg' | 'unknown';
+/** How the user configured the cost slot. `auto` defers to the detected plan. */
+export type CostMode = 'auto' | 'dollars' | 'limits' | 'off';
+/** What the slot actually renders after resolving `auto` against the plan. */
+export type EffectiveCostMode = 'dollars' | 'limits' | 'off';
+/**
+ * Classify the active account. Subscription when the billing type is a
+ * subscription OR the org is a Claude consumer/team plan; pay-as-you-go when a
+ * known non-subscription billing type is present; unknown when we can't tell
+ * (no account, unrecognized shape) — callers treat unknown like payg so a real
+ * dollar figure still shows rather than a blank.
+ */
+export declare function detectPlan(account: OAuthAccountLike | null | undefined): Plan;
+/**
+ * Resolve the configured mode against the detected plan into what to actually
+ * render. `auto` → limits for subscription, dollars otherwise. Explicit modes
+ * pass through unchanged (the user overrides the heuristic on purpose).
+ */
+export declare function resolveEffectiveCostMode(mode: CostMode, plan: Plan): EffectiveCostMode;
+/** A short, screenshare-safe account label. Prefers displayName, then org. */
+export declare function accountLabel(account: OAuthAccountLike | null | undefined, maxLen?: number): string;
+/** Normalize a raw cost-mode string (env/config) to a valid CostMode or null. */
+export declare function parseCostMode(raw: unknown): CostMode | null;
+//# sourceMappingURL=account-plan.d.ts.map

package/v3/@swarmdo/cli/dist/src/usage/account-plan.js

@@ -0,0 +1,71 @@
+/**
+ * account-plan.ts — decide what the statusline "cost" slot should mean for the
+ * currently-authenticated Claude account.
+ *
+ * Claude Code stores the active account in `~/.claude.json` under `oauthAccount`
+ * and OVERWRITES it on account switch — it never records history, and the
+ * transcript is account-blind. So the only reliable signal is "who is logged in
+ * right now", read live at render time. From that we pick the metric:
+ *
+ *   - subscription (Max/Team/Enterprise/Pro, flat fee) → a dollar figure is a
+ *     phantom you never pay; show rate-limit % instead.
+ *   - pay-as-you-go (API/console usage billing) → the dollar figure is real.
+ *
+ * Pure + injectable (no fs here) so it is unit-tested against literal account
+ * objects. The statusline shim reads the file and passes the object in.
+ */
+const SUBSCRIPTION_BILLING = /subscription/i; // e.g. "stripe_subscription"
+const SUBSCRIPTION_ORG = /claude_(max|team|enterprise|pro)/i; // e.g. "claude_max"
+/**
+ * Classify the active account. Subscription when the billing type is a
+ * subscription OR the org is a Claude consumer/team plan; pay-as-you-go when a
+ * known non-subscription billing type is present; unknown when we can't tell
+ * (no account, unrecognized shape) — callers treat unknown like payg so a real
+ * dollar figure still shows rather than a blank.
+ */
+export function detectPlan(account) {
+    if (!account || typeof account !== 'object')
+        return 'unknown';
+    const billing = typeof account.billingType === 'string' ? account.billingType : '';
+    const org = typeof account.organizationType === 'string' ? account.organizationType : '';
+    if (SUBSCRIPTION_BILLING.test(billing) || SUBSCRIPTION_ORG.test(org))
+        return 'subscription';
+    if (billing)
+        return 'payg'; // a known, non-subscription billing type
+    return 'unknown';
+}
+/**
+ * Resolve the configured mode against the detected plan into what to actually
+ * render. `auto` → limits for subscription, dollars otherwise. Explicit modes
+ * pass through unchanged (the user overrides the heuristic on purpose).
+ */
+export function resolveEffectiveCostMode(mode, plan) {
+    if (mode === 'off')
+        return 'off';
+    if (mode === 'dollars')
+        return 'dollars';
+    if (mode === 'limits')
+        return 'limits';
+    // auto
+    return plan === 'subscription' ? 'limits' : 'dollars';
+}
+/** A short, screenshare-safe account label. Prefers displayName, then org. */
+export function accountLabel(account, maxLen = 16) {
+    if (!account)
+        return '';
+    const raw = (typeof account.displayName === 'string' && account.displayName) ||
+        (typeof account.organizationName === 'string' && account.organizationName) ||
+        '';
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return '';
+    return trimmed.length > maxLen ? trimmed.slice(0, maxLen - 1) + '…' : trimmed;
+}
+/** Normalize a raw cost-mode string (env/config) to a valid CostMode or null. */
+export function parseCostMode(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const v = raw.trim().toLowerCase();
+    return v === 'auto' || v === 'dollars' || v === 'limits' || v === 'off' ? v : null;
+}
+//# sourceMappingURL=account-plan.js.map

package/v3/@swarmdo/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmdo/cli",
-  "version": "1.58.6",
+  "version": "1.58.12",
   "type": "module",
   "description": "Swarmdo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",