skillspub 0.1.0

package/dist/view.js

@@ -0,0 +1,321 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { inspectHarnesses } from "./harnesses/registry.js";
+import { sharedOutdatedFromInventory, } from "./shared.js";
+import { readStateFile, targetSlotId, pendingTargetDefinitions, scanGlobalInventory, scanProjectInventory, } from "./inventory.js";
+export function harnessStatusBadge(harness) {
+    if (harness.support !== 'managed')
+        return { text: `[${harness.support}]`, tone: 'muted' };
+    if (harness.isolation.status === 'managed' || harness.isolation.status === 'not-required')
+        return { text: '[managed]', tone: 'success' };
+    if (harness.isolation.status === 'unmanaged')
+        return { text: '[manageable]', tone: 'muted' };
+    return harness.isolation.status === 'drift'
+        ? { text: '[drift]', tone: 'danger' }
+        : { text: '[unknown]', tone: 'warning' };
+}
+function toInfo(relationship, target) {
+    return {
+        presence: relationship.realPath ? relationship.activation : 'deadlink',
+        path: relationship.path,
+        realPath: relationship.realPath,
+        form: relationship.form,
+        linked: relationship.form === 'link',
+        mirrored: relationship.form === 'mirror',
+        diverged: relationship.diverged === true,
+        underOff: relationship.activation === 'off',
+        target: relationship.target,
+        scope: target?.scope,
+        readOnly: target ? !target.writable : undefined,
+    };
+}
+/** One Skill × Target cell for a project scan: inherited ON wins unless the project is ON. */
+function effectiveProjectRelationship(relationships) {
+    const project = relationships.find((relationship) => relationship.scope === 'project');
+    const inheritedOn = relationships.find((relationship) => relationship.scope !== 'project' && relationship.info.presence === 'on');
+    if (project?.info.presence === 'on')
+        return project;
+    if (inheritedOn)
+        return inheritedOn;
+    return project ?? relationships[0];
+}
+export function viewTargets(report) {
+    return report.targets.map((target) => ({
+        name: target.key,
+        dir: target.discoveryRoot,
+    }));
+}
+function descriptionFrom(content) {
+    const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/)?.[1];
+    if (!frontmatter)
+        return undefined;
+    const lines = frontmatter.split(/\r?\n/);
+    const index = lines.findIndex((line) => /^description\s*:/.test(line));
+    if (index === -1)
+        return undefined;
+    const value = lines[index].replace(/^description\s*:\s*/, '').trim();
+    if (value === '|' || value === '>') {
+        const parts = [];
+        for (const line of lines.slice(index + 1)) {
+            if (!/^\s+/.test(line))
+                break;
+            parts.push(line.trim());
+        }
+        return parts.join(value === '>' ? ' ' : '\n') || undefined;
+    }
+    return value.replace(/^(['"])(.*)\1$/, '$2') || undefined;
+}
+function readDescription(realPath) {
+    if (!realPath)
+        return undefined;
+    try {
+        return descriptionFrom(fs.readFileSync(path.join(realPath, 'SKILL.md'), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Project one scan into matrix rows. Pure: no disk or state reads beyond the report. */
+export function projectRows(report) {
+    const keys = new Map(report.targets.map((target) => [target.id, target.key]));
+    const targetById = new Map(report.targets.map((target) => [target.id, target]));
+    const provenanceBySlot = new Map(report.slots.map((slot) => [slot.id, slot.provenance]));
+    const grouped = new Map();
+    for (const relationship of report.relationships) {
+        const id = relationship.resourceId ?? relationship.realPath ?? `broken:${relationship.path}`;
+        let instance = grouped.get(id);
+        if (!instance) {
+            instance = {
+                id,
+                name: relationship.name,
+                displayName: relationship.name,
+                realPath: relationship.resourceId ?? relationship.realPath,
+                description: readDescription(relationship.realPath),
+                provenance: {},
+                sourceLabel: 'Source unknown',
+                relationships: [],
+                targets: {},
+            };
+            grouped.set(id, instance);
+        }
+        const targetName = keys.get(relationship.targetId) ?? relationship.targetKey;
+        const target = targetById.get(relationship.targetId);
+        // Discovery entries scan before parking entries, so ??= prefers ON.
+        instance.targets[targetName] ??= toInfo(relationship, target);
+        instance.relationships.push({
+            target: targetName,
+            name: relationship.name,
+            info: toInfo(relationship, target),
+            targetId: relationship.targetId,
+            slot: relationship.slot,
+            scope: target?.scope,
+            readOnly: target ? !target.writable : undefined,
+        });
+    }
+    if (report.scope === 'project') {
+        for (const instance of grouped.values()) {
+            instance.observedRelationships = instance.relationships;
+            const byTarget = new Map();
+            for (const relationship of instance.relationships) {
+                const list = byTarget.get(relationship.target) ?? [];
+                list.push(relationship);
+                byTarget.set(relationship.target, list);
+            }
+            instance.relationships = [...byTarget.values()].map(effectiveProjectRelationship);
+            instance.targets = Object.fromEntries(instance.relationships.map((relationship) => [relationship.target, relationship.info]));
+        }
+    }
+    const instances = [...grouped.values()].sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
+    const counts = new Map();
+    for (const instance of instances)
+        counts.set(instance.name, (counts.get(instance.name) ?? 0) + 1);
+    for (const instance of instances) {
+        const provenance = instance.relationships
+            .map((relationship) => provenanceBySlot.get(targetSlotId(relationship.targetId, relationship.slot)))
+            .find((candidate) => candidate && Object.values(candidate).some(Boolean));
+        instance.provenance = provenance ?? {};
+        instance.sourceLabel = instance.provenance.sourceUrl
+            ?? instance.provenance.source
+            ?? 'Source unknown';
+        if ((counts.get(instance.name) ?? 0) > 1) {
+            const suffix = instance.provenance.source
+                ?? instance.provenance.sourceUrl
+                ?? instance.realPath
+                ?? instance.relationships[0].info.path;
+            instance.displayName = `${instance.name} (${suffix})`;
+        }
+    }
+    return instances;
+}
+function sourceSortValue(row) {
+    return row.provenance.sourceUrl
+        ?? row.provenance.source
+        ?? row.provenance.skillPath
+        ?? row.realPath
+        ?? row.relationships.map(({ info }) => info.path).sort()[0]
+        ?? row.displayName;
+}
+/** Match only the inventory metadata already loaded for a skill instance. */
+export function matchesSearch(row, query) {
+    const needle = query.trim().toLocaleLowerCase();
+    if (!needle)
+        return true;
+    return [
+        row.name,
+        row.displayName,
+        row.description,
+        row.provenance.source,
+        row.provenance.sourceUrl,
+        row.provenance.skillPath,
+    ].some((value) => value?.toLocaleLowerCase().includes(needle));
+}
+export function searchRows(rows, query) {
+    return rows.filter((row) => matchesSearch(row, query));
+}
+/** Compare rows in a projection; callers provide its active status when needed. */
+export function compareRows(a, b, sort, statusA = '', statusB = '') {
+    const primary = sort === 'name'
+        ? a.displayName.localeCompare(b.displayName)
+        : sort === 'source'
+            ? sourceSortValue(a).localeCompare(sourceSortValue(b))
+            : statusA.localeCompare(statusB);
+    return primary || a.displayName.localeCompare(b.displayName) || a.id.localeCompare(b.id);
+}
+export function sortRows(rows, sort, statusFor = () => '') {
+    return [...rows].sort((a, b) => compareRows(a, b, sort, statusFor(a), statusFor(b)));
+}
+export function filterRows(rows, filter, tags) {
+    return rows.filter((r) => {
+        if (filter.target !== undefined && r.targets[filter.target] === undefined)
+            return false;
+        if (filter.tag !== undefined && !(tags[r.id] ?? []).includes(filter.tag))
+            return false;
+        return true;
+    });
+}
+export function untagged(rows, tags) {
+    return rows
+        .filter((row) => (tags[row.id] ?? []).length === 0)
+        .map((row) => row.displayName);
+}
+function stringListRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value)
+        .filter(([, members]) => Array.isArray(members) && members.every((member) => typeof member === 'string')));
+}
+function presetRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value)
+        .filter(([, preset]) => Boolean(preset) && typeof preset === 'object' && !Array.isArray(preset) &&
+        Array.isArray(preset.selectors) &&
+        preset.selectors.every((s) => typeof s === 'string')));
+}
+/** Tags, bundles, claims and preset definitions are catalog/policy metadata;
+ *  unreadable or invalid state projects as empty. */
+export function readViewState(home) {
+    try {
+        const state = readStateFile(path.join(home.configDir, 'state.json'));
+        return {
+            bundles: stringListRecord(state.bundles),
+            tags: stringListRecord(state.tags),
+            claims: stringListRecord(state.claims),
+            presets: presetRecord(state.presets),
+        };
+    }
+    catch {
+        return { bundles: {}, tags: {}, claims: {}, presets: {} };
+    }
+}
+const snapshotInventories = new WeakMap();
+/** Reuse the exact inventory evidence that produced a TUI snapshot. */
+export function tuiSnapshotInventory(snapshot) {
+    return snapshotInventories.get(snapshot);
+}
+function rememberInventory(snapshot, report) {
+    snapshotInventories.set(snapshot, report);
+    return snapshot;
+}
+export function attachUpdateAvailability(rows, home, report) {
+    try {
+        const bySlot = new Map(sharedOutdatedFromInventory(home, report).entries.map((entry) => [entry.slot, entry]));
+        for (const row of rows) {
+            const shared = row.relationships.find((relationship) => relationship.target === 'shared' &&
+                relationship.scope === report.scope);
+            row.updateAvailability = shared ? bySlot.get(shared.slot) : undefined;
+        }
+    }
+    catch {
+        // A missing/unreadable installer lock is not an Inventory failure.
+    }
+    return rows;
+}
+function visibleTargets(report, harnesses) {
+    const detected = new Set(harnesses.detected.map(({ key }) => key));
+    return report.targets
+        .filter(({ kind, key }) => kind !== 'harness' || detected.has(key))
+        .map((target) => ({ name: target.key, dir: target.discoveryRoot }));
+}
+/** Read the live disk state. Call again after every mutation (ADR-0001). */
+export function tuiSnapshot(home) {
+    const report = scanGlobalInventory(home, undefined, { persist: false });
+    const harnesses = inspectHarnesses(home, report.targets);
+    return rememberInventory({
+        targets: visibleTargets(report, harnesses),
+        harnesses,
+        pendingTargetKeys: pendingTargetDefinitions(home).map(({ key }) => key),
+        rows: attachUpdateAvailability(projectRows(report), home, report),
+        catalog: readViewState(home),
+    }, report);
+}
+/** Project-scope snapshot (ADR-0010): target columns are the project targets only;
+ *  rows are the project + parent + global union, inherited cells marked read-only. */
+export function projectTuiSnapshot(home, projectPath) {
+    const report = scanProjectInventory(home, projectPath, undefined, { persist: false });
+    const harnesses = inspectHarnesses(home, report.targets, report.projectPath);
+    return rememberInventory({
+        targets: visibleTargets({ ...report, targets: report.targets.filter((target) => target.scope === 'project') }, harnesses),
+        harnesses,
+        pendingTargetKeys: pendingTargetDefinitions(home).map(({ key }) => key),
+        rows: attachUpdateAvailability(projectRows(report), home, report),
+        catalog: readViewState(home),
+        project: report.projectPath,
+    }, report);
+}
+/** Assemble detail for one explicit instance identity. */
+export function skillDetail(home, instanceId, projectPath) {
+    const report = projectPath
+        ? scanProjectInventory(home, projectPath, undefined, { persist: false })
+        : scanGlobalInventory(home, undefined, { persist: false });
+    const rows = projectRows(report);
+    const instance = rows.find((candidate) => candidate.id === instanceId);
+    if (!instance)
+        return undefined;
+    const state = readViewState(home);
+    const unambiguousName = rows.filter((candidate) => candidate.name === instance.name).length === 1;
+    const contentPath = instance.realPath
+        ? path.join(instance.realPath, 'SKILL.md')
+        : undefined;
+    return {
+        id: instance.id,
+        name: instance.name,
+        displayName: instance.displayName,
+        description: instance.description,
+        targets: instance.targets,
+        relationships: instance.relationships,
+        realPaths: instance.realPath ? [instance.realPath] : [],
+        source: instance.provenance.source,
+        sourceUrl: instance.provenance.sourceUrl,
+        sourceLabel: instance.sourceLabel,
+        skillPath: instance.provenance.skillPath,
+        bundles: Object.entries(state.bundles)
+            .filter(([, members]) => members.includes(instance.id) ||
+            (unambiguousName && members.includes(instance.name)))
+            .map(([bundle]) => bundle)
+            .sort((a, b) => a.localeCompare(b)),
+        tags: state.tags[instance.id] ?? [],
+        content: contentPath ? fs.readFileSync(contentPath, 'utf8') : undefined,
+        contentPath,
+    };
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "skillspub",
+  "version": "0.1.0",
+  "description": "SkillsPub multi-agent skills on/off manager — disk is the source of truth",
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "skillspub": "dist/cli.js"
+  },
+  "engines": {
+    "node": ">=22.20.0"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json",
+    "test": "node --test",
+    "typecheck": "tsc --noEmit",
+    "check:package": "node scripts/check-package.mjs",
+    "audit:release": "node scripts/audit-release.mjs",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build && npm run audit:release && npm run check:package"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AlligatorT/SkillsPub.git"
+  },
+  "homepage": "https://github.com/AlligatorT/SkillsPub",
+  "bugs": {
+    "url": "https://github.com/AlligatorT/SkillsPub/issues"
+  },
+  "license": "MIT",
+  "author": "AlligatorT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "@types/react": "^19.2.17",
+    "skills": "1.5.21",
+    "typescript": "^5.8"
+  },
+  "dependencies": {
+    "ink": "^7.1.1",
+    "react": "^19.2.8",
+    "smol-toml": "^1.8.0",
+    "wrap-ansi": "^10.0.0"
+  }
+}