@falkenslab/agent-kit 0.18.0 → 0.20.0

package/dist/core/marketplaces.d.ts

@@ -0,0 +1,118 @@
+/** Where a marketplace's plugin comes from, as `marketplace.json` says (Claude Code's forms). */
+export type PluginSource = string | {
+    source: "github";
+    repo: string;
+    ref?: string;
+    sha?: string;
+} | {
+    source: "url";
+    url: string;
+    ref?: string;
+    sha?: string;
+} | {
+    source: "git-subdir";
+    url: string;
+    path: string;
+    ref?: string;
+    sha?: string;
+} | {
+    source: string;
+    [field: string]: unknown;
+};
+/** A plugin a marketplace offers. */
+export interface MarketplacePlugin {
+    name: string;
+    source: PluginSource;
+    description?: string;
+    version?: string;
+    category?: string;
+    tags?: string[];
+    keywords?: string[];
+}
+/** A marketplace's `marketplace.json`, as the kit reads it. */
+export interface MarketplaceManifest {
+    name: string;
+    owner: {
+        name: string;
+        email?: string;
+        url?: string;
+    };
+    description?: string;
+    /** Where bare plugin sources resolve, relative to the marketplace's root. */
+    pluginRoot?: string;
+    plugins: MarketplacePlugin[];
+}
+/** A marketplace an agent knows. */
+export interface KnownMarketplace {
+    name: string;
+    /** Where it came from: a folder, a git URL (`#ref`), or `owner/repo`. */
+    source: string;
+    /** The commit its copy was taken at, for a git one. */
+    commit?: string;
+    /** The agent's own: known without asking, and its plugins installed without a confirmation. */
+    official: boolean;
+    /** When its copy was taken, ISO 8601 in UTC. */
+    updated: string;
+    /** Its copy, inside the agent's extensions folder. */
+    dir: string;
+    manifest?: MarketplaceManifest;
+}
+/** Reads and checks a marketplace's `.claude-plugin/marketplace.json`. */
+export declare function readMarketplaceManifest(root: string): Promise<MarketplaceManifest>;
+/** Reads a marketplace from a folder, a git URL (`#ref`) or `owner/repo` without adding it: what to show before asking. */
+export declare function inspectMarketplace(source: string): Promise<MarketplaceManifest>;
+/**
+ * Adds a marketplace to the agent (its extensions folder, `dir`) from a folder, a git URL
+ * (`#ref`) or `owner/repo`, taking a copy; one with the same name is replaced. Asking the person
+ * first is the caller's: the kit's command asks them to type its name, unless it's `official`.
+ */
+export declare function addMarketplace(source: string, dir: string, options?: {
+    official?: boolean;
+}): Promise<{
+    name: string;
+    replaced: boolean;
+    manifest: MarketplaceManifest;
+    commit?: string;
+}>;
+/** The marketplaces the agent knows, with their manifests when they can be read. */
+export declare function listMarketplaces(dir: string): Promise<KnownMarketplace[]>;
+/** Takes a fresh copy of a known marketplace from where it came from. */
+export declare function updateMarketplace(dir: string, name: string): Promise<{
+    commit?: string;
+}>;
+/** Forgets a marketplace (its copy and its entry); the extensions installed from it stay. False when it wasn't known. */
+export declare function removeMarketplace(dir: string, name: string): Promise<boolean>;
+/** A plugin found in the known marketplaces: `<name>@<marketplace>`, or a name only one of them offers. */
+export declare function findPlugin(dir: string, spec: string): Promise<{
+    marketplace: KnownMarketplace;
+    plugin: MarketplacePlugin;
+}>;
+/** Where a plugin comes from: a folder or git repository for `addExtension()`, or a download (npm, archive). */
+export type ResolvedSource = {
+    source: string;
+    subdir?: string;
+    sha?: string;
+} | {
+    npm: {
+        name: string;
+        version?: string;
+        registry?: string;
+    };
+} | {
+    archive: {
+        url: string;
+        sha256?: string;
+    };
+};
+/** Where a plugin's source points: a folder of the marketplace's copy, a git repository, an npm package or a zip. */
+export declare function resolvePluginSource(marketplace: KnownMarketplace, plugin: MarketplacePlugin): ResolvedSource;
+/**
+ * Installs `<plugin>@<marketplace>` (or a plugin only one known marketplace offers) into a scope,
+ * locked with where it came from. Its name in the agent is its `plugin.json`'s, as for any extension.
+ */
+export declare function installFromMarketplace(dir: string, spec: string, scopeDir: string): Promise<{
+    name: string;
+    replaced: boolean;
+    commit?: string;
+    marketplace: string;
+}>;

package/dist/core/marketplaces.js

@@ -0,0 +1,242 @@
+import { execFile } from "node:child_process";
+import { cp, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { addExtension, isGitSource } from "./externalExtensions.js";
+import { fetchArchivePlugin, fetchNpmPlugin } from "./pluginDownloads.js";
+/**
+ * Marketplaces (ADR-025, #29): a repository of extensions is a Claude Code marketplace as it is,
+ * a folder or git repository with `.claude-plugin/marketplace.json` listing plugins and where
+ * each comes from. An agent knows the marketplaces added to it, kept in its extensions folder
+ * (`marketplaces.json`, and a copy of each in `.marketplaces/<name>/`), and installs from them
+ * by `<plugin>@<marketplace>` into either scope, through `addExtension()`: the same copy, hash and
+ * lock as any extension. Its official marketplace is known without asking; any other is added
+ * only by hand, after a warning (the command asks to type its name).
+ */
+const exec = promisify(execFile);
+const REGISTRY = "marketplaces.json";
+const COPIES = ".marketplaces";
+const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+/** Reads and checks a marketplace's `.claude-plugin/marketplace.json`. */
+export async function readMarketplaceManifest(root) {
+    const file = path.join(root, ".claude-plugin", "marketplace.json");
+    const raw = JSON.parse(await readFile(file, "utf8").catch(() => {
+        throw new Error(`${root} isn't a marketplace: it has no .claude-plugin/marketplace.json.`);
+    }));
+    const name = raw.name;
+    if (typeof name !== "string" || !NAME.test(name) || name.includes(".."))
+        throw new Error(`${file}: "name" must be letters, digits, ".", "_" or "-".`);
+    const owner = raw.owner;
+    if (!owner || typeof owner.name !== "string")
+        throw new Error(`${file}: "owner" needs a "name".`);
+    if (!Array.isArray(raw.plugins))
+        throw new Error(`${file}: "plugins" must be a list.`);
+    const metadata = (raw.metadata ?? {});
+    const plugins = raw.plugins.map((plugin, index) => {
+        if (typeof plugin?.name !== "string" || !NAME.test(plugin.name))
+            throw new Error(`${file}: plugin ${index + 1} has no valid "name".`);
+        if (plugin.source === undefined)
+            throw new Error(`${file}: ${plugin.name} has no "source".`);
+        return plugin;
+    });
+    const description = raw.description ?? metadata.description;
+    return { name, owner, ...(description ? { description } : {}), ...(metadata.pluginRoot ? { pluginRoot: metadata.pluginRoot } : {}), plugins };
+}
+async function readRegistry(dir) {
+    try {
+        return JSON.parse(await readFile(path.join(dir, REGISTRY), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+}
+async function writeRegistry(dir, registry) {
+    await mkdir(dir, { recursive: true });
+    const sorted = Object.fromEntries(Object.keys(registry).sort().map((name) => [name, registry[name]]));
+    await writeFile(path.join(dir, REGISTRY), `${JSON.stringify(sorted, null, 2)}\n`, "utf8");
+}
+/** A git URL for a marketplace or plugin source: `owner/repo` is GitHub's. */
+function gitUrl(source) {
+    return /^[\w.-]+\/[\w.-]+$/.test(source) ? `https://github.com/${source}.git` : source.replace(/^github:/, "https://github.com/");
+}
+/** Whether a marketplace source is a git repository rather than a folder (`owner/repo` included, unless such a folder exists). */
+async function isGitMarketplace(source) {
+    const [location] = source.split("#");
+    if (isGitSource(location))
+        return true;
+    if (!/^[\w.-]+\/[\w.-]+$/.test(location))
+        return false;
+    return !(await stat(path.resolve(location)).then((found) => found.isDirectory(), () => false));
+}
+/** Takes a copy of a marketplace (a folder, or a git clone at its ref) into a temporary folder. */
+async function fetchMarketplace(source) {
+    const copy = await mkdtemp(path.join(os.tmpdir(), "agent-kit-marketplace-"));
+    try {
+        if (await isGitMarketplace(source)) {
+            const [location, ref] = source.split("#");
+            await exec("git", ["clone", "--depth", "1", ...(ref ? ["--branch", ref] : []), gitUrl(location), copy]);
+            const commit = (await exec("git", ["-C", copy, "rev-parse", "HEAD"])).stdout.trim();
+            await rm(path.join(copy, ".git"), { recursive: true, force: true });
+            return { copy, commit };
+        }
+        await cp(path.resolve(source), copy, { recursive: true, filter: (file) => path.basename(file) !== ".git" });
+        return { copy };
+    }
+    catch (error) {
+        await rm(copy, { recursive: true, force: true });
+        throw error;
+    }
+}
+/** Reads a marketplace from a folder, a git URL (`#ref`) or `owner/repo` without adding it: what to show before asking. */
+export async function inspectMarketplace(source) {
+    const { copy } = await fetchMarketplace((await isGitMarketplace(source)) ? source : path.resolve(source));
+    try {
+        return await readMarketplaceManifest(copy);
+    }
+    finally {
+        await rm(copy, { recursive: true, force: true });
+    }
+}
+/**
+ * Adds a marketplace to the agent (its extensions folder, `dir`) from a folder, a git URL
+ * (`#ref`) or `owner/repo`, taking a copy; one with the same name is replaced. Asking the person
+ * first is the caller's: the kit's command asks them to type its name, unless it's `official`.
+ */
+export async function addMarketplace(source, dir, options = {}) {
+    const location = (await isGitMarketplace(source)) ? source : path.resolve(source);
+    const { copy, commit } = await fetchMarketplace(location);
+    try {
+        const manifest = await readMarketplaceManifest(copy);
+        const registry = await readRegistry(dir);
+        const replaced = Boolean(registry[manifest.name]);
+        const target = path.join(dir, COPIES, manifest.name);
+        await rm(target, { recursive: true, force: true });
+        await mkdir(path.dirname(target), { recursive: true });
+        await cp(copy, target, { recursive: true });
+        registry[manifest.name] = { source: location, ...(commit ? { commit } : {}), official: Boolean(options.official || registry[manifest.name]?.official), updated: new Date().toISOString() };
+        await writeRegistry(dir, registry);
+        return { name: manifest.name, replaced, manifest, ...(commit ? { commit } : {}) };
+    }
+    finally {
+        await rm(copy, { recursive: true, force: true });
+    }
+}
+/** The marketplaces the agent knows, with their manifests when they can be read. */
+export async function listMarketplaces(dir) {
+    const registry = await readRegistry(dir);
+    return Promise.all(Object.entries(registry).map(async ([name, entry]) => {
+        const copy = path.join(dir, COPIES, name);
+        const manifest = await readMarketplaceManifest(copy).catch(() => undefined);
+        return { name, ...entry, dir: copy, ...(manifest ? { manifest } : {}) };
+    }));
+}
+/** Takes a fresh copy of a known marketplace from where it came from. */
+export async function updateMarketplace(dir, name) {
+    const known = (await readRegistry(dir))[name];
+    if (!known)
+        throw new Error(`No marketplace ${name}.`);
+    const result = await addMarketplace(known.source, dir, { official: known.official });
+    if (result.name !== name)
+        throw new Error(`${known.source} is now the marketplace ${result.name}, not ${name}.`);
+    return result.commit ? { commit: result.commit } : {};
+}
+/** Forgets a marketplace (its copy and its entry); the extensions installed from it stay. False when it wasn't known. */
+export async function removeMarketplace(dir, name) {
+    const registry = await readRegistry(dir);
+    if (!registry[name])
+        return false;
+    delete registry[name];
+    await rm(path.join(dir, COPIES, name), { recursive: true, force: true });
+    await writeRegistry(dir, registry);
+    return true;
+}
+/** A plugin found in the known marketplaces: `<name>@<marketplace>`, or a name only one of them offers. */
+export async function findPlugin(dir, spec) {
+    const [name, wanted] = spec.split("@");
+    const marketplaces = (await listMarketplaces(dir)).filter((marketplace) => !wanted || marketplace.name === wanted);
+    if (wanted && !marketplaces.length)
+        throw new Error(`No marketplace ${wanted}.`);
+    const found = marketplaces.flatMap((marketplace) => (marketplace.manifest?.plugins ?? []).filter((plugin) => plugin.name === name).map((plugin) => ({ marketplace, plugin })));
+    if (!found.length)
+        throw new Error(`No marketplace offers ${name}${wanted ? ` (${wanted} doesn't)` : ""}.`);
+    if (found.length > 1)
+        throw new Error(`${name} is in several marketplaces (${found.map(({ marketplace }) => marketplace.name).join(", ")}): say which, ${name}@<marketplace>.`);
+    return found[0];
+}
+/** Where a plugin's source points: a folder of the marketplace's copy, a git repository, an npm package or a zip. */
+export function resolvePluginSource(marketplace, plugin) {
+    const { source } = plugin;
+    if (typeof source === "string") {
+        // From the marketplace's root: `./plugins/x`, or a bare name under `pluginRoot`; never "..", as Claude Code.
+        if (source.split(/[\\/]/).includes(".."))
+            throw new Error(`${plugin.name}'s source leaves its marketplace: ${source}.`);
+        const relative = source.startsWith("./") || source === "." ? source : path.join(marketplace.manifest?.pluginRoot ?? ".", source);
+        const root = path.resolve(marketplace.dir);
+        const folder = path.resolve(root, relative);
+        if (folder !== root && !folder.startsWith(`${root}${path.sep}`))
+            throw new Error(`${plugin.name}'s source leaves its marketplace: ${source}.`);
+        return { source: folder };
+    }
+    // Its fields, as written: the union above only names the forms the kit knows.
+    const entry = source;
+    const ref = typeof entry.ref === "string" ? `#${entry.ref}` : "";
+    const sha = typeof entry.sha === "string" ? { sha: entry.sha } : {};
+    switch (source.source) {
+        case "github":
+            return { source: `https://github.com/${String(entry.repo)}.git${ref}`, ...sha };
+        case "url":
+            return { source: `${String(entry.url)}${ref}`, ...sha };
+        case "git-subdir":
+            return { source: `${gitUrl(String(entry.url))}${ref}`, subdir: String(entry.path), ...sha };
+        case "npm": {
+            // "package" may carry its version ("@scope/name@^2.0.0"); "version" wins.
+            const spec = String(entry.package);
+            const at = spec.lastIndexOf("@");
+            const [name, inline] = at > 0 ? [spec.slice(0, at), spec.slice(at + 1)] : [spec, undefined];
+            const version = typeof entry.version === "string" ? entry.version : inline;
+            return { npm: { name, ...(version ? { version } : {}), ...(typeof entry.registry === "string" ? { registry: entry.registry } : {}) } };
+        }
+        case "archive":
+            return { archive: { url: String(entry.url), ...(typeof entry.sha256 === "string" ? { sha256: entry.sha256 } : {}) } };
+        default:
+            // command runs a program of the marketplace's on this machine: never.
+            throw new Error(`${plugin.name} comes from a "${source.source}" source, which agent-kit doesn't install: only folders of the marketplace, github, url, git-subdir, npm and archive.`);
+    }
+}
+/**
+ * Installs `<plugin>@<marketplace>` (or a plugin only one known marketplace offers) into a scope,
+ * locked with where it came from. Its name in the agent is its `plugin.json`'s, as for any extension.
+ */
+export async function installFromMarketplace(dir, spec, scopeDir) {
+    const { marketplace, plugin } = await findPlugin(dir, spec);
+    const resolved = resolvePluginSource(marketplace, plugin);
+    const from = `${plugin.name}@${marketplace.name}`;
+    if ("npm" in resolved) {
+        const { name, version, registry } = resolved.npm;
+        const fetched = await fetchNpmPlugin(name, version, registry);
+        try {
+            return { ...(await addExtension(fetched.dir, scopeDir, { marketplace: from, origin: `npm:${name}@${fetched.version}` })), marketplace: marketplace.name };
+        }
+        finally {
+            await rm(fetched.dir, { recursive: true, force: true });
+        }
+    }
+    if ("archive" in resolved) {
+        const fetched = await fetchArchivePlugin(resolved.archive.url, resolved.archive.sha256);
+        try {
+            return { ...(await addExtension(fetched.root, scopeDir, { marketplace: from, origin: resolved.archive.url })), marketplace: marketplace.name };
+        }
+        finally {
+            await rm(fetched.dir, { recursive: true, force: true });
+        }
+    }
+    const result = await addExtension(resolved.source, scopeDir, {
+        ...(resolved.subdir ? { subdir: resolved.subdir } : {}),
+        ...(resolved.sha ? { sha: resolved.sha } : {}),
+        marketplace: from,
+    });
+    return { ...result, marketplace: marketplace.name };
+}

package/dist/core/messages/de.js

@@ -22,6 +22,18 @@ export const de = {
     resumeHint: "↑/↓ wählen · Enter fortsetzen · Esc abbrechen",
     resumeQuestion: "Nummer des Gesprächs, das fortgesetzt werden soll (Enter zum Abbrechen): ",
     noEarlierRuns: "(keine früheren Gespräche zum Fortsetzen)",
+    commandResume: "Ein früheres Gespräch wählen und fortsetzen",
+    commandPlan: "In den Planmodus und zurück",
+    commandExtensions: "Was läuft, was aus ist und warum; eine ein- oder ausschalten",
+    extensionsRunning: (names) => `Aktiv: ${names}`,
+    extensionsNone: "(keine Erweiterungen)",
+    extensionOff: (name, reason) => `${name} ist aus: ${reason}`,
+    extensionsInstalled: "Installiert:",
+    extensionSwitched: (name, enabled) => `(${name} ${enabled ? "aktiviert" : "deaktiviert"}, in derselben Sitzung)`,
+    extensionToggled: (name, enabled) => `(${name} ${enabled ? "aktiviert" : "deaktiviert"}: die Sitzung wird mit derselben Unterhaltung neu geöffnet)`,
+    extensionNotInstalled: (name) => `(${name} ist nicht installiert: /extensions listet sie auf)`,
+    extensionsUsage: "(Verwendung: /extensions, /extensions enable <Name>, /extensions disable <Name>)",
+    extensionsCantReopen: "(dieser Chat kann seine Sitzung nicht neu öffnen: im Terminal aktivieren oder deaktivieren und neu starten)",
     currentRun: "(dieses)",
     resumed: (date) => `(Gespräch vom ${date} fortgesetzt)`,
     suggestionKey: "Tab",
@@ -91,22 +103,6 @@ export const de = {
         Task: ["hat {n} Subagenten gestartet", "hat {n} Subagenten gestartet"],
         mcp__time__current_time: ["Uhrzeit abgefragt", "Uhrzeit {n}-mal abgefragt"],
         mcp__time__date_math: ["Daten berechnet", "Daten {n}-mal berechnet"],
-        mcp__sourceFiles__list_sources: ["Quellen geprüft", "Quellen {n}-mal geprüft"],
-        mcp__sourceFiles__extract_text: ["{n} Dokument gelesen", "{n} Dokumente gelesen"],
-        mcp__sourceFiles__save_to_sources: ["{n} Quelle gespeichert", "{n} Quellen gespeichert"],
-        mcp__sourceFiles__download_to_sources: ["{n} Quelle heruntergeladen", "{n} Quellen heruntergeladen"],
-        mcp__sourceFiles__request_file: ["um {n} Datei gebeten", "um {n} Dateien gebeten"],
-        mcp__sourceFiles__retire_source: ["{n} Quelle zurückgezogen", "{n} Quellen zurückgezogen"],
-        mcp__knowledge__knowledge_index: ["Index gelesen", "Index {n}-mal gelesen"],
-        mcp__knowledge__knowledge_search: ["Wissensbasis durchsucht", "Wissensbasis {n}-mal durchsucht"],
-        mcp__knowledge__knowledge_read: ["{n} Seite gelesen", "{n} Seiten gelesen"],
-        mcp__knowledge__knowledge_create: ["{n} Seite angelegt", "{n} Seiten angelegt"],
-        mcp__knowledge__knowledge_edit: ["{n} Seite bearbeitet", "{n} Seiten bearbeitet"],
-        mcp__knowledge__knowledge_rewrite: ["{n} Seite neu geschrieben", "{n} Seiten neu geschrieben"],
-        mcp__knowledge__knowledge_supersede: ["{n} Seite ersetzt", "{n} Seiten ersetzt"],
-        mcp__knowledge__knowledge_retire: ["{n} Seite zurückgezogen", "{n} Seiten zurückgezogen"],
-        mcp__knowledge__knowledge_log: ["Protokoll aktualisiert", "Protokoll {n}-mal aktualisiert"],
-        mcp__knowledge__knowledge_check: ["Wissensbasis geprüft", "Wissensbasis {n}-mal geprüft"],
         mcp__approvals__ask_human: ["{n} Frage gestellt", "{n} Fragen gestellt"],
         mcp__approvals__present_plan: ["Plan vorgelegt", "Plan {n}-mal vorgelegt"],
     },
@@ -120,7 +116,6 @@ export const de = {
     labels: {
         askingApproval: (summary) => `Bittet um menschliche Genehmigung: ${summary}`,
         waitingManual: "Wartet auf einen manuellen Eingriff",
-        savingToSources: (destination) => `Speichert ${destination} in den Quellen`,
         checkingTime: "Datum und Uhrzeit abfragen",
         calculatingDates: "Daten berechnen",
         reading: (file) => `Liest ${file}`,
@@ -139,21 +134,6 @@ export const de = {
         applyingSkill: (skill) => `Wendet den Skill "${skill}" an`,
         aSkill: "einen Skill",
         updatingTasks: "Aufgabenliste aktualisieren",
-        listingSources: "Quellen prüfen",
-        extractingText: (source) => `${source} lesen`,
-        downloading: (url) => `${url} in die Quellen herunterladen`,
-        requestingFile: (description) => `Um eine Datei bitten: ${description}`,
-        retiringSource: (source) => `Quelle ${source} zurückziehen`,
-        knowledgeIndex: "Index der Wissensbasis lesen",
-        knowledgeSearch: (query) => `Wissensbasis nach "${query}" durchsuchen`,
-        knowledgeRead: (page) => `${page} lesen`,
-        knowledgeCreate: (page) => `${page} anlegen`,
-        knowledgeEdit: (page) => `${page} bearbeiten`,
-        knowledgeRewrite: (page) => `${page} neu schreiben`,
-        knowledgeSupersede: (page) => `${page} als ersetzt markieren`,
-        knowledgeRetire: (page) => `${page} zurückziehen`,
-        knowledgeLog: "Protokoll der Wissensbasis aktualisieren",
-        knowledgeCheck: "Wissensbasis prüfen",
         askingHuman: (question) => `Frage: ${question}`,
         presentingPlan: "Plan vorlegen",
     },

package/dist/core/messages/en.d.ts

@@ -29,6 +29,21 @@ export interface Messages {
     resumeHint: string;
     resumeQuestion: string;
     noEarlierRuns: string;
+    /** What the chat's own commands do, for a view that lists them. */
+    commandResume: string;
+    commandPlan: string;
+    commandExtensions: string;
+    /** /extensions (#37): what the session runs with, what's off and why, and enabling or disabling one. */
+    extensionsRunning(names: string): string;
+    extensionsNone: string;
+    extensionOff(name: string, reason: string): string;
+    extensionsInstalled: string;
+    /** An installed extension turned off or on in the running session (#49). */
+    extensionSwitched(name: string, enabled: boolean): string;
+    extensionToggled(name: string, enabled: boolean): string;
+    extensionNotInstalled(name: string): string;
+    extensionsUsage: string;
+    extensionsCantReopen: string;
     currentRun: string;
     resumed(date: string): string;
     suggestionKey: string;
@@ -82,7 +97,6 @@ export interface Messages {
     labels: {
         askingApproval(summary: string): string;
         waitingManual: string;
-        savingToSources(destination: string): string;
         checkingTime: string;
         calculatingDates: string;
         reading(file: string): string;
@@ -101,21 +115,6 @@ export interface Messages {
         applyingSkill(skill: string): string;
         aSkill: string;
         updatingTasks: string;
-        listingSources: string;
-        extractingText(source: string): string;
-        downloading(url: string): string;
-        requestingFile(description: string): string;
-        retiringSource(source: string): string;
-        knowledgeIndex: string;
-        knowledgeSearch(query: string): string;
-        knowledgeRead(page: string): string;
-        knowledgeCreate(page: string): string;
-        knowledgeEdit(page: string): string;
-        knowledgeRewrite(page: string): string;
-        knowledgeSupersede(page: string): string;
-        knowledgeRetire(page: string): string;
-        knowledgeLog: string;
-        knowledgeCheck: string;
         askingHuman(question: string): string;
         presentingPlan: string;
     };

package/dist/core/messages/en.js

@@ -21,6 +21,18 @@ export const en = {
     resumeHint: "↑/↓ choose · Enter resume · Esc cancel",
     resumeQuestion: "Number of the conversation to resume (Enter to cancel): ",
     noEarlierRuns: "(no earlier conversations to resume)",
+    commandResume: "Pick an earlier conversation to go on with",
+    commandPlan: "Into plan mode, or back",
+    commandExtensions: "What runs, what's off and why; turn one on or off",
+    extensionsRunning: (names) => `Running with: ${names}`,
+    extensionsNone: "(no extensions)",
+    extensionOff: (name, reason) => `${name} is off: it ${reason}`,
+    extensionsInstalled: "Installed:",
+    extensionSwitched: (name, enabled) => `(${name} ${enabled ? "enabled" : "disabled"}, in this same session)`,
+    extensionToggled: (name, enabled) => `(${name} ${enabled ? "enabled" : "disabled"}: the session reopens, with the same conversation)`,
+    extensionNotInstalled: (name) => `(${name} isn't installed: /extensions lists them)`,
+    extensionsUsage: "(usage: /extensions, /extensions enable <name>, /extensions disable <name>)",
+    extensionsCantReopen: "(this chat can't reopen its session: enable or disable it from the terminal, and start again)",
     currentRun: "(this one)",
     resumed: (date) => `(resumed the conversation of ${date})`,
     suggestionKey: "tab",
@@ -90,22 +102,6 @@ export const en = {
         Task: ["ran {n} subagent", "ran {n} subagents"],
         mcp__time__current_time: ["checked the time", "checked the time {n} times"],
         mcp__time__date_math: ["calculated dates", "calculated dates {n} times"],
-        mcp__sourceFiles__list_sources: ["listed the sources", "listed the sources {n} times"],
-        mcp__sourceFiles__extract_text: ["read {n} document", "read {n} documents"],
-        mcp__sourceFiles__save_to_sources: ["saved {n} source", "saved {n} sources"],
-        mcp__sourceFiles__download_to_sources: ["downloaded {n} source", "downloaded {n} sources"],
-        mcp__sourceFiles__request_file: ["asked for {n} file", "asked for {n} files"],
-        mcp__sourceFiles__retire_source: ["retired {n} source", "retired {n} sources"],
-        mcp__knowledge__knowledge_index: ["read the index", "read the index {n} times"],
-        mcp__knowledge__knowledge_search: ["searched the knowledge base", "searched the knowledge base {n} times"],
-        mcp__knowledge__knowledge_read: ["read {n} page", "read {n} pages"],
-        mcp__knowledge__knowledge_create: ["created {n} page", "created {n} pages"],
-        mcp__knowledge__knowledge_edit: ["edited {n} page", "edited {n} pages"],
-        mcp__knowledge__knowledge_rewrite: ["rewrote {n} page", "rewrote {n} pages"],
-        mcp__knowledge__knowledge_supersede: ["superseded {n} page", "superseded {n} pages"],
-        mcp__knowledge__knowledge_retire: ["retired {n} page", "retired {n} pages"],
-        mcp__knowledge__knowledge_log: ["updated the log", "updated the log {n} times"],
-        mcp__knowledge__knowledge_check: ["checked the knowledge base", "checked the knowledge base {n} times"],
         mcp__approvals__ask_human: ["asked {n} question", "asked {n} questions"],
         mcp__approvals__present_plan: ["presented the plan", "presented the plan {n} times"],
     },
@@ -119,7 +115,6 @@ export const en = {
     labels: {
         askingApproval: (summary) => `Asking for human approval: ${summary}`,
         waitingManual: "Waiting for a human to intervene manually",
-        savingToSources: (destination) => `Saving ${destination} to the sources`,
         checkingTime: "Checking the date and time",
         calculatingDates: "Calculating dates",
         reading: (file) => `Reading ${file}`,
@@ -138,21 +133,6 @@ export const en = {
         applyingSkill: (skill) => `Applying the "${skill}" skill`,
         aSkill: "a skill",
         updatingTasks: "Updating the task list",
-        listingSources: "Listing the sources",
-        extractingText: (source) => `Reading ${source}`,
-        downloading: (url) => `Downloading ${url} to the sources`,
-        requestingFile: (description) => `Asking for a file: ${description}`,
-        retiringSource: (source) => `Retiring the source ${source}`,
-        knowledgeIndex: "Reading the knowledge base's index",
-        knowledgeSearch: (query) => `Searching the knowledge base for "${query}"`,
-        knowledgeRead: (page) => `Reading ${page}`,
-        knowledgeCreate: (page) => `Creating ${page}`,
-        knowledgeEdit: (page) => `Editing ${page}`,
-        knowledgeRewrite: (page) => `Rewriting ${page}`,
-        knowledgeSupersede: (page) => `Marking ${page} superseded`,
-        knowledgeRetire: (page) => `Retiring ${page}`,
-        knowledgeLog: "Updating the knowledge base's log",
-        knowledgeCheck: "Checking the knowledge base",
         askingHuman: (question) => `Asking: ${question}`,
         presentingPlan: "Presenting the plan",
     },

package/dist/core/messages/es.js

@@ -22,6 +22,18 @@ export const es = {
     resumeHint: "↑/↓ elegir · Intro retomar · Esc cancelar",
     resumeQuestion: "Número de la conversación que retomar (Intro para cancelar): ",
     noEarlierRuns: "(no hay conversaciones anteriores que retomar)",
+    commandResume: "Elegir una conversación anterior para seguir con ella",
+    commandPlan: "Entrar en el modo plan, o volver",
+    commandExtensions: "Qué funciona, qué no y por qué; activar o desactivar una",
+    extensionsRunning: (names) => `Funcionando con: ${names}`,
+    extensionsNone: "(ninguna extensión)",
+    extensionOff: (name, reason) => `${name} está desactivada: ${reason}`,
+    extensionsInstalled: "Instaladas:",
+    extensionSwitched: (name, enabled) => `(${name} ${enabled ? "activada" : "desactivada"}, en esta misma sesión)`,
+    extensionToggled: (name, enabled) => `(${name} ${enabled ? "activada" : "desactivada"}: la sesión se reabre, con la misma conversación)`,
+    extensionNotInstalled: (name) => `(${name} no está instalada: /extensions las lista)`,
+    extensionsUsage: "(uso: /extensions, /extensions enable <nombre>, /extensions disable <nombre>)",
+    extensionsCantReopen: "(este chat no puede reabrir su sesión: actívala o desactívala desde la terminal y vuelve a empezar)",
     currentRun: "(esta)",
     resumed: (date) => `(retomada la conversación del ${date})`,
     suggestionKey: "tab",
@@ -91,22 +103,6 @@ export const es = {
         Task: ["lanzó {n} subagente", "lanzó {n} subagentes"],
         mcp__time__current_time: ["consultó la hora", "consultó la hora {n} veces"],
         mcp__time__date_math: ["calculó fechas", "calculó fechas {n} veces"],
-        mcp__sourceFiles__list_sources: ["revisó las fuentes", "revisó las fuentes {n} veces"],
-        mcp__sourceFiles__extract_text: ["leyó {n} documento", "leyó {n} documentos"],
-        mcp__sourceFiles__save_to_sources: ["guardó {n} fuente", "guardó {n} fuentes"],
-        mcp__sourceFiles__download_to_sources: ["descargó {n} fuente", "descargó {n} fuentes"],
-        mcp__sourceFiles__request_file: ["pidió {n} fichero", "pidió {n} ficheros"],
-        mcp__sourceFiles__retire_source: ["retiró {n} fuente", "retiró {n} fuentes"],
-        mcp__knowledge__knowledge_index: ["leyó el índice", "leyó el índice {n} veces"],
-        mcp__knowledge__knowledge_search: ["buscó en la base de conocimiento", "buscó en la base de conocimiento {n} veces"],
-        mcp__knowledge__knowledge_read: ["leyó {n} página", "leyó {n} páginas"],
-        mcp__knowledge__knowledge_create: ["creó {n} página", "creó {n} páginas"],
-        mcp__knowledge__knowledge_edit: ["editó {n} página", "editó {n} páginas"],
-        mcp__knowledge__knowledge_rewrite: ["reescribió {n} página", "reescribió {n} páginas"],
-        mcp__knowledge__knowledge_supersede: ["sustituyó {n} página", "sustituyó {n} páginas"],
-        mcp__knowledge__knowledge_retire: ["retiró {n} página", "retiró {n} páginas"],
-        mcp__knowledge__knowledge_log: ["actualizó el registro", "actualizó el registro {n} veces"],
-        mcp__knowledge__knowledge_check: ["revisó la base de conocimiento", "revisó la base de conocimiento {n} veces"],
         mcp__approvals__ask_human: ["hizo {n} pregunta", "hizo {n} preguntas"],
         mcp__approvals__present_plan: ["presentó el plan", "presentó el plan {n} veces"],
     },
@@ -120,7 +116,6 @@ export const es = {
     labels: {
         askingApproval: (summary) => `Pidiendo aprobación humana: ${summary}`,
         waitingManual: "Esperando a que una persona intervenga a mano",
-        savingToSources: (destination) => `Guardando ${destination} en las fuentes`,
         checkingTime: "Consultando la fecha y la hora",
         calculatingDates: "Calculando fechas",
         reading: (file) => `Leyendo ${file}`,
@@ -139,21 +134,6 @@ export const es = {
         applyingSkill: (skill) => `Aplicando la skill "${skill}"`,
         aSkill: "una skill",
         updatingTasks: "Actualizando la lista de tareas",
-        listingSources: "Revisando las fuentes",
-        extractingText: (source) => `Leyendo ${source}`,
-        downloading: (url) => `Descargando ${url} a las fuentes`,
-        requestingFile: (description) => `Pidiendo un fichero: ${description}`,
-        retiringSource: (source) => `Retirando la fuente ${source}`,
-        knowledgeIndex: "Leyendo el índice de la base de conocimiento",
-        knowledgeSearch: (query) => `Buscando "${query}" en la base de conocimiento`,
-        knowledgeRead: (page) => `Leyendo ${page}`,
-        knowledgeCreate: (page) => `Creando ${page}`,
-        knowledgeEdit: (page) => `Editando ${page}`,
-        knowledgeRewrite: (page) => `Reescribiendo ${page}`,
-        knowledgeSupersede: (page) => `Marcando ${page} como sustituida`,
-        knowledgeRetire: (page) => `Retirando ${page}`,
-        knowledgeLog: "Actualizando el registro de la base de conocimiento",
-        knowledgeCheck: "Revisando la base de conocimiento",
         askingHuman: (question) => `Preguntando: ${question}`,
         presentingPlan: "Presentando el plan",
     },