@fabriccode/weave 0.7.0

package/dist/managers/background-manager.d.ts

@@ -0,0 +1,88 @@
+/** Possible lifecycle states for a background task */
+export type TaskStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+/** Options for spawning a background task */
+export interface SpawnOptions {
+    agentName: string;
+    prompt: string;
+    category?: string;
+    skills?: string[];
+    concurrencyKey?: string;
+}
+/** A record representing a background task and its lifecycle */
+export interface TaskRecord {
+    id: string;
+    status: TaskStatus;
+    options: SpawnOptions;
+    result?: unknown;
+    error?: string;
+    startedAt?: Date;
+    completedAt?: Date;
+}
+/**
+ * In-memory background task manager for the Weave Fabric plugin.
+ *
+ * v1 tracks tasks in memory only — no real session spawning, polling, or
+ * tmux integration.  Real concurrency control and SDK integration are
+ * deferred to a future release.
+ *
+ * ## Planned Delegation Tracking Integration
+ *
+ * Once a UI consumer exists (e.g. a `/status` slash command), this class
+ * should be wired into `plugin-interface.ts` as follows:
+ *
+ * 1. **`tool.execute.before`** — when `input.tool === "task"`, call
+ *    `backgroundManager.spawn({ agentName: args.agent, prompt: args.description })`
+ *    and store the returned task ID keyed by `input.callID`.
+ *
+ * 2. **`tool.execute.after`** — look up the task ID by `input.callID` and
+ *    transition its status:
+ *    - On success: set `status = "completed"` and `completedAt = new Date()`
+ *    - On error: set `status = "failed"` and `error = err.message`
+ *
+ * 3. **`/status` command** — call `list({ status: "running" })` to surface
+ *    all in-flight delegations to the user in real time.
+ *
+ * This is deferred until there is an Fabric API to read task status back
+ * out of the plugin (e.g. a query hook or TUI panel).
+ */
+export declare class BackgroundManager {
+    private readonly tasks;
+    readonly maxConcurrent: number;
+    constructor(options?: {
+        maxConcurrent?: number;
+    });
+    /**
+     * Creates a new task record with status "pending", stores it, and returns
+     * the generated task ID.
+     */
+    spawn(options: SpawnOptions): string;
+    /**
+     * Returns the task record for the given ID, or `undefined` if not found.
+     */
+    getTask(taskId: string): TaskRecord | undefined;
+    /**
+     * Attempts to cancel the task with the given ID.
+     *
+     * - Returns `true` if the task was found and successfully cancelled.
+     * - Returns `false` if the task does not exist or is already in a terminal
+     *   state ("completed", "failed", "cancelled").
+     */
+    cancel(taskId: string): boolean;
+    /**
+     * Cancels all tasks that are not yet in a terminal state.
+     */
+    cancelAll(): void;
+    /**
+     * Returns all tasks, optionally filtered by status.
+     *
+     * @param filter - If `filter.status` is provided, only tasks with that
+     *   status are returned.  If no filter is given, all tasks are returned.
+     */
+    list(filter?: {
+        status?: TaskStatus;
+    }): TaskRecord[];
+    /**
+     * Returns the number of tasks currently in the "running" state.
+     */
+    getRunningCount(): number;
+}

package/dist/managers/config-handler.d.ts

@@ -0,0 +1,54 @@
+import type { AgentConfig } from "@fabriccode/sdk";
+import type { WeaveConfig } from "../config/schema";
+/** Input to the config pipeline */
+export interface ConfigPipelineInput {
+    pluginConfig: WeaveConfig;
+    /** Available agents from createBuiltinAgents (or empty for testing) */
+    agents?: Record<string, AgentConfig>;
+    /** Available tool names */
+    availableTools?: string[];
+}
+/** Output from config pipeline */
+export interface ConfigPipelineOutput {
+    agents: Record<string, AgentConfig>;
+    /** Default agent display name (set on config.default_agent) */
+    defaultAgent?: string;
+    tools: string[];
+    mcps: Record<string, unknown>;
+    commands: Record<string, unknown>;
+}
+/**
+ * Runs the 6-phase config pipeline for the Fabric config hook.
+ * Phases 1, 4, 5, 6 are pass-through for v1.
+ * Phase 2 merges agent overrides, filters disabled, and remaps keys to display names.
+ * Phase 3 filters disabled tools.
+ */
+export declare class ConfigHandler {
+    private readonly pluginConfig;
+    constructor(options: {
+        pluginConfig: WeaveConfig;
+    });
+    /** Run the 6-phase pipeline and return accumulated config output */
+    handle(input: ConfigPipelineInput): Promise<ConfigPipelineOutput>;
+    /** Phase 1: Provider detection happens elsewhere — pass through */
+    private applyProviderConfig;
+    /**
+     * Phase 2: Merge agent overrides from pluginConfig.agents.
+     * Exclude agents listed in pluginConfig.disabled_agents.
+     * Remap keys from config keys (e.g., "loom") to display names (e.g., "Loom (Main Orchestrator)").
+     */
+    private applyAgentConfig;
+    /**
+     * Resolve the default agent display name.
+     * Returns the display name of "loom" if present in resolved agents, otherwise first primary agent.
+     */
+    private resolveDefaultAgent;
+    /** Phase 3: Filter tools by disabled_tools */
+    private applyToolConfig;
+    /** Phase 4: MCP loading is done elsewhere — return empty for v1 */
+    private applyMcpConfig;
+    /** Phase 5: Return builtin commands with agent fields remapped to display names */
+    private applyCommandConfig;
+    /** Phase 6: Skill injection happens in agent builder — no-op for v1 */
+    private applySkillConfig;
+}

package/dist/managers/index.d.ts

@@ -0,0 +1,6 @@
+export { ConfigHandler } from "./config-handler";
+export type { ConfigPipelineInput, ConfigPipelineOutput } from "./config-handler";
+export { BackgroundManager } from "./background-manager";
+export type { SpawnOptions, TaskRecord, TaskStatus } from "./background-manager";
+export { SkillMcpManager } from "./skill-mcp-manager";
+export type { McpClient, McpServerConfig, SkillMcpClientInfo } from "./skill-mcp-manager";

package/dist/managers/skill-mcp-manager.d.ts

@@ -0,0 +1,30 @@
+export interface McpClient {
+    callTool(params: {
+        name: string;
+        arguments: Record<string, unknown>;
+    }): Promise<{
+        content: unknown;
+    }>;
+    close(): Promise<void>;
+}
+export interface McpServerConfig {
+    type?: "stdio" | "http";
+    command?: string;
+    args?: string[];
+    url?: string;
+    env?: Record<string, string>;
+}
+export interface SkillMcpClientInfo {
+    sessionID: string;
+    skillName: string;
+    serverName: string;
+}
+export declare class SkillMcpManager {
+    private clients;
+    getOrCreateClient(info: SkillMcpClientInfo, config: McpServerConfig): Promise<McpClient>;
+    disconnectSession(sessionID: string): Promise<void>;
+    disconnectAll(): Promise<void>;
+    getConnectedServers(): string[];
+    isConnected(info: SkillMcpClientInfo): boolean;
+    callTool(info: SkillMcpClientInfo, config: McpServerConfig, name: string, args: Record<string, unknown>): Promise<unknown>;
+}

package/dist/plugin/index.d.ts

@@ -0,0 +1 @@
+export type { PluginContext, PluginInstance, PluginInterface, ToolsRecord } from "./types";

package/dist/plugin/plugin-interface.d.ts

@@ -0,0 +1,17 @@
+import type { PluginInterface, ToolsRecord } from "./types";
+import type { AgentConfig } from "@fabriccode/sdk";
+import type { WeaveConfig } from "../config/schema";
+import type { ConfigHandler } from "../managers/config-handler";
+import type { CreatedHooks } from "../hooks/create-hooks";
+import type { PluginContext } from "./types";
+import type { SessionTracker } from "../features/analytics";
+export declare function createPluginInterface(args: {
+    pluginConfig: WeaveConfig;
+    hooks: CreatedHooks;
+    tools: ToolsRecord;
+    configHandler: ConfigHandler;
+    agents: Record<string, AgentConfig>;
+    client?: PluginContext["client"];
+    directory?: string;
+    tracker?: SessionTracker;
+}): PluginInterface;

package/dist/plugin/types.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin, ToolDefinition } from "@fabriccode/plugin";
+export type PluginContext = Parameters<Plugin>[0];
+export type PluginInstance = Awaited<ReturnType<Plugin>>;
+export type PluginInterface = Required<Pick<PluginInstance, "tool" | "config" | "chat.message" | "chat.params" | "chat.headers" | "event" | "tool.execute.before" | "tool.execute.after" | "command.execute.before">>;
+export type ToolsRecord = Record<string, ToolDefinition>;

package/dist/shared/agent-display-names.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Agent config keys to display names mapping.
+ * Config keys are lowercase (e.g., "loom", "thread").
+ * Display names include role suffixes for UI (e.g., "Loom (Main Orchestrator)").
+ *
+ * Fabric uses the agent key in config.agent as the display name in the UI,
+ * so we remap lowercase config keys to descriptive display names.
+ *
+ * This map is mutable — custom agents can register display names via
+ * registerAgentDisplayName().
+ */
+export declare const AGENT_DISPLAY_NAMES: Record<string, string>;
+/**
+ * Register a display name for an agent config key.
+ * Custom agents call this so getAgentDisplayName/getAgentConfigKey work for them.
+ *
+ * Throws if the display name collides with a built-in agent's display name,
+ * or if the config key is a built-in agent name.
+ */
+export declare function registerAgentDisplayName(configKey: string, displayName: string): void;
+/**
+ * Get display name for an agent config key.
+ * Uses case-insensitive lookup for flexibility.
+ * Returns original key if not found in the mapping.
+ */
+export declare function getAgentDisplayName(configKey: string): string;
+/**
+ * Resolve an agent name (display name or config key) to its lowercase config key.
+ * "Loom (Main Orchestrator)" → "loom", "loom" → "loom", "unknown" → "unknown"
+ */
+export declare function getAgentConfigKey(agentName: string): string;

package/dist/shared/index.d.ts

@@ -0,0 +1,5 @@
+export type { DeepPartial, Brand } from "./types";
+export { getWeaveVersion } from "./version";
+export { log, getLogFilePath, logDelegation } from "./log";
+export type { DelegationEvent } from "./log";
+export { AGENT_DISPLAY_NAMES, getAgentDisplayName, getAgentConfigKey, registerAgentDisplayName, } from "./agent-display-names";

package/dist/shared/log.d.ts

@@ -0,0 +1,11 @@
+export declare function log(message: string, data?: unknown): void;
+export declare function getLogFilePath(): string;
+export interface DelegationEvent {
+    phase: "start" | "complete" | "error";
+    agent: string;
+    sessionId?: string;
+    toolCallId?: string;
+    durationMs?: number;
+    summary?: string;
+}
+export declare function logDelegation(event: DelegationEvent): void;

package/dist/shared/types.d.ts

@@ -0,0 +1,6 @@
+export type DeepPartial<T> = T extends Array<infer U> ? Array<U> : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+export type Brand<T, B> = T & {
+    readonly __brand: B;
+};

package/dist/shared/version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the current Weave package version from package.json.
+ * Cached after first read. Falls back to "0.0.0" if reading fails.
+ */
+export declare function getWeaveVersion(): string;

package/dist/tools/index.d.ts

@@ -0,0 +1,4 @@
+export { createToolRegistry } from "./registry";
+export { createToolPermissions } from "./permissions";
+export type { ToolRegistryResult, ToolRegistryOptions } from "./registry";
+export type { ToolPermissions, ToolPermissionMap } from "./permissions";

package/dist/tools/permissions.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tool permission management — per-agent grant/deny tool lists.
+ *
+ * Tools are represented as a boolean map where false = denied.
+ * This matches the AgentConfig.tools shape from @fabriccode/sdk.
+ */
+export type ToolPermissionMap = Record<string, boolean>;
+export type ToolPermissions = {
+    getRestrictions(agentName: string): ToolPermissionMap;
+    isToolAllowed(agentName: string, toolName: string): boolean;
+};
+/**
+ * Build a ToolPermissions object from a record of agent configs.
+ *
+ * Each agent config's `tools` map is extracted and used for permission checks.
+ * Agents without a `tools` map have no restrictions (all tools allowed).
+ */
+export declare function createToolPermissions(agentRestrictions: Record<string, ToolPermissionMap>): ToolPermissions;

package/dist/tools/registry.d.ts

@@ -0,0 +1,29 @@
+import type { WeaveConfig } from "../config/schema";
+import type { ToolPermissions, ToolPermissionMap } from "./permissions";
+export type { ToolPermissions, ToolPermissionMap };
+/**
+ * Result from createToolRegistry.
+ * filteredTools: tool names allowed globally (not in disabled_tools).
+ * permissions: per-agent tool permission checker.
+ * taskSystemEnabled: whether the task spawning tool is globally enabled.
+ */
+export interface ToolRegistryResult {
+    filteredTools: string[];
+    permissions: ToolPermissions;
+    taskSystemEnabled: boolean;
+}
+export interface ToolRegistryOptions {
+    /** All available tool names (from Fabric's tool system) */
+    availableTools: string[];
+    /** Config with disabled_tools list */
+    config: WeaveConfig;
+    /** Per-agent tool restriction maps (from agent configs) */
+    agentRestrictions: Record<string, ToolPermissionMap>;
+}
+/**
+ * Create a tool registry that filters by disabled_tools and builds per-agent permissions.
+ *
+ * Tools are not reimplemented here — they come from Fabric.
+ * Weave only manages which tools are visible and which are denied per agent.
+ */
+export declare function createToolRegistry(options: ToolRegistryOptions): ToolRegistryResult;

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@fabriccode/weave",
+  "version": "0.7.0",
+  "description": "Weave — lean Fabric plugin with multi-agent orchestration",
+  "author": "Weave",
+  "license": "MIT",
+  "homepage": "https://github.com/pgermishuys/weave#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pgermishuys/weave.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "bun run script/build.ts && tsc --emitDeclarationOnly",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "eval": "bun run script/eval.ts",
+    "eval:smoke": "bun run script/eval.ts --suite pr-smoke",
+    "eval:coverage": "bun run script/verify-eval-coverage.ts"
+  },
+  "keywords": [
+    "fabric",
+    "plugin",
+    "agents",
+    "weave"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "dependencies": {
+    "@fabriccode/plugin": "^7.0.46",
+    "@fabriccode/sdk": "^7.0.46",
+    "jsonc-parser": "^3.3.1",
+    "picocolors": "^1.1.1",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "bun": "^1.3.9",
+    "bun-types": "^1.3.6",
+    "typescript": "^5.7.3"
+  }
+}