@f5-sales-demo/xcsh 20.7.0 → 20.8.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/xcsh",
-	"version": "20.7.0",
+	"version": "20.8.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/f5-sales-demo/xcsh",
 	"author": "Can Boluk",
@@ -61,13 +61,13 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@mozilla/readability": "^0.6",
-		"@f5-sales-demo/xcsh-stats": "20.7.0",
-		"@f5-sales-demo/pi-agent-core": "20.7.0",
-		"@f5-sales-demo/pi-ai": "20.7.0",
-		"@f5-sales-demo/pi-natives": "20.7.0",
-		"@f5-sales-demo/pi-resource-management": "20.7.0",
-		"@f5-sales-demo/pi-tui": "20.7.0",
-		"@f5-sales-demo/pi-utils": "20.7.0",
+		"@f5-sales-demo/xcsh-stats": "20.8.0",
+		"@f5-sales-demo/pi-agent-core": "20.8.0",
+		"@f5-sales-demo/pi-ai": "20.8.0",
+		"@f5-sales-demo/pi-natives": "20.8.0",
+		"@f5-sales-demo/pi-resource-management": "20.8.0",
+		"@f5-sales-demo/pi-tui": "20.8.0",
+		"@f5-sales-demo/pi-utils": "20.8.0",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.20",

package/src/extensibility/skill-resolution.ts

@@ -0,0 +1,87 @@
+import type { Skill } from "./skills";
+
+export interface SkillMatchResult {
+	skill: Skill;
+	relativePath: string;
+	suffix?: string;
+}
+
+/** Known plugin alias mappings for backwards compatibility (e.g. collapsed/renamed plugins) */
+const PLUGIN_ALIASES: Record<string, string> = {
+	"github-ops": "github",
+	"f5xc-github-ops": "github",
+};
+
+/**
+ * Match a raw skill path (from URL host + pathname) against registered skills.
+ * Handles:
+ * - Exact namespaced matches: "github:workflow-lifecycle"
+ * - Slash-formatted namespaced matches: "github/workflow-lifecycle"
+ * - Redundant SKILL.md paths: "github/workflow-lifecycle/SKILL.md" -> relativePath = ""
+ * - Plugin aliases: "github-ops:workflow-lifecycle" -> "github:workflow-lifecycle"
+ * - Colon-delimited line range suffixes: "github:workflow-lifecycle:1-10"
+ * - Relative files: "github:workflow-lifecycle/scripts/run.sh"
+ */
+export function resolveSkillFromPath(
+	rawHost: string,
+	rawPathname: string,
+	skills: readonly Skill[],
+): SkillMatchResult | null {
+	const rawCombined = rawHost + (rawPathname ? rawPathname : "");
+	if (!rawCombined) return null;
+
+	// Build key variants for each registered skill
+	// Sorted by key length descending so longer skill names match first
+	interface KeyEntry {
+		key: string;
+		skill: Skill;
+	}
+	const keyEntries: KeyEntry[] = [];
+
+	for (const skill of skills) {
+		const canonical = skill.name;
+		keyEntries.push({ key: canonical, skill });
+
+		// Slash version: "github:workflow-lifecycle" -> "github/workflow-lifecycle"
+		if (canonical.includes(":")) {
+			keyEntries.push({ key: canonical.replace(":", "/"), skill });
+		}
+
+		// Alias versions (e.g. github-ops -> github)
+		for (const [alias, target] of Object.entries(PLUGIN_ALIASES)) {
+			if (canonical.startsWith(`${target}:`)) {
+				const aliasColon = canonical.replace(`${target}:`, `${alias}:`);
+				const aliasSlash = canonical.replace(`${target}:`, `${alias}/`);
+				keyEntries.push({ key: aliasColon, skill });
+				keyEntries.push({ key: aliasSlash, skill });
+			}
+		}
+	}
+
+	// Sort key entries by length descending
+	keyEntries.sort((a, b) => b.key.length - a.key.length);
+
+	for (const entry of keyEntries) {
+		if (rawCombined === entry.key) {
+			return { skill: entry.skill, relativePath: "" };
+		}
+
+		if (rawCombined.startsWith(`${entry.key}/`) || rawCombined.startsWith(`${entry.key}:`)) {
+			const sep = rawCombined[entry.key.length];
+			let remainder = rawCombined.slice(entry.key.length + 1);
+
+			if (sep === ":") {
+				// Line range or colon suffix
+				return { skill: entry.skill, relativePath: "", suffix: remainder };
+			}
+
+			// Sep is '/'
+			if (remainder === "SKILL.md" || remainder === "SKILL.MD") {
+				remainder = "";
+			}
+			return { skill: entry.skill, relativePath: remainder };
+		}
+	}
+
+	return null;
+}

package/src/internal-urls/build-info.generated.ts

@@ -17,17 +17,17 @@ export interface BuildInfo {
 }
 
 export const BUILD_INFO: BuildInfo = {
-	"version": "20.7.0",
-	"commit": "1e634cfb3d15f8774c756a1eed5b1ef81c24c35a",
-	"shortCommit": "1e634cf",
+	"version": "20.8.0",
+	"commit": "27be1c998051e2ab0ffced6120383b502b2b77c6",
+	"shortCommit": "27be1c9",
 	"branch": "main",
-	"tag": "v20.7.0",
-	"commitDate": "2026-08-07T13:11:40Z",
-	"buildDate": "2026-08-07T13:38:50.245Z",
+	"tag": "v20.8.0",
+	"commitDate": "2026-08-08T03:42:08Z",
+	"buildDate": "2026-08-08T04:06:22.569Z",
 	"dirty": true,
 	"prNumber": "",
 	"repoUrl": "https://github.com/f5-sales-demo/xcsh",
 	"repoSlug": "f5-sales-demo/xcsh",
-	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/1e634cfb3d15f8774c756a1eed5b1ef81c24c35a",
-	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v20.7.0"
+	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/27be1c998051e2ab0ffced6120383b502b2b77c6",
+	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v20.8.0"
 };

package/src/internal-urls/skill-protocol.ts

@@ -8,6 +8,7 @@
  * - skill://<name>/<path> - Reads relative path within skill's baseDir
  */
 import * as path from "node:path";
+import { resolveSkillFromPath } from "../extensibility/skill-resolution";
 import type { Skill } from "../extensibility/skills";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
@@ -54,39 +55,37 @@ export class SkillProtocolHandler implements ProtocolHandler {
 	async resolve(url: InternalUrl): Promise<InternalResource> {
 		const skills = this.options.getSkills();
 
-		// Extract skill name from host
-		const skillName = url.rawHost || url.hostname;
-		if (!skillName) {
+		const rawHost = url.rawHost || url.hostname || "";
+		const rawPathname = url.rawPathname || url.pathname || "";
+
+		if (!rawHost && !rawPathname) {
 			throw new Error("skill:// URL requires a skill name: skill://<name>");
 		}
 
-		// Find the skill
-		const skill = skills.find(s => s.name === skillName);
-		if (!skill) {
+		// Resolve skill using resilient matcher (handles exact, colon line-ranges, slash notation, aliases)
+		const match = resolveSkillFromPath(rawHost, rawPathname, skills);
+		if (!match) {
 			const available = skills.map(s => s.name);
 			const availableStr = available.length > 0 ? available.join(", ") : "none";
-			throw new Error(`Unknown skill: ${skillName}\nAvailable: ${availableStr}`);
+			const requested = rawHost + (rawPathname ? rawPathname : "");
+			throw new Error(`Unknown skill: ${requested}\nAvailable: ${availableStr}`);
 		}
 
-		// Determine the file to read
+		const { skill, relativePath } = match;
 		let targetPath: string;
-		const urlPath = url.pathname;
-		const hasRelativePath = urlPath && urlPath !== "/" && urlPath !== "";
 
-		if (hasRelativePath) {
-			// Read relative path within skill's baseDir
-			const relativePath = decodeURIComponent(urlPath.slice(1)); // Remove leading /
-			validateRelativePath(relativePath);
-			targetPath = path.join(skill.baseDir, relativePath);
+		if (relativePath) {
+			const decoded = decodeURIComponent(relativePath);
+			validateRelativePath(decoded);
+			targetPath = path.join(skill.baseDir, decoded);
 
-			// Verify the resolved path is still within baseDir
+			// Verify resolved path stays within skill baseDir
 			const resolvedPath = path.resolve(targetPath);
 			const resolvedBaseDir = path.resolve(skill.baseDir);
 			if (!resolvedPath.startsWith(resolvedBaseDir + path.sep) && resolvedPath !== resolvedBaseDir) {
 				throw new Error("Path traversal is not allowed");
 			}
 		} else {
-			// Read SKILL.md
 			targetPath = skill.filePath;
 		}
 

package/src/tools/bash-skill-urls.ts

@@ -43,6 +43,8 @@ export interface InternalUrlExpansionOptions {
 	sessionOwnedRoots?: () => readonly string[];
 }
 
+import { resolveSkillFromPath } from "../extensibility/skill-resolution";
+
 /**
  * Resolve a single skill:// URL to its absolute filesystem path.
  * Does NOT read file content or verify existence.
@@ -54,49 +56,45 @@ export function resolveSkillUrlToPath(url: string, skills: readonly Skill[]): st
 		throw new ToolError(`Invalid skill:// URL: ${url}`);
 	}
 
-	let rawSkillSegment = parsed[1];
-	if (!rawSkillSegment) {
+	let rawHost = parsed[1];
+	if (!rawHost) {
 		throw new ToolError(`skill:// URL requires a skill name: ${url}`);
 	}
-	// Decode percent-encoded colons (%3A) used for namespaced skill names
 	try {
-		rawSkillSegment = decodeURIComponent(rawSkillSegment);
+		rawHost = decodeURIComponent(rawHost);
 	} catch {
 		// Leave as-is if decoding fails
 	}
 
-	// Resolve skill name by longest-prefix match against registered skills.
-	// This handles namespaced skills ("plugin:skill") where the URI may also
-	// carry a colon-delimited suffix (e.g., ":1-5" line range).
-	const { skill, suffix } = matchSkillName(rawSkillSegment, skills);
-	if (!skill) {
+	const rawPathname = parsed[2] ?? "";
+	const match = resolveSkillFromPath(rawHost, rawPathname, skills);
+	if (!match) {
 		const available = skills.map(s => s.name);
 		const availableStr = available.length > 0 ? available.join(", ") : "none";
-		throw new ToolError(`Unknown skill: ${rawSkillSegment}. Available: ${availableStr}`);
+		const requested = rawHost;
+		throw new ToolError(`Unknown skill: ${requested}. Available: ${availableStr}`);
 	}
 
-	// Combine any colon suffix (line range like ":1-5") with the path segment
-	const rawPath = (parsed[2] ?? "") + (suffix ? `/${suffix}` : "");
-	const hasRelativePath = rawPath !== "" && rawPath !== "/";
-
-	if (!hasRelativePath) {
+	const { skill, relativePath } = match;
+	if (!relativePath) {
 		return path.resolve(skill.filePath);
 	}
 
-	let relativePath: string;
+	let decodedRelative: string;
 	try {
-		relativePath = decodeURIComponent(rawPath.slice(1));
+		decodedRelative = decodeURIComponent(relativePath);
 	} catch {
 		throw new ToolError(`Invalid skill:// URL path encoding: ${url}`);
 	}
+
 	try {
-		validateRelativePath(relativePath);
+		validateRelativePath(decodedRelative);
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
 		throw new ToolError(message);
 	}
 
-	const targetPath = path.join(skill.baseDir, relativePath);
+	const targetPath = path.join(skill.baseDir, decodedRelative);
 	const resolvedPath = path.resolve(targetPath);
 	const resolvedBaseDir = path.resolve(skill.baseDir);
 	if (!resolvedPath.startsWith(resolvedBaseDir + path.sep) && resolvedPath !== resolvedBaseDir) {
@@ -106,39 +104,6 @@ export function resolveSkillUrlToPath(url: string, skills: readonly Skill[]): st
 	return resolvedPath;
 }
 
-/**
- * Match a raw skill segment against registered skills using longest-prefix match.
- * Handles colons in both skill names (namespacing) and suffixes (line ranges).
- *
- * For "superpowers:brainstorming:1-5" with skill "superpowers:brainstorming":
- *   -> skill = superpowers:brainstorming, suffix = "1-5"
- * For "brainstorming" with skill "brainstorming":
- *   -> skill = brainstorming, suffix = undefined
- */
-function matchSkillName(
-	rawSegment: string,
-	skills: readonly Skill[],
-): { skill: Skill | undefined; suffix: string | undefined } {
-	// Exact match first (most common case)
-	const exact = skills.find(s => s.name === rawSegment);
-	if (exact) return { skill: exact, suffix: undefined };
-
-	// Try stripping colon-delimited suffixes from the right
-	let candidate = rawSegment;
-	while (true) {
-		const lastColon = candidate.lastIndexOf(":");
-		if (lastColon <= 0) break;
-		candidate = candidate.slice(0, lastColon);
-		const match = skills.find(s => s.name === candidate);
-		if (match) {
-			const suffix = rawSegment.slice(lastColon + 1);
-			return { skill: match, suffix };
-		}
-	}
-
-	return { skill: undefined, suffix: undefined };
-}
-
 function extractScheme(url: string): SupportedInternalScheme | undefined {
 	const match = /^([a-z][a-z0-9+.-]*):\/\//i.exec(url);
 	if (!match) return undefined;