@qvac/harness 1.0.0-rc.0 → 1.0.0-rc.2

package/dist-lib/lib/skills-host/index.js

@@ -0,0 +1,268 @@
+import process from 'process';
+import { errorMessage } from '../guards.js';
+import { hlog } from '../log.js';
+import { modelNameToCapabilityProfile } from '../models/model-catalog.js';
+import { probeBinVersions } from '../tools/skills/bin-check.js';
+import { ensureBundledSkillsDir } from '../tools/skills/bundled-dir.js';
+import { availableSkills, detectPlatform, loadSkillCatalog, resolveSkillStatuses, skillSupportsPlatform, versionProbeSkills } from '../tools/skills/catalog.js';
+import { resetCredentialHealth } from '../tools/skills/credential-health.js';
+import { ensureSkillsOverlayDir } from '../tools/skills/overlay-dir.js';
+import { copyBaseForEdit, deleteOverlaySkill, listManagedSkills, readSkillFile, writeSkillFile } from '../tools/skills/overlay-crud.js';
+import { watchSkillsOverlay } from '../tools/skills/overlay-watch.js';
+import { deviceSharedKeys, scopeKey } from '../tools/skills/scope-key.js';
+import { settingsScopeKey } from '../tools/skills/skill-settings.js';
+import { bareRuntime } from '../tools/exec/bare-runtime.js';
+import { runCommand } from '../tools/exec/runner.js';
+export class SkillsHost {
+    static BIN_VERSION_PROBE_TTL_MS = 45_000;
+    _skillsDir;
+    _platform;
+    _credentialStore;
+    _tools;
+    _startPlugins;
+    _watcher = null;
+    _allSkills = [];
+    _supportedSkills = [];
+    _credentials = new Map();
+    _settings = new Map();
+    _readiness = new Map();
+    _deviceSharedKeys = null;
+    _binVersionCache = null;
+    _binVersionInflight = null;
+    constructor(opts) {
+        this._skillsDir = opts.skillsDir;
+        this._platform = opts.platform;
+        this._credentialStore = opts.credentialStore;
+        this._tools = opts.tools;
+        this._startPlugins = opts.startPlugins;
+    }
+    get names() {
+        return this._supportedSkills.map((skill) => skill.name);
+    }
+    async open() {
+        await this._reload();
+        await this._watch();
+    }
+    close() {
+        this._watcher?.stop();
+        this._watcher = null;
+    }
+    publish(skills) {
+        this._readiness = new Map(skills.map((readiness) => [readiness.skill, readiness]));
+        this._deviceSharedKeys = deviceSharedKeys(skills);
+        this._filter();
+    }
+    setCredentials(entries) {
+        const previous = this._credentials;
+        const next = new Map();
+        for (const { key, token, expiresAt, agentId, skill } of entries) {
+            if (!token)
+                continue;
+            const storeKey = scopeKey({ agentId, skill, key });
+            const record = typeof expiresAt === 'number' && expiresAt > 0 ? { token, expiresAt } : { token };
+            const current = previous.get(storeKey);
+            if (!current || current.token !== record.token || current.expiresAt !== record.expiresAt) {
+                resetCredentialHealth(key, agentId, skill);
+            }
+            next.set(storeKey, record);
+        }
+        this._credentials = next;
+    }
+    setSkillSettings(entries) {
+        const next = new Map();
+        for (const { skill, key, value, agentId } of entries) {
+            if (!skill || !key || typeof value !== 'string')
+                continue;
+            const scope = settingsScopeKey(skill, agentId);
+            const bucket = next.get(scope) ?? {};
+            bucket[key] = value;
+            next.set(scope, bucket);
+        }
+        this._settings = next;
+    }
+    skillSettings(skill, agentId) {
+        return {
+            ...this._settings.get(settingsScopeKey(skill, null)),
+            ...(agentId ? this._settings.get(settingsScopeKey(skill, agentId)) : undefined)
+        };
+    }
+    async listManagedSkills() {
+        return listManagedSkills(await this._baseDir(), await ensureSkillsOverlayDir());
+    }
+    async readSkillFile(name) {
+        return readSkillFile(await this._baseDir(), await ensureSkillsOverlayDir(), name);
+    }
+    async writeSkillFile(name, content) {
+        const overlay = await this._overlayDir();
+        await writeSkillFile(overlay, name, content);
+        await this._reload();
+        return { ok: true };
+    }
+    async copyBaseForEdit(name) {
+        const overlay = await this._overlayDir();
+        const result = await copyBaseForEdit(await this._baseDir(), overlay, name);
+        if (result.copied) {
+            await this._reload();
+        }
+        return result;
+    }
+    async deleteOverlaySkill(name) {
+        const overlay = await this._overlayDir();
+        const result = await deleteOverlaySkill(overlay, name);
+        if (result.removed) {
+            await this._reload();
+        }
+        return result;
+    }
+    resolveCredential(key, ctx) {
+        if (this._credentialStore) {
+            return this._credentialStore(key, ctx);
+        }
+        const agentId = ctx?.agentId ?? null;
+        if (agentId && !this._deviceSharedKeys) {
+            return this._startPlugins().then(() => this.resolveCredential(key, ctx));
+        }
+        const deviceShared = this._deviceSharedKeys?.has(key) === true;
+        for (const skill of ctx?.skills ?? []) {
+            const owned = this._credentials.get(scopeKey({ agentId, skill, key })) ??
+                (agentId && deviceShared ? this._credentials.get(scopeKey({ skill, key })) : undefined);
+            if (owned) {
+                return owned;
+            }
+        }
+        if (agentId) {
+            const scoped = this._credentials.get(scopeKey({ agentId, key }));
+            if (scoped) {
+                return scoped;
+            }
+        }
+        if (!agentId || deviceShared) {
+            return this._credentials.get(scopeKey({ key })) ?? null;
+        }
+        return null;
+    }
+    async statuses(agentId, modelName, options) {
+        const platform = this._currentPlatform();
+        const refresh = options?.refresh === true;
+        return resolveSkillStatuses(this._allSkills, {
+            installedTools: this._installedTools(),
+            credentialStore: (key, ctx) => this.resolveCredential(key, ctx),
+            settingsStore: (skill, agentId) => this.skillSettings(skill, agentId),
+            platform,
+            agentId,
+            binVersions: options?.skipBinProbe === true
+                ? (this._binVersionCache?.bySkill ?? new Map())
+                : await this._probeBinVersions(platform, refresh),
+            refresh,
+            skipCredentialProbe: options?.skipCredentialProbe === true,
+            activeProfile: modelName ? modelNameToCapabilityProfile(modelName) : undefined,
+            readiness: this._readiness
+        });
+    }
+    async completionSkills(agentId, model) {
+        const statuses = new Map((await this.statuses(agentId, model, { skipCredentialProbe: true, skipBinProbe: true })).map((entry) => [entry.name, entry.status]));
+        return availableSkills(this._supportedSkills, this._installedTools()).map((entry) => ({
+            ...entry,
+            status: statuses.get(entry.name)
+        }));
+    }
+    _currentPlatform() {
+        return this._platform ?? detectPlatform();
+    }
+    _installedTools() {
+        return new Set(this._tools().map((tool) => tool.name));
+    }
+    async _baseDir() {
+        return this._skillsDir ?? (await ensureBundledSkillsDir());
+    }
+    async _overlayDir() {
+        const overlay = await ensureSkillsOverlayDir();
+        if (!overlay) {
+            throw new Error('no writable skills overlay is configured');
+        }
+        return overlay;
+    }
+    async _reload() {
+        this._allSkills = await loadSkillCatalog(await this._baseDir(), { platform: null });
+        this._filter();
+    }
+    _filter() {
+        const platform = this._currentPlatform();
+        const supported = this._allSkills.filter((skill) => skillSupportsPlatform(skill, platform));
+        this._supportedSkills = availableSkills(supported, this._installedTools());
+    }
+    async _watch() {
+        if (this._watcher)
+            return;
+        try {
+            const overlay = await ensureSkillsOverlayDir();
+            if (!overlay) {
+                return;
+            }
+            this._watcher = watchSkillsOverlay(overlay, () => {
+                this._reload().catch((err) => hlog('overlay reload failed', { err: errorMessage(err) }));
+            });
+        }
+        catch (err) {
+            hlog('overlay watch unavailable', { err: errorMessage(err) });
+        }
+    }
+    async _probeBinVersions(platform, refresh) {
+        const now = Date.now();
+        if (!refresh && this._binVersionCache && this._binVersionCache.expiresAt > now) {
+            return this._binVersionCache.bySkill;
+        }
+        if (this._binVersionInflight) {
+            return this._binVersionInflight;
+        }
+        this._binVersionInflight = this._runBinVersionProbes(platform)
+            .then((bySkill) => {
+            this._binVersionCache = {
+                expiresAt: Date.now() + SkillsHost.BIN_VERSION_PROBE_TTL_MS,
+                bySkill
+            };
+            return bySkill;
+        })
+            .finally(() => {
+            this._binVersionInflight = null;
+        });
+        return this._binVersionInflight;
+    }
+    async _runBinVersionProbes(platform) {
+        if (process.env.QVAC_NO_SKILL_BIN_PROBE) {
+            return new Map();
+        }
+        const candidates = versionProbeSkills(this._allSkills, {
+            installedTools: this._installedTools(),
+            platform,
+            readiness: this._readiness
+        });
+        if (candidates.length === 0) {
+            return new Map();
+        }
+        let runtime;
+        try {
+            runtime = await bareRuntime();
+        }
+        catch {
+            return new Map();
+        }
+        const run = async (command) => {
+            try {
+                const result = await runCommand(command, { ...runtime, timeoutMs: 5_000 });
+                return result.exitCode === 0 ? result.stdout : null;
+            }
+            catch {
+                return null;
+            }
+        };
+        const bySkill = new Map();
+        for (const skill of candidates) {
+            const states = await probeBinVersions(skill.requires, { platform, run });
+            if (states.size > 0) {
+                bySkill.set(skill.name, states);
+            }
+        }
+        return bySkill;
+    }
+}

package/dist-lib/lib/spawn.d.ts

@@ -3,9 +3,8 @@ import { type StowIpc, type StowRunner } from 'bare-supervisor/stow';
 import type { ChildSpec } from 'bare-supervisor';
 import { type RemoteHarness } from './connect.ts';
 import { type EmbedDevice } from './models/embed-config.ts';
-import type { ImageClamps } from './models/model-catalog.ts';
-import type { ImageModelSet } from './tools/generate-image.ts';
-import type { MusicClamps, MusicModelStages } from './tools/generate-music.ts';
+import type { LlamaLoadKnobs } from './models/model-pool.ts';
+import type { ImageClamps, ImageModelSet, MusicClamps, MusicModelStages } from './models/model-catalog.ts';
 export type MusicModelArg = string | (MusicModelStages & {
     inferenceSteps?: number;
     useGpu?: boolean;
@@ -20,8 +19,39 @@ export interface HarnessLlmConfig {
     contextSize?: number;
     kvCacheK?: string;
     kvCacheV?: string;
+    llmLoad?: LlamaLoadKnobs;
+    slots?: number;
     completionModelCap?: number;
 }
+export interface HarnessKnowledgeConfig {
+    dir: string;
+    model: string;
+}
+export interface HarnessSpeechOptions {
+    tts?: 'supertonic' | 'moss';
+    voice?: string;
+    dialogue?: {
+        backbone: string;
+        speakers: {
+            audio: string;
+            transcript: string;
+        }[];
+    };
+}
+export interface HarnessMcpServer {
+    name: string;
+    url: string;
+    auth?: {
+        tokenCredentialKey: string;
+    };
+    defer?: boolean;
+}
+export interface HarnessPluginOptions {
+    speech?: HarnessSpeechOptions;
+    mcp?: {
+        servers?: HarnessMcpServer[];
+    };
+}
 export interface HarnessChildOptions {
     runner: StowRunner;
     skillsDir?: string;
@@ -36,6 +66,8 @@ export interface HarnessChildOptions {
     musicModel?: MusicModelArg;
     musicClamps?: MusicClamps;
     llm?: HarnessLlmConfig;
+    knowledge?: HarnessKnowledgeConfig;
+    pluginOptions?: HarnessPluginOptions;
     onIpc?: (ipc: StowIpc) => void;
     logger?: Logger | null;
     deps?: string[];
@@ -60,6 +92,8 @@ export interface SpawnHarnessOptions {
     musicModel?: MusicModelArg;
     musicClamps?: MusicClamps;
     llm?: HarnessLlmConfig;
+    knowledge?: HarnessKnowledgeConfig;
+    pluginOptions?: HarnessPluginOptions;
     logger?: Logger | null;
 }
 export declare function spawnHarness(opts: SpawnHarnessOptions): RemoteHarness;

package/dist-lib/lib/spawn.js

@@ -6,7 +6,7 @@ export function harnessChild(entry, opts) {
     if (opts.logger) {
         setHarnessLog(true);
     }
-    const { runner, skillsDir, gpuStats, wheelsDir, sdkStorage, embedDevice, embedGpuLayers, embedBatchSize, imageModel, imageClamps, musicModel, musicClamps, llm, onIpc, logger = null, ...spec } = opts;
+    const { runner, skillsDir, gpuStats, wheelsDir, sdkStorage, embedDevice, embedGpuLayers, embedBatchSize, imageModel, imageClamps, musicModel, musicClamps, llm, knowledge, pluginOptions, onIpc, logger = null, ...spec } = opts;
     const embedConfig = createEmbedConfig({
         device: embedDevice,
         gpuLayers: embedGpuLayers,
@@ -26,7 +26,9 @@ export function harnessChild(entry, opts) {
             musicModel ? JSON.stringify(musicModel) : '',
             musicClamps ? JSON.stringify(musicClamps) : '',
             wheelsDir ?? '',
-            gpuStats === undefined ? '' : JSON.stringify(gpuStats)
+            gpuStats === undefined ? '' : JSON.stringify(gpuStats),
+            knowledge ? JSON.stringify(knowledge) : '',
+            pluginOptions ? JSON.stringify(pluginOptions) : ''
         ],
         logger,
         create: (ipc) => {
@@ -60,7 +62,9 @@ export function spawnHarness(opts) {
             opts.musicModel ? JSON.stringify(opts.musicModel) : '',
             opts.musicClamps ? JSON.stringify(opts.musicClamps) : '',
             opts.wheelsDir ?? '',
-            opts.gpuStats === undefined ? '' : JSON.stringify(opts.gpuStats)
+            opts.gpuStats === undefined ? '' : JSON.stringify(opts.gpuStats),
+            opts.knowledge ? JSON.stringify(opts.knowledge) : '',
+            opts.pluginOptions ? JSON.stringify(opts.pluginOptions) : ''
         ]);
         sidecar.stdout.on('data', (data) => logger?.info('harness', data.toString().trimEnd()));
         sidecar.stderr.on('data', (data) => logger?.warn('harness', data.toString().trimEnd()));

package/dist-lib/lib/spill.d.ts

@@ -0,0 +1,11 @@
+import type { ToolSpill } from './contract/index.ts';
+export declare const SPILL_DIR: string;
+export declare const SPILL_MAX_BYTES: number;
+export declare const SPILL_MAX_AGE_MS: number;
+export interface SpillOptions {
+    readonly root?: string;
+    readonly maxBytes?: number;
+}
+export declare function runSpill(runId: string, { root, maxBytes }?: SpillOptions): ToolSpill | undefined;
+export declare function removeRun(runId: string, root?: string): Promise<void>;
+export declare function sweepSpill(now?: number, root?: string): void;

package/dist-lib/lib/spill.js

@@ -0,0 +1,82 @@
+import b4a from 'b4a';
+import { randomBytes } from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { userTmpPath } from './tmp-path.js';
+export const SPILL_DIR = userTmpPath('qvac-harness-spill');
+export const SPILL_MAX_BYTES = 8 * 1024 * 1024;
+export const SPILL_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const RUN_ID = /^[A-Za-z0-9_-][A-Za-z0-9._-]*$/;
+const HOP = '+';
+const noop = () => { };
+export function runSpill(runId, { root = SPILL_DIR, maxBytes = SPILL_MAX_BYTES } = {}) {
+    const dir = runDir(runId, root);
+    if (dir === null) {
+        return undefined;
+    }
+    return {
+        dir,
+        sink: (stream) => createSink(path.join(dir, `${b4a.toHex(randomBytes(8))}.${stream}.txt`), maxBytes)
+    };
+}
+function createSink(file, maxBytes) {
+    let written = 0;
+    let failed = false;
+    let closed = false;
+    let pending = Promise.resolve();
+    const append = (bytes, first) => async () => {
+        if (failed)
+            return;
+        try {
+            if (first) {
+                await fs.promises.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+            }
+            await fs.promises.appendFile(file, bytes, { mode: 0o600, flag: first ? 'wx' : 'a' });
+        }
+        catch {
+            failed = true;
+        }
+    };
+    return {
+        write(text) {
+            if (closed || written >= maxBytes || !text)
+                return;
+            const bytes = b4a.from(text).subarray(0, maxBytes - written);
+            pending = pending.then(append(bytes, written === 0));
+            written += bytes.byteLength;
+        },
+        async close() {
+            closed = true;
+            await pending;
+            return written > 0 && !failed ? file : null;
+        }
+    };
+}
+function runDir(runId, root) {
+    const segments = runId.split('/');
+    return segments.every((segment) => RUN_ID.test(segment))
+        ? path.join(root, segments.join(HOP))
+        : null;
+}
+export async function removeRun(runId, root = SPILL_DIR) {
+    const dir = runDir(runId, root);
+    if (dir === null) {
+        return;
+    }
+    await fs.promises.rm(dir, { recursive: true, force: true }).catch(noop);
+}
+export function sweepSpill(now = Date.now(), root = SPILL_DIR) {
+    fs.promises.readdir(root).then((names) => {
+        for (const name of names) {
+            const dir = path.join(root, name);
+            fs.promises
+                .stat(dir)
+                .then((stat) => {
+                if (now - stat.mtimeMs > SPILL_MAX_AGE_MS) {
+                    return fs.promises.rm(dir, { recursive: true, force: true });
+                }
+            })
+                .catch(noop);
+        }
+    }, noop);
+}

package/dist-lib/lib/tools/{exec/adapters/python → attachments}/output-policy.d.ts

@@ -1,3 +1,4 @@
+import type { ExecError } from '../../contract/exec.ts';
 export declare const MAX_OUTPUT_FILE_BYTES: number;
 export declare const MAX_OUTPUT_TOTAL_BYTES: number;
 export declare const RUN_OUTPUT_BUDGET_BYTES: number;
@@ -6,9 +7,7 @@ export declare const MAX_INPUTS = 24;
 export declare const MAX_INPUT_TOTAL_BYTES: number;
 export declare function checkFileName(name: string): string | null;
 export declare function checkOutputName(name: string): string | null;
-export interface ExecError {
-    error: string;
-}
+export type { ExecError };
 export interface AcceptedOutput {
     mimeType: string;
 }

package/dist-lib/lib/tools/{exec/adapters/python/attachments.d.ts → attachments/staging.d.ts}

@@ -1,6 +1,6 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-import type { AttachFn, FetchAttachmentFn, RunBudget } from '../../../../capabilities/completion.ts';
-import type { ExecAttachment, RejectedOutput } from '../../runner.ts';
+import type { AttachFn, FetchAttachmentFn, RunBudget } from '../../contract/index.ts';
+import type { ExecAttachment, RejectedOutput } from '../exec/runner.ts';
 import { type ExecError } from './output-policy.ts';
 export interface ExecInput {
     readonly attachmentId?: string;

package/dist-lib/lib/tools/{exec/adapters/python/attachments.js → attachments/staging.js}

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
-import { errorMessage } from '../../../../guards.js';
-import { hlog } from '../../../../log.js';
+import { errorMessage } from '../../guards.js';
+import { hlog } from '../../log.js';
 import { checkOutputBytes, MAX_INPUT_TOTAL_BYTES, RUN_OUTPUT_BUDGET_BYTES } from './output-policy.js';
 const STAGE_TIMEOUT_MS = 60_000;
 const STAGE_TIMEOUT_MESSAGE = `staging attachments timed out after ${STAGE_TIMEOUT_MS}ms`;
@@ -90,7 +90,7 @@ export async function stageInputs(fetchAttachment, inputs, opts = {}) {
             }
             total += probe.size;
             if (total > MAX_INPUT_TOTAL_BYTES) {
-                hlog('python: input attachments over budget; skipping blob download', {
+                hlog('input attachments over budget; skipping blob download', {
                     total,
                     cap: MAX_INPUT_TOTAL_BYTES,
                     count: inputs.length

package/dist-lib/lib/tools/catalog.d.ts

@@ -1,4 +1,4 @@
-import { type ToolDefinition } from '../capabilities/completion.ts';
+import type { ToolDefinition } from '../contract/index.ts';
 import type { Toolset } from './toolsets.ts';
 export interface ToolCatalogEntry {
     name: string;

package/dist-lib/lib/tools/catalog.js

@@ -1,4 +1,4 @@
-import { toSdkTool } from '../capabilities/completion.js';
+import { toSdkTool } from '../capabilities/sdk-tool.js';
 export function toolCatalog(tools) {
     return tools.map((tool) => ({
         name: tool.name,

package/dist-lib/lib/tools/create-documents.d.ts

@@ -1,3 +1,3 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
+import type { ToolDefinition } from '../contract/index.ts';
 import { type FsToolOptions } from './fs/scope.ts';
 export declare function createCreateDocumentsTool({ realpath, deniedRoots }?: FsToolOptions): ToolDefinition;

package/dist-lib/lib/tools/edit-documents.d.ts

@@ -1,3 +1,3 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
+import type { ToolDefinition } from '../contract/index.ts';
 import { type FsToolOptions } from './fs/scope.ts';
 export declare function createEditDocumentsTool({ realpath, deniedRoots }?: FsToolOptions): ToolDefinition;

package/dist-lib/lib/tools/exec/adapters/shell/shell-adapter.d.ts

@@ -1,12 +1,10 @@
-import { type KillProcess, type SpawnFn } from '../../runner.ts';
-import type { FallbackExecutionAdapter } from '../adapter.ts';
-export interface ShellRuntime {
-    readonly spawn: SpawnFn;
-    readonly killProcess?: KillProcess;
-}
+import type { ExecShell, KillProcess, ShellRuntime, SpawnFn } from '../../../../contract/exec.ts';
+export type { ShellRuntime } from '../../../../contract/exec.ts';
 export interface ShellAdapterOptions {
+    readonly name?: string;
     readonly spawn?: SpawnFn;
     readonly killProcess?: KillProcess;
     readonly loadRuntime: () => Promise<ShellRuntime>;
+    readonly downloadNote: string;
 }
-export declare function createShellAdapter(options: ShellAdapterOptions): FallbackExecutionAdapter;
+export declare function createShellAdapter(options: ShellAdapterOptions): ExecShell;

package/dist-lib/lib/tools/exec/adapters/shell/shell-adapter.js

@@ -1,7 +1,8 @@
 import { runCommand } from '../../runner.js';
-import { shellDownloadNote } from '../../shell-guidance.js';
+import { savesDownload } from '../../shell-guidance.js';
 export function createShellAdapter(options) {
     return {
+        name: options.name ?? 'host',
         resolve(args) {
             const command = String(args.command ?? '').trim();
             return {
@@ -14,7 +15,7 @@ export function createShellAdapter(options) {
                         spawn: runtime.spawn,
                         killProcess: runtime.killProcess
                     });
-                    const note = result.exitCode === 0 ? shellDownloadNote(command) : null;
+                    const note = result.exitCode === 0 && savesDownload(command) ? options.downloadNote : null;
                     if (!note) {
                         return result;
                     }

package/dist-lib/lib/tools/exec/bare-runtime.js

@@ -1,9 +1,7 @@
+import process from 'process';
 import { spawnEnv } from '../../helpers/spawn-path.js';
 export async function bareRuntime() {
-    const [{ spawn }, { default: process }] = await Promise.all([
-        import('bare-subprocess'),
-        import('bare-process')
-    ]);
+    const { spawn } = await import('child_process');
     const rawSpawn = spawn;
     const spawnFn = (command, opts = {}) => rawSpawn(command, { ...opts, env: spawnEnv(process.env, process.platform, opts.env) });
     return { spawn: spawnFn, killProcess: process.kill.bind(process) };

package/dist-lib/lib/tools/exec/python-source.d.ts

@@ -0,0 +1,6 @@
+export declare function isPythonLanguage(language: unknown): boolean;
+export declare function unwrapPythonSource(command: string): string | null;
+export declare function withoutProgramDir(command: string): string;
+export declare function pipInstallTargets(command: string): string[] | null;
+export declare function startsLikePython(command: string): boolean;
+export declare function isPythonSourceShaped(command: string): boolean;