talking-stick 0.4.11 → 0.4.13

package/dist/skill-install.js

@@ -2,12 +2,55 @@ import fs from "node:fs";
 import crypto from "node:crypto";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { FILE_SKILL_HARNESSES, HARNESS_SKILL_MODELS, SUPPORTED_HARNESSES } from "./harness-model.js";
 import { MissingHarnessError, resolveHarnessConfigDir, skipAction } from "./install.js";
 export const DEFAULT_SKILL_NAME = "talking-stick";
-const FILE_SKILL_HARNESSES = ["claude-code", "codex", "grok", "opencode"];
+export { FILE_SKILL_HARNESSES } from "./harness-model.js";
 export function resolveBundledSkillPath(options = {}) {
     return options.sourcePath ?? path.resolve(currentPackageDir(), "skills", DEFAULT_SKILL_NAME);
 }
+export function resolveSharedAgentsSkillsDir(options = {}) {
+    const homeDir = options.homeDir ?? process.env.HOME ?? "";
+    return path.join(homeDir, ".agents", "skills");
+}
+export function resolveSharedSkillTargetPath(options = {}) {
+    return path.join(resolveSharedAgentsSkillsDir(options), options.skillName ?? DEFAULT_SKILL_NAME);
+}
+export function skillLoadingModel(harness) {
+    return HARNESS_SKILL_MODELS[harness].skillLoadingModel;
+}
+export function resolvePrimarySkillTargetPath(harness, options = {}) {
+    const model = skillLoadingModel(harness);
+    if (model === "shared" || model === "shared+proprietary") {
+        return resolveSharedSkillTargetPath(options);
+    }
+    return resolveSkillTargetPath(harness, options);
+}
+export function resolveLegacyOpencodeSkillTargetPath(options = {}) {
+    const homeDir = options.homeDir ?? process.env.HOME ?? "";
+    return path.join(homeDir, ".opencode", "skills", options.skillName ?? DEFAULT_SKILL_NAME);
+}
+export function resolveDuplicateSkillTargetPaths(harness, options = {}) {
+    const skillName = options.skillName ?? DEFAULT_SKILL_NAME;
+    switch (harness) {
+        case "claude-code":
+        case "antigravity":
+            return [];
+        case "codex":
+            return [resolveSkillTargetPath("codex", options)];
+        case "grok":
+            return [resolveSkillTargetPath("grok", options)];
+        case "opencode":
+            return [
+                resolveSkillTargetPath("opencode", options),
+                resolveLegacyOpencodeSkillTargetPath(options)
+            ];
+        case "gemini":
+            return [path.join(resolveHarnessConfigDir("gemini", options), "skills", skillName)];
+        default:
+            throw new Error(`Unknown duplicate skill cleanup harness: ${harness}`);
+    }
+}
 export function resolveSkillTargetPath(harness, options = {}) {
     const homeDir = options.homeDir ?? process.env.HOME ?? "";
     switch (harness) {
@@ -15,6 +58,8 @@ export function resolveSkillTargetPath(harness, options = {}) {
             return path.join(homeDir, ".claude", "skills", options.skillName ?? DEFAULT_SKILL_NAME);
         case "codex":
             return path.join(homeDir, ".codex", "skills", options.skillName ?? DEFAULT_SKILL_NAME);
+        case "antigravity":
+            return resolveSharedSkillTargetPath(options);
         case "grok":
             return path.join(resolveHarnessConfigDir("grok", options), "skills", options.skillName ?? DEFAULT_SKILL_NAME);
         case "opencode":
@@ -29,28 +74,15 @@ export function planSkillInstall(harness, options = {}) {
     const shouldLink = options.link ?? true;
     ensureSkillSourceExists(sourcePath);
     if (harness === "gemini") {
-        return shouldLink
-            ? {
-                kind: "exec",
-                harness,
-                command: "gemini",
-                args: ["skills", "link", sourcePath, "--scope", "user", "--consent"],
-                description: `gemini skills link ${sourcePath} --scope user --consent`,
-                operation: "install"
-            }
-            : {
-                kind: "exec",
-                harness,
-                command: "gemini",
-                args: ["skills", "install", sourcePath, "--scope", "user", "--consent"],
-                description: `gemini skills install ${sourcePath} --scope user --consent`,
-                operation: "install"
-            };
+        return skipAction(harness, `Gemini CLI skill install is deprecated; use tt install antigravity. Cleanup will remove ${path.join(resolveHarnessConfigDir("gemini", options), "skills", skillName)} when it is a Talking Stick-managed symlink.`);
     }
-    const targetPath = resolveSkillTargetPath(harness, options);
-    const harnessRootPath = resolveHarnessConfigDir(harness, options);
+    const targetPath = resolvePrimarySkillTargetPath(harness, options);
+    const harnessRootPath = skillLoadingModel(harness) === "shared" ||
+        skillLoadingModel(harness) === "shared+proprietary"
+        ? undefined
+        : resolveHarnessConfigDir(harness, options);
     const pathExists = options.pathExists ?? fs.existsSync;
-    if (options.skipMissing && !pathExists(harnessRootPath)) {
+    if (options.skipMissing && harnessRootPath && !pathExists(harnessRootPath)) {
         return skipAction(harness, `harness config directory not found: ${harnessRootPath}`);
     }
     return {
@@ -67,6 +99,9 @@ export function planSkillInstall(harness, options = {}) {
 }
 export function planSkillUninstall(harness, options = {}) {
     const skillName = options.skillName ?? DEFAULT_SKILL_NAME;
+    if (harness === "antigravity") {
+        return skipAction(harness, `shared skill left installed: ${resolveSharedSkillTargetPath(options)}`);
+    }
     if (harness === "gemini") {
         return {
             kind: "exec",
@@ -90,16 +125,141 @@ export function planSkillUninstall(harness, options = {}) {
         apply: () => removeInstalledSkill(targetPath, harnessRootPath, options)
     };
 }
+export function planSharedSkillUninstall(options = {}) {
+    const targetPath = resolveSharedSkillTargetPath(options);
+    return {
+        kind: "file-patch",
+        harness: "antigravity",
+        filePath: targetPath,
+        description: `remove shared agents skill ${targetPath}`,
+        operation: "uninstall",
+        inspect: () => inspectInstalledPath(targetPath),
+        apply: () => removeInstalledSkill(targetPath, undefined, options)
+    };
+}
 export function syncInstalledSkills(options = {}) {
     const sourcePath = resolveBundledSkillPath(options);
     ensureSkillSourceExists(sourcePath);
     const sourceDigest = digestDirectory(sourcePath);
+    const syncTargets = dedupeSyncTargets(options);
     return {
         sourcePath,
         sourceDigest,
-        targets: FILE_SKILL_HARNESSES.map((harness) => syncInstalledFileSkill(harness, sourcePath, sourceDigest, options))
+        targets: syncTargets.map((harness) => syncInstalledFileSkill(harness, sourcePath, sourceDigest, options))
     };
 }
+export function removeDuplicateSkillInstalls(options) {
+    const sourcePath = resolveBundledSkillPath(options);
+    ensureSkillSourceExists(sourcePath);
+    const harnesses = options.harnesses === undefined || options.harnesses === "all"
+        ? SUPPORTED_HARNESSES
+        : options.harnesses;
+    const results = [];
+    for (const harness of harnesses) {
+        const targets = dedupePaths(resolveDuplicateSkillTargetPaths(harness, options));
+        if (targets.length === 0) {
+            const result = {
+                harness,
+                action: "skipped",
+                message: `${harness}: no proprietary skill duplicate target`,
+                target_type: "skill"
+            };
+            results.push(result);
+            appendSkillCleanupAudit(options, result);
+            continue;
+        }
+        for (const targetPath of targets) {
+            const result = cleanupDuplicateSkillTarget(harness, targetPath, sourcePath);
+            results.push(result);
+            appendSkillCleanupAudit(options, result, targetPath);
+        }
+    }
+    return results;
+}
+function dedupePaths(paths) {
+    const seen = new Set();
+    const result = [];
+    for (const targetPath of paths) {
+        const key = path.resolve(targetPath);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(targetPath);
+    }
+    return result;
+}
+function cleanupDuplicateSkillTarget(harness, targetPath, sourcePath) {
+    try {
+        const stat = fs.lstatSync(targetPath);
+        if (!stat.isSymbolicLink()) {
+            return {
+                harness,
+                action: "preserved",
+                message: `${targetPath} is not a Talking Stick-managed symlink; left in place.`,
+                target_type: "skill"
+            };
+        }
+        const currentTarget = fs.readlinkSync(targetPath);
+        const resolvedCurrentTarget = path.resolve(path.dirname(targetPath), currentTarget);
+        if (!sameRealPath(resolvedCurrentTarget, sourcePath)) {
+            return {
+                harness,
+                action: "preserved",
+                message: `${targetPath} points at ${resolvedCurrentTarget}; left in place.`,
+                target_type: "skill"
+            };
+        }
+        fs.unlinkSync(targetPath);
+        return {
+            harness,
+            action: "removed",
+            message: `Removed duplicate skill symlink ${targetPath}.`,
+            target_type: "skill"
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return {
+                harness,
+                action: "absent",
+                message: `${targetPath} is already absent.`,
+                target_type: "skill"
+            };
+        }
+        return {
+            harness,
+            action: "failed",
+            message: error instanceof Error ? error.message : String(error),
+            target_type: "skill"
+        };
+    }
+}
+function appendSkillCleanupAudit(options, result, targetPath) {
+    options.audit?.append({
+        reason: options.reason,
+        package_version_from: options.packageVersionFrom,
+        package_version_to: options.packageVersionTo,
+        harness: result.harness,
+        target_type: "skill",
+        config_path: targetPath,
+        action: result.action,
+        server_name: options.skillName ?? DEFAULT_SKILL_NAME,
+        detail: result.message
+    });
+}
+function dedupeSyncTargets(options) {
+    const seen = new Set();
+    const targets = [];
+    for (const harness of FILE_SKILL_HARNESSES) {
+        const targetPath = resolvePrimarySkillTargetPath(harness, options);
+        const key = path.resolve(targetPath);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        targets.push(harness);
+    }
+    return targets;
+}
 function currentPackageDir() {
     return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 }
@@ -111,7 +271,7 @@ function ensureSkillSourceExists(sourcePath) {
 }
 function installSkillDirectory(sourcePath, targetPath, harnessRootPath, link, options) {
     const pathExists = options.pathExists ?? fs.existsSync;
-    if (options.skipMissing && !pathExists(harnessRootPath)) {
+    if (options.skipMissing && harnessRootPath && !pathExists(harnessRootPath)) {
         throw new MissingHarnessError(`harness config directory not found: ${harnessRootPath}`);
     }
     fs.mkdirSync(path.dirname(targetPath), { recursive: true });
@@ -123,8 +283,11 @@ function installSkillDirectory(sourcePath, targetPath, harnessRootPath, link, op
     fs.cpSync(sourcePath, targetPath, { recursive: true });
 }
 function syncInstalledFileSkill(harness, sourcePath, sourceDigest, options) {
-    const targetPath = resolveSkillTargetPath(harness, options);
-    const harnessRootPath = resolveHarnessConfigDir(harness, options);
+    const targetPath = resolvePrimarySkillTargetPath(harness, options);
+    const model = skillLoadingModel(harness);
+    const harnessRootPath = model === "shared" || model === "shared+proprietary"
+        ? path.dirname(resolveSharedAgentsSkillsDir(options))
+        : resolveHarnessConfigDir(harness, options);
     try {
         if (!fs.existsSync(harnessRootPath) || !fs.existsSync(targetPath)) {
             return {
@@ -206,6 +369,18 @@ function inspectInstalledSkill(sourcePath, targetPath, link) {
         throw error;
     }
 }
+function inspectInstalledPath(targetPath) {
+    try {
+        fs.lstatSync(targetPath);
+        return "present";
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return "absent";
+        }
+        throw error;
+    }
+}
 function removeInstalledSkill(targetPath, harnessRootPath, options = {}) {
     const pathExists = options.pathExists ?? fs.existsSync;
     if (options.skipMissing && harnessRootPath && !pathExists(harnessRootPath)) {

package/dist/update-migration.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from "node:url";
 import { resolveDataDir } from "./config.js";
 import { FileAuditLog, defaultAuditLogPath } from "./install-audit.js";
 import { removeStaleMcpRegistrations } from "./install-migration.js";
+import { removeDuplicateSkillInstalls } from "./skill-install.js";
 export const UPDATE_MIGRATION_STATE_FILE = "update-migrations-state.json";
 export async function runStaleMcpCleanup(options) {
     const packageVersionTo = options.packageVersionTo ?? options.packageVersion ?? readPackageVersion();
@@ -11,7 +12,7 @@ export async function runStaleMcpCleanup(options) {
     const statePath = resolveUpdateMigrationStatePath(dataDir);
     const auditPath = defaultAuditLogPath(dataDir);
     const audit = options.audit ?? new FileAuditLog(auditPath);
-    const results = await removeStaleMcpRegistrations({
+    const mcpResults = await removeStaleMcpRegistrations({
         harnesses: options.harnesses ?? "all",
         reason: options.reason,
         packageVersionFrom: options.packageVersionFrom,
@@ -19,6 +20,15 @@ export async function runStaleMcpCleanup(options) {
         audit,
         installOptions: options.installOptions
     });
+    const skillResults = removeDuplicateSkillInstalls({
+        harnesses: options.harnesses ?? "all",
+        reason: options.reason,
+        packageVersionFrom: options.packageVersionFrom,
+        packageVersionTo,
+        audit,
+        ...(options.installOptions ?? {})
+    });
+    const results = [...mcpResults, ...skillResults];
     if (options.updateState !== false && !results.some((result) => result.action === "failed")) {
         writeUpdateMigrationState(statePath, {
             mcp_cleanup_version: packageVersionTo,