@mupt-ai/dari-gateway 0.1.0 → 0.2.1

package/dist/telemetry/skills/codex/file_reads.js

@@ -0,0 +1,37 @@
+import { codexExecCommand, readSkillsFromCodexCommand, } from "./exec_file_reads.js";
+import { codexFileSkillCatalog } from "./catalog.js";
+import { codexSkillCapabilityId } from "./identity.js";
+/** Match model-emitted Codex file reads to the exact current skill catalog. */
+export function codexAutomaticSkillObservations(request, output, limit) {
+    if (limit <= 0
+        || request.sourceProtocol !== "openai_responses"
+        || !request.tools.some((tool) => tool.kind === "function"
+            && tool.name === "exec_command"
+            && tool.namespace === undefined))
+        return [];
+    const catalog = codexFileSkillCatalog(request);
+    if (catalog === undefined)
+        return [];
+    const observedPaths = new Set();
+    const observed = [];
+    for (const item of output.items) {
+        const input = codexExecCommand(item);
+        if (input === undefined)
+            continue;
+        for (const skill of readSkillsFromCodexCommand(input, catalog)) {
+            if (observedPaths.has(skill.path.key))
+                continue;
+            observedPaths.add(skill.path.key);
+            observed.push({
+                eventType: "skill_load",
+                toolCallId: input.callId,
+                capabilityId: codexSkillCapabilityId(skill.name),
+                observedName: skill.name,
+                evidenceSource: "skill_file_read",
+            });
+            if (observed.length === limit)
+                return observed;
+        }
+    }
+    return observed;
+}

package/dist/telemetry/skills/codex/identity.d.ts

@@ -0,0 +1,2 @@
+export declare function codexSkillCapabilityId(name: string): string;
+export declare function normalizedCodexSkillName(value: unknown): string | undefined;

package/dist/telemetry/skills/codex/identity.js

@@ -0,0 +1,20 @@
+const CAPABILITY_PREFIX = "codex:name:";
+const MAX_CAPABILITY_ID_CHARS = 512;
+const MAX_SKILL_NAME_CHARS = 512;
+const SKILL_NAME = /^[A-Za-z0-9][A-Za-z0-9_:-]*$/u;
+const UNSAFE_DISPLAY_CHARACTERS = /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u;
+export function codexSkillCapabilityId(name) {
+    return `${CAPABILITY_PREFIX}${name}`;
+}
+export function normalizedCodexSkillName(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.normalize("NFC").trim();
+    return normalized.length > 0
+        && normalized.length <= MAX_SKILL_NAME_CHARS
+        && normalized.length <= MAX_CAPABILITY_ID_CHARS - CAPABILITY_PREFIX.length
+        && SKILL_NAME.test(normalized)
+        && !UNSAFE_DISPLAY_CHARACTERS.test(normalized)
+        ? normalized
+        : undefined;
+}

package/dist/telemetry/skills/observations.d.ts

@@ -0,0 +1,21 @@
+import { type InteractionOutput, type InteractionRequest } from "../../interaction/types.js";
+import type { HarnessConversationIdentity } from "../../runtime/harness_identity/index.js";
+export type SkillEvidenceSource = "skill_content_injection" | "skill_command_expansion" | "skill_tool_activation" | "skill_file_read";
+export type SkillObservation = {
+    eventType: "skill_use" | "skill_load";
+    toolCallId: string | null;
+    capabilityId: string;
+    observedName: string;
+    evidenceSource: SkillEvidenceSource;
+};
+export declare function inputSkillObservations(args: {
+    request: InteractionRequest;
+    harnessConversationIdentity?: HarnessConversationIdentity;
+    limit: number;
+}): SkillObservation[];
+export declare function outputSkillObservations(args: {
+    request: InteractionRequest;
+    output: InteractionOutput;
+    harnessConversationIdentity?: HarnessConversationIdentity;
+    limit: number;
+}): SkillObservation[];

package/dist/telemetry/skills/observations.js

@@ -0,0 +1,41 @@
+import { isBackgroundRequest } from "../../interaction/types.js";
+import { piStyleAutomaticSkillObservations, piStyleExplicitSkillObservations, } from "./pi.js";
+import { claudeFileReadObservations } from "./claude/file_reads.js";
+import { claudeSkillObservations } from "./claude/observations.js";
+import { codexExplicitSkillObservations } from "./codex/explicit.js";
+import { codexAutomaticSkillObservations } from "./codex/file_reads.js";
+export function inputSkillObservations(args) {
+    if (args.limit <= 0 || isBackgroundRequest(args.request))
+        return [];
+    if (args.request.requestPurpose === undefined
+        && args.request.sourceProtocol === "openai_chat") {
+        return piStyleExplicitSkillObservations(args.request, args.limit);
+    }
+    if (args.request.requestPurpose === undefined
+        && args.request.sourceProtocol === "openai_responses"
+        && args.harnessConversationIdentity?.kind === "codex_thread"
+        && args.harnessConversationIdentity.userTurnId !== undefined) {
+        return codexExplicitSkillObservations(args.request, args.harnessConversationIdentity.userTurnId, args.limit);
+    }
+    if (args.request.sourceProtocol === "anthropic_messages"
+        && args.harnessConversationIdentity?.kind === "claude_code_session") {
+        return claudeSkillObservations(args.request, args.limit);
+    }
+    return [];
+}
+export function outputSkillObservations(args) {
+    if (args.limit <= 0 || isBackgroundRequest(args.request))
+        return [];
+    if (args.request.sourceProtocol === "openai_chat") {
+        return piStyleAutomaticSkillObservations(args.request, args.output, args.limit);
+    }
+    if (args.request.sourceProtocol === "openai_responses"
+        && args.harnessConversationIdentity?.kind === "codex_thread") {
+        return codexAutomaticSkillObservations(args.request, args.output, args.limit);
+    }
+    if (args.request.sourceProtocol === "anthropic_messages"
+        && args.harnessConversationIdentity?.kind === "claude_code_session") {
+        return claudeFileReadObservations(args.request, args.output, args.limit);
+    }
+    return [];
+}

package/dist/telemetry/skills/paths.d.ts

@@ -0,0 +1,11 @@
+export type PathPlatform = "posix" | "windows";
+export type NormalizedSkillPath = {
+    platform: PathPlatform;
+    value: string;
+    key: string;
+};
+export declare function normalizedAbsoluteSkillPath(value: unknown): NormalizedSkillPath | undefined;
+export declare function resolvedSkillPath(value: string, workdir: NormalizedSkillPath | undefined): NormalizedSkillPath | undefined;
+export declare function joinedSkillPath(root: NormalizedSkillPath, suffix: string): NormalizedSkillPath | undefined;
+export declare function skillPathBasename(path: NormalizedSkillPath): string;
+export declare function skillPathSegments(path: NormalizedSkillPath): string[];

package/dist/telemetry/skills/paths.js

@@ -0,0 +1,61 @@
+import { posix, win32 } from "node:path";
+const MAX_SKILL_PATH_CHARS = 16 * 1024;
+const UNSAFE_DISPLAY_CHARACTERS = /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u;
+export function normalizedAbsoluteSkillPath(value) {
+    if (typeof value !== "string"
+        || value.length === 0
+        || value.length > MAX_SKILL_PATH_CHARS
+        || UNSAFE_DISPLAY_CHARACTERS.test(value)
+        || hasParentPathSegment(value))
+        return undefined;
+    if (posix.isAbsolute(value)) {
+        const normalized = posix.normalize(value);
+        return { platform: "posix", value: normalized, key: `posix:${normalized}` };
+    }
+    if (win32.isAbsolute(value)) {
+        const normalized = win32.normalize(value);
+        return {
+            platform: "windows",
+            value: normalized,
+            key: `windows:${normalized.toLowerCase()}`,
+        };
+    }
+    return undefined;
+}
+export function resolvedSkillPath(value, workdir) {
+    if (hasParentPathSegment(value) || /^[A-Za-z]:[^\\/]/u.test(value)) {
+        return undefined;
+    }
+    const absolute = normalizedAbsoluteSkillPath(value);
+    if (absolute !== undefined)
+        return absolute;
+    if (workdir === undefined)
+        return undefined;
+    const resolved = workdir.platform === "windows"
+        ? win32.resolve(workdir.value, value)
+        : posix.resolve(workdir.value, value);
+    const normalized = normalizedAbsoluteSkillPath(resolved);
+    return normalized?.platform === workdir.platform ? normalized : undefined;
+}
+export function joinedSkillPath(root, suffix) {
+    if (hasParentPathSegment(suffix))
+        return undefined;
+    const joined = root.platform === "windows"
+        ? win32.join(root.value, ...suffix.split("/"))
+        : posix.join(root.value, suffix);
+    const normalized = normalizedAbsoluteSkillPath(joined);
+    return normalized?.platform === root.platform ? normalized : undefined;
+}
+export function skillPathBasename(path) {
+    return path.platform === "windows"
+        ? win32.basename(path.value)
+        : posix.basename(path.value);
+}
+export function skillPathSegments(path) {
+    const implementation = path.platform === "windows" ? win32 : posix;
+    const root = implementation.parse(path.value).root;
+    return path.value.slice(root.length).split(implementation.sep).filter(Boolean);
+}
+function hasParentPathSegment(value) {
+    return value.split(/[\\/]/u).includes("..");
+}

package/dist/telemetry/skills/pi.d.ts

@@ -0,0 +1,6 @@
+import type { InteractionOutput, InteractionRequest } from "../../interaction/types.js";
+import type { SkillObservation } from "./observations.js";
+/** Parse the exact expansion emitted by Pi for `/skill:name [arguments]`. */
+export declare function piStyleExplicitSkillObservations(request: InteractionRequest, limit: number): SkillObservation[];
+/** Match a current model-emitted Pi `read` call to its exact skill catalog entry. */
+export declare function piStyleAutomaticSkillObservations(request: InteractionRequest, output: InteractionOutput, limit: number): SkillObservation[];

package/dist/telemetry/skills/pi.js

@@ -0,0 +1,223 @@
+import { interactionToolInput } from "../tools/input.js";
+const CAPABILITY_PREFIX = "unattributed:name:";
+const MAX_CAPABILITY_ID_CHARS = 512;
+const MAX_SKILL_NAME_CHARS = 64;
+const MAX_SKILL_PATH_CHARS = 16 * 1024;
+const PI_SKILL_CLOSE = "\n</skill>";
+const SKILL_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/u;
+const UNSAFE_DISPLAY_CHARACTERS = /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u;
+const XML_ENTITY = /&(amp|lt|gt|quot|apos);/gu;
+const INVALID_XML_ENTITY = /&(?!(?:amp|lt|gt|quot|apos);)/u;
+const PI_SKILL_BLOCK = /(?:^|\n)  <skill>\n([\s\S]*?)\n  <\/skill>(?=\n|$)/gu;
+const PI_SKILL_FIELDS = /^    <name>([^\n]*)<\/name>\n    <description>[\s\S]*<\/description>\n    <location>([^\n]*)<\/location>$/u;
+/** Parse the exact expansion emitted by Pi for `/skill:name [arguments]`. */
+export function piStyleExplicitSkillObservations(request, limit) {
+    if (limit <= 0)
+        return [];
+    return trailingUserMessages(request)
+        .flatMap((message) => {
+        const textParts = message.content.filter((part) => part.type === "text");
+        if (textParts.length !== 1
+            || message.content.some((part) => part.type !== "text" && part.type !== "image"))
+            return [];
+        const name = piStyleSkillName(textParts[0].text);
+        return name === undefined
+            ? []
+            : [observation(name, "skill_use", "skill_command_expansion", null)];
+    })
+        .slice(0, limit);
+}
+/** Match a current model-emitted Pi `read` call to its exact skill catalog entry. */
+export function piStyleAutomaticSkillObservations(request, output, limit) {
+    if (limit <= 0
+        || request.sourceProtocol !== "openai_chat"
+        || !request.tools.some((tool) => tool.kind === "function"
+            && tool.name === "read"
+            && tool.namespace === undefined)) {
+        return [];
+    }
+    const skillsByLocation = piStyleAvailableSkills(request);
+    if (skillsByLocation.size === 0)
+        return [];
+    const observedCapabilities = new Set();
+    const observed = [];
+    for (const item of output.items) {
+        const read = piSkillRead(item);
+        if (read === undefined)
+            continue;
+        const name = skillsByLocation.get(read.path);
+        if (name === undefined)
+            continue;
+        const skill = observation(name, "skill_load", "skill_file_read", read.toolCallId);
+        if (observedCapabilities.has(skill.capabilityId))
+            continue;
+        observedCapabilities.add(skill.capabilityId);
+        observed.push(skill);
+        if (observed.length === limit)
+            break;
+    }
+    return observed;
+}
+function observation(name, eventType, evidenceSource, toolCallId) {
+    return {
+        eventType,
+        toolCallId,
+        capabilityId: `${CAPABILITY_PREFIX}${name}`,
+        observedName: name,
+        evidenceSource,
+    };
+}
+function piStyleAvailableSkills(request) {
+    const skills = new Map();
+    const ambiguousLocations = new Set();
+    for (const item of request.items) {
+        if (item.type !== "message"
+            || (item.role !== "system" && item.role !== "developer")) {
+            continue;
+        }
+        for (const part of item.content) {
+            if (part.type !== "text")
+                continue;
+            for (const section of part.text.matchAll(/(?:^|\n)<available_skills>\n([\s\S]*?)\n<\/available_skills>(?=\n|$)/gu)) {
+                const body = section[1];
+                if (body === undefined)
+                    continue;
+                for (const block of body.matchAll(PI_SKILL_BLOCK)) {
+                    const fields = block[1]?.match(PI_SKILL_FIELDS);
+                    if (fields === null || fields === undefined)
+                        continue;
+                    const nameValue = decodePiXmlText(fields[1]);
+                    const location = normalizedSkillPath(decodePiXmlText(fields[2]));
+                    const name = nameValue === undefined
+                        ? undefined
+                        : normalizedSkillName(nameValue);
+                    if (name === undefined
+                        || location === undefined
+                        || ambiguousLocations.has(location)) {
+                        continue;
+                    }
+                    const previous = skills.get(location);
+                    if (previous !== undefined && previous !== name) {
+                        skills.delete(location);
+                        ambiguousLocations.add(location);
+                    }
+                    else {
+                        skills.set(location, name);
+                    }
+                }
+            }
+        }
+    }
+    return skills;
+}
+function piSkillRead(item) {
+    if (item.type !== "tool_call"
+        || item.kind !== "function"
+        || item.namespace !== undefined
+        || item.name !== "read") {
+        return undefined;
+    }
+    const input = interactionToolInput(item);
+    const path = input === undefined ? undefined : normalizedSkillPath(input.path);
+    return path === undefined ? undefined : { path, toolCallId: item.callId };
+}
+function decodePiXmlText(value) {
+    if (value === undefined || INVALID_XML_ENTITY.test(value))
+        return undefined;
+    const entities = {
+        amp: "&",
+        lt: "<",
+        gt: ">",
+        quot: '"',
+        apos: "'",
+    };
+    return value.replace(XML_ENTITY, (_entity, name) => entities[name] ?? "");
+}
+function normalizedSkillPath(value) {
+    if (typeof value !== "string")
+        return undefined;
+    return value.length > 0
+        && value.length <= MAX_SKILL_PATH_CHARS
+        && !UNSAFE_DISPLAY_CHARACTERS.test(value)
+        ? value
+        : undefined;
+}
+function trailingUserMessages(request) {
+    let index = request.items.length - 1;
+    while (index >= 0) {
+        const item = request.items[index];
+        if (item.type === "message"
+            && (item.role === "system" || item.role === "developer")) {
+            index -= 1;
+            continue;
+        }
+        break;
+    }
+    const messages = [];
+    while (index >= 0) {
+        const item = request.items[index];
+        if (item.type !== "message" || item.role !== "user")
+            break;
+        messages.push(item);
+        index -= 1;
+    }
+    return messages.reverse();
+}
+function piStyleSkillName(text) {
+    const namePrefix = '<skill name="';
+    if (!text.startsWith(namePrefix))
+        return undefined;
+    const nameEnd = text.indexOf('" location="', namePrefix.length);
+    if (nameEnd < 0)
+        return undefined;
+    const locationStart = nameEnd + '" location="'.length;
+    const locationEnd = text.indexOf('">\n', locationStart);
+    if (locationEnd < 0)
+        return undefined;
+    const bodyStart = locationEnd + '">\n'.length;
+    const bodyEnd = piStyleSkillBodyEnd(text, bodyStart);
+    if (bodyEnd < 0)
+        return undefined;
+    const name = normalizedSkillName(text.slice(namePrefix.length, nameEnd));
+    const location = text.slice(locationStart, locationEnd);
+    const body = text.slice(bodyStart, bodyEnd);
+    const referencesPrefix = "References are relative to ";
+    const referencesEnd = body.indexOf(".\n\n", referencesPrefix.length);
+    if (name === undefined
+        || location.length === 0
+        || location.length > MAX_SKILL_PATH_CHARS
+        || UNSAFE_DISPLAY_CHARACTERS.test(location)
+        || !body.startsWith(referencesPrefix)
+        || referencesEnd < 0
+        || body.slice(referencesEnd + ".\n\n".length).trim() === "") {
+        return undefined;
+    }
+    return name;
+}
+function piStyleSkillBodyEnd(text, bodyStart) {
+    let lastNonWhitespace = text.length - 1;
+    while (lastNonWhitespace >= 0 && /\s/u.test(text[lastNonWhitespace])) {
+        lastNonWhitespace -= 1;
+    }
+    let candidate = text.indexOf(PI_SKILL_CLOSE, bodyStart);
+    while (candidate >= 0) {
+        const suffixStart = candidate + PI_SKILL_CLOSE.length;
+        if (suffixStart === text.length
+            || (text.startsWith("\n\n", suffixStart)
+                && suffixStart + 2 <= lastNonWhitespace)) {
+            return candidate;
+        }
+        candidate = text.indexOf(PI_SKILL_CLOSE, suffixStart);
+    }
+    return -1;
+}
+function normalizedSkillName(value) {
+    const normalized = value.normalize("NFC").trim();
+    return normalized.length > 0
+        && normalized.length <= MAX_SKILL_NAME_CHARS
+        && normalized.length <= MAX_CAPABILITY_ID_CHARS - CAPABILITY_PREFIX.length
+        && SKILL_NAME.test(normalized)
+        && !UNSAFE_DISPLAY_CHARACTERS.test(normalized)
+        ? normalized
+        : undefined;
+}

package/dist/telemetry/skills/shell_file_reads.d.ts

@@ -0,0 +1,7 @@
+import { type NormalizedSkillPath, type PathPlatform } from "./paths.js";
+export type ShellReadCommand = {
+    command: string;
+    workdir?: string;
+};
+/** Parse only direct, deterministic shell readers and return their resolved paths. */
+export declare function readPathsFromShellCommand(input: ShellReadCommand, platform: PathPlatform, nesting?: number): NormalizedSkillPath[];

package/dist/telemetry/skills/shell_file_reads.js

@@ -0,0 +1,226 @@
+import { normalizedAbsoluteSkillPath, resolvedSkillPath, } from "./paths.js";
+import { executableCommand, restrictedShellSegments, trustedExecutableName, } from "./shell_words.js";
+const MAX_SHELL_NESTING = 16;
+const NO_VALUE_FLAGS = new Set();
+const BAT_VALUE_FLAGS = new Set([
+    "--language",
+    "--line-range",
+    "--map-syntax",
+    "--style",
+    "--tabs",
+    "--terminal-width",
+    "--theme",
+]);
+const HEAD_TAIL_VALUE_FLAGS = new Set(["-c", "--bytes", "-n", "--lines"]);
+const LESS_VALUE_FLAGS = new Set([
+    "--LOG-FILE",
+    "-j",
+    "--jump-target",
+    "--log-file",
+    "-o",
+    "-O",
+    "-p",
+    "--pattern",
+    "-P",
+    "--prompt",
+    "--shift",
+    "--tabs",
+    "-x",
+    "-y",
+    "-z",
+]);
+const NL_VALUE_FLAGS = new Set([
+    "--body-numbering",
+    "--footer-numbering",
+    "--header-numbering",
+    "--join-blank-lines",
+    "--number-format",
+    "--number-separator",
+    "--number-width",
+    "--section-delimiter",
+    "--starting-line-number",
+    "-b",
+    "-d",
+    "-f",
+    "-h",
+    "-i",
+    "-n",
+    "-s",
+    "-v",
+    "-w",
+]);
+const AWK_VALUE_FLAGS = new Set(["-F", "-v"]);
+/** Parse only direct, deterministic shell readers and return their resolved paths. */
+export function readPathsFromShellCommand(input, platform, nesting = 0) {
+    if (nesting > MAX_SHELL_NESTING)
+        return [];
+    const segments = restrictedShellSegments(input.command, platform);
+    if (segments === undefined)
+        return [];
+    const normalizedWorkdir = normalizedAbsoluteSkillPath(input.workdir);
+    let workdir = normalizedWorkdir?.platform === platform
+        ? normalizedWorkdir
+        : undefined;
+    const observed = [];
+    let previousOperator = null;
+    let previousWasSupported = false;
+    for (const segment of segments) {
+        const command = executableCommand(segment.words);
+        if (command === undefined) {
+            previousOperator = segment.next;
+            previousWasSupported = false;
+            continue;
+        }
+        const executable = trustedExecutableName(command.executable, platform);
+        if (executable === undefined) {
+            previousOperator = segment.next;
+            previousWasSupported = false;
+            continue;
+        }
+        if (previousOperator === "||")
+            return [];
+        if (previousOperator === "&&" && !previousWasSupported) {
+            previousOperator = segment.next;
+            previousWasSupported = false;
+            continue;
+        }
+        if (executable === "cd") {
+            const nextWorkdir = cdTarget(command.args, workdir, platform);
+            if (nextWorkdir !== undefined
+                && (segment.next === "&&" || segment.next === ";" || segment.next === "\n"))
+                workdir = nextWorkdir;
+            previousOperator = segment.next;
+            previousWasSupported = nextWorkdir !== undefined;
+            continue;
+        }
+        if (platform === "posix"
+            && (executable === "bash" || executable === "zsh" || executable === "sh")
+            && command.args.length >= 2
+            && /^-[^-]*c[^-]*$/u.test(command.args[0])) {
+            observed.push(...readPathsFromShellCommand({
+                command: command.args[1],
+                ...(workdir === undefined ? {} : { workdir: workdir.value }),
+            }, platform, nesting + 1));
+            previousOperator = segment.next;
+            previousWasSupported = false;
+            continue;
+        }
+        const paths = readerPaths(executable, command.args, platform);
+        if (paths === undefined) {
+            previousOperator = segment.next;
+            previousWasSupported = false;
+            continue;
+        }
+        for (const path of paths) {
+            const resolved = resolvedSkillPath(path, workdir);
+            if (resolved?.platform === platform)
+                observed.push(resolved);
+        }
+        previousOperator = segment.next;
+        previousWasSupported = true;
+    }
+    return observed;
+}
+function readerPaths(executable, args, platform) {
+    switch (executable) {
+        case "cat":
+        case "more":
+            return ordinaryFileOperands(args, NO_VALUE_FLAGS);
+        case "bat":
+        case "batcat":
+            return ordinaryFileOperands(args, BAT_VALUE_FLAGS);
+        case "head":
+        case "tail":
+            return ordinaryFileOperands(args, HEAD_TAIL_VALUE_FLAGS);
+        case "less":
+            return ordinaryFileOperands(args, LESS_VALUE_FLAGS);
+        case "nl":
+            return ordinaryFileOperands(args, NL_VALUE_FLAGS);
+        case "sed":
+            return sedFileOperands(args);
+        case "awk":
+            return ordinaryFileOperands(args, AWK_VALUE_FLAGS).slice(1);
+        case "get-content":
+        case "gc":
+        case "type":
+            return platform === "windows" ? powershellFileOperands(args) : [];
+        default:
+            return undefined;
+    }
+}
+function ordinaryFileOperands(args, valueFlags) {
+    const files = [];
+    let optionsEnded = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (!optionsEnded && argument === "--") {
+            optionsEnded = true;
+            continue;
+        }
+        if (!optionsEnded && valueFlags.has(argument)) {
+            index += 1;
+            continue;
+        }
+        if (!optionsEnded && argument.startsWith("-"))
+            continue;
+        files.push(argument);
+    }
+    return files;
+}
+function sedFileOperands(args) {
+    const files = [];
+    let explicitProgram = false;
+    let implicitProgramConsumed = false;
+    let optionsEnded = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (!optionsEnded && argument === "--") {
+            optionsEnded = true;
+            continue;
+        }
+        if (!optionsEnded && ["-e", "--expression", "-f", "--file"].includes(argument)) {
+            explicitProgram = true;
+            index += 1;
+            continue;
+        }
+        if (!optionsEnded && (argument.startsWith("-e")
+            || argument.startsWith("--expression=")
+            || argument.startsWith("-f")
+            || argument.startsWith("--file="))) {
+            explicitProgram = true;
+            continue;
+        }
+        if (!optionsEnded && argument.startsWith("-"))
+            continue;
+        if (!explicitProgram && !implicitProgramConsumed) {
+            implicitProgramConsumed = true;
+            continue;
+        }
+        files.push(argument);
+    }
+    return files;
+}
+function powershellFileOperands(args) {
+    const files = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (/^-(?:Path|LiteralPath)$/iu.test(argument)) {
+            const path = args[index + 1];
+            if (path !== undefined)
+                files.push(path);
+            index += 1;
+            continue;
+        }
+        if (!argument.startsWith("-"))
+            files.push(argument);
+    }
+    return files;
+}
+function cdTarget(args, workdir, platform) {
+    const operands = args.filter((argument) => argument !== "--" && !argument.startsWith("-"));
+    const target = operands.at(-1);
+    const resolved = target === undefined
+        ? undefined
+        : resolvedSkillPath(target, workdir);
+    return resolved?.platform === platform ? resolved : undefined;
+}

package/dist/telemetry/skills/shell_words.d.ts

@@ -0,0 +1,13 @@
+import type { PathPlatform } from "./paths.js";
+export type ShellOperator = "&" | "&&" | "|" | "||" | ";" | "\n";
+export type ShellSegment = {
+    words: string[];
+    next: ShellOperator | null;
+};
+export type ExecutableCommand = {
+    executable: string;
+    args: string[];
+};
+export declare function executableCommand(words: string[]): ExecutableCommand | undefined;
+export declare function restrictedShellSegments(command: string, platform: PathPlatform): ShellSegment[] | undefined;
+export declare function trustedExecutableName(command: string, platform: PathPlatform): string | undefined;