plugsuits 1.0.0

package/src/interaction/spinner.ts

@@ -0,0 +1,61 @@
+let spinnerOutputEnabled = true;
+
+export const setSpinnerOutputEnabled = (enabled: boolean): void => {
+  spinnerOutputEnabled = enabled;
+};
+
+export class Spinner {
+  private interval: Timer | null = null;
+  private readonly frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  private currentFrame = 0;
+  private readonly message: string;
+
+  constructor(message = "Loading...") {
+    this.message = message;
+  }
+
+  start(): void {
+    if (this.interval) {
+      return;
+    }
+
+    if (!spinnerOutputEnabled) {
+      return;
+    }
+
+    process.stdout.write("\x1B[?25l");
+    this.interval = setInterval(() => {
+      const frame = this.frames[this.currentFrame];
+      process.stdout.write(`\r${frame} ${this.message}`);
+      this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+    }, 80);
+  }
+
+  stop(): void {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+
+    if (!spinnerOutputEnabled) {
+      return;
+    }
+
+    process.stdout.write("\r\x1B[K");
+    process.stdout.write("\x1B[?25h");
+  }
+
+  succeed(message?: string): void {
+    this.stop();
+    if (message) {
+      process.stdout.write(`✓ ${message}\n`);
+    }
+  }
+
+  fail(message?: string): void {
+    this.stop();
+    if (message) {
+      process.stdout.write(`✗ ${message}\n`);
+    }
+  }
+}

package/src/middleware/index.ts

@@ -0,0 +1,32 @@
+import type { LanguageModelV3Middleware } from "@ai-sdk/provider";
+import {
+  hermesToolMiddleware,
+  morphXmlToolMiddleware,
+  qwen3CoderToolMiddleware,
+} from "@ai-sdk-tool/parser";
+import type { ToolFallbackMode } from "../tool-fallback-mode";
+import { trimLeadingNewlinesMiddleware as trimMiddleware } from "./trim-leading-newlines";
+
+export interface MiddlewareOptions {
+  toolFallbackMode: ToolFallbackMode;
+}
+
+const TOOL_FALLBACK_MIDDLEWARES: Readonly<
+  Record<Exclude<ToolFallbackMode, "disable">, LanguageModelV3Middleware>
+> = {
+  morphxml: morphXmlToolMiddleware,
+  hermes: hermesToolMiddleware,
+  qwen3coder: qwen3CoderToolMiddleware,
+};
+
+export function buildMiddlewares(
+  options: MiddlewareOptions
+): LanguageModelV3Middleware[] {
+  const middlewares: LanguageModelV3Middleware[] = [trimMiddleware];
+
+  if (options.toolFallbackMode !== "disable") {
+    middlewares.push(TOOL_FALLBACK_MIDDLEWARES[options.toolFallbackMode]);
+  }
+
+  return middlewares;
+}

package/src/middleware/todo-continuation.ts

@@ -0,0 +1,128 @@
+import { readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { TODO_DIR } from "../context/paths";
+import { getSessionId, hasActiveSession } from "../context/session";
+
+export interface TodoItem {
+  content: string;
+  description?: string;
+  id: string;
+  priority: "high" | "medium" | "low";
+  status: "pending" | "in_progress" | "completed" | "cancelled";
+}
+
+interface TodoData {
+  todos: TodoItem[];
+  updatedAt: string;
+}
+
+export async function getIncompleteTodos(): Promise<TodoItem[]> {
+  if (!hasActiveSession()) {
+    return [];
+  }
+
+  const sessionId = getSessionId();
+  const todoPath = join(process.cwd(), TODO_DIR, `${sessionId}.json`);
+
+  try {
+    await stat(todoPath);
+  } catch (error: unknown) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+
+  let data: TodoData;
+  try {
+    const content = await readFile(todoPath, "utf-8");
+    data = JSON.parse(content);
+  } catch {
+    return [];
+  }
+
+  if (!Array.isArray(data.todos)) {
+    return [];
+  }
+
+  return data.todos.filter(
+    (t) => t.status !== "completed" && t.status !== "cancelled"
+  );
+}
+
+const STATUS_EMOJI_MAP: Record<TodoItem["status"], string> = {
+  in_progress: "🔄",
+  pending: "📋",
+  completed: "✅",
+  cancelled: "❌",
+};
+
+const buildTodoTaskList = (todos: TodoItem[]): string =>
+  todos
+    .map((t, i) => {
+      const statusEmoji = STATUS_EMOJI_MAP[t.status] ?? "⚠️";
+      return `${i + 1}. ${statusEmoji} [${t.status.toUpperCase()}] ${t.content} (priority: ${t.priority})`;
+    })
+    .join("\n");
+
+export function buildTodoContinuationPrompt(todos: TodoItem[]): string {
+  const taskList = buildTodoTaskList(todos);
+
+  return `
+
+---
+
+[SYSTEM REMINDER - TODO CONTINUATION]
+
+You have an active todo list with ${todos.length} incomplete task(s):
+
+${taskList}
+
+CRITICAL EXECUTION RULES - READ CAREFULLY:
+
+1. EXECUTE TASKS, DO NOT JUST DESCRIBE THEM
+   - DO NOT tell the user to run commands manually
+   - YOU must call shell_execute to run commands
+   - YOU must call write_file/edit_file to modify files
+   - DO NOT wait for user to do the work - YOU do it
+
+2. CONTINUOUS EXECUTION:
+   - Mark task as in_progress using todo_write
+   - Execute the task using appropriate tools (shell_execute, write_file, etc.)
+   - Mark as completed using todo_write
+   - IMMEDIATELY start next task without stopping
+   - DO NOT ask user if ready - just continue
+
+3. Tool Usage:
+   - For git commands: USE shell_execute
+   - For file changes: USE write_file or edit_file
+   - For running tests: USE shell_execute
+   - DO NOT tell user to run commands - YOU run them
+
+4. Continue until COMPLETE:
+   - Process ALL tasks in sequence
+   - Only stop when ALL tasks are marked completed
+   - Do NOT wait for user confirmation between tasks
+
+You are autonomous. Execute tasks, do not just describe them.
+
+---
+`.trim();
+}
+
+export function buildTodoContinuationUserMessage(todos: TodoItem[]): string {
+  const taskList = buildTodoTaskList(todos);
+
+  return [
+    "[SYSTEM REMINDER - TODO CONTINUATION]",
+    "",
+    `You have ${todos.length} incomplete task(s):`,
+    "",
+    taskList,
+    "",
+    "Continue executing the tasks now. Update statuses with todo_write.",
+    "Do not stop until all tasks are completed.",
+  ]
+    .join("\n")
+    .trim();
+}

package/src/middleware/trim-leading-newlines.ts

@@ -0,0 +1,66 @@
+import type {
+  LanguageModelV3Content,
+  LanguageModelV3Middleware,
+  LanguageModelV3StreamPart,
+} from "@ai-sdk/provider";
+
+const LEADING_NEWLINES = /^\n+/;
+
+function trimContentLeadingNewlines(
+  content: LanguageModelV3Content[]
+): LanguageModelV3Content[] {
+  if (content.length === 0) {
+    return content;
+  }
+
+  const first = content[0];
+  if (first.type === "text") {
+    const trimmed = first.text.replace(LEADING_NEWLINES, "");
+    if (trimmed === first.text) {
+      return content;
+    }
+    return [{ ...first, text: trimmed }, ...content.slice(1)];
+  }
+  return content;
+}
+
+export const trimLeadingNewlinesMiddleware: LanguageModelV3Middleware = {
+  specificationVersion: "v3",
+  wrapGenerate: async ({ doGenerate }) => {
+    const result = await doGenerate();
+    return {
+      ...result,
+      content: trimContentLeadingNewlines(result.content),
+    };
+  },
+
+  wrapStream: async ({ doStream }) => {
+    const { stream, ...rest } = await doStream();
+
+    let hasTrimmed = false;
+
+    const transformStream = new TransformStream<
+      LanguageModelV3StreamPart,
+      LanguageModelV3StreamPart
+    >({
+      transform(chunk, controller) {
+        if (chunk.type === "text-delta" && !hasTrimmed) {
+          const trimmed = chunk.delta.replace(LEADING_NEWLINES, "");
+          if (trimmed !== "" || chunk.delta === "") {
+            hasTrimmed = true;
+          }
+          if (trimmed !== "") {
+            controller.enqueue({ ...chunk, delta: trimmed });
+          }
+          return;
+        }
+        controller.enqueue(chunk);
+      },
+    });
+
+    return {
+      stream: stream.pipeThrough(transformStream),
+      ...rest,
+    };
+  },
+};

package/src/reasoning-mode.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "bun:test";
+import { parseReasoningMode } from "./reasoning-mode";
+
+describe("parseReasoningMode", () => {
+  it("parses canonical reasoning modes", () => {
+    expect(parseReasoningMode("off")).toBe("off");
+    expect(parseReasoningMode("on")).toBe("on");
+    expect(parseReasoningMode("interleaved")).toBe("interleaved");
+    expect(parseReasoningMode("preserved")).toBe("preserved");
+  });
+
+  it("parses compatibility aliases", () => {
+    expect(parseReasoningMode("enable")).toBe("on");
+    expect(parseReasoningMode("true")).toBe("on");
+    expect(parseReasoningMode("disable")).toBe("off");
+    expect(parseReasoningMode("false")).toBe("off");
+    expect(parseReasoningMode("interleave")).toBe("interleaved");
+    expect(parseReasoningMode("preserve")).toBe("preserved");
+  });
+
+  it("returns null for unknown values", () => {
+    expect(parseReasoningMode("something-else")).toBeNull();
+  });
+});

package/src/reasoning-mode.ts

@@ -0,0 +1,40 @@
+export const REASONING_MODES = [
+  "off",
+  "on",
+  "interleaved",
+  "preserved",
+] as const;
+
+export type ReasoningMode = (typeof REASONING_MODES)[number];
+
+export const DEFAULT_REASONING_MODE: ReasoningMode = "off";
+
+const isReasoningMode = (value: string): value is ReasoningMode => {
+  return REASONING_MODES.includes(value as ReasoningMode);
+};
+
+export const parseReasoningMode = (rawValue: string): ReasoningMode | null => {
+  const value = rawValue.toLowerCase();
+
+  if (isReasoningMode(value)) {
+    return value;
+  }
+
+  if (value === "enable" || value === "true") {
+    return "on";
+  }
+
+  if (value === "disable" || value === "false") {
+    return "off";
+  }
+
+  if (value === "interleave") {
+    return "interleaved";
+  }
+
+  if (value === "preserve") {
+    return "preserved";
+  }
+
+  return null;
+};

package/src/skills/example/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: example
+description: Example v2 skill demonstrating agentskills.io standard with subdirectories
+license: MIT
+compatibility: Works on all platforms
+metadata:
+  author: minpeter
+  version: 1.0.0
+allowed-tools: shell_execute(*) read_file(*)
+---
+
+# Example Skill (v2 Format)
+
+This is an example skill using the agentskills.io v2 standard format.
+
+## Features
+
+- Demonstrates YAML frontmatter parsing
+- Shows directory-based structure with subdirectories
+- Includes scripts and reference files
+
+## Usage
+
+1. Load this skill using `load_skill("example")`
+2. Access subdirectory files using `load_skill("example", "scripts/setup.sh")`
+3. Reference documentation at `references/api.md`
+
+## Available Resources
+
+### Scripts
+- `scripts/setup.sh` - Setup script for initializing the environment
+
+### References
+- `references/api.md` - API documentation
+
+## Example Commands
+
+```bash
+# Run setup script
+./scripts/setup.sh
+
+# Check API documentation
+cat references/api.md
+```

package/src/skills/example/references/api.md

@@ -0,0 +1,37 @@
+# API Reference
+
+## Overview
+
+This is an example API reference document stored in a v2 skill subdirectory.
+
+## Endpoints
+
+### GET /api/health
+Check service health status
+
+**Response:**
+```json
+{
+  "status": "ok",
+  "timestamp": "2025-01-19T00:00:00Z"
+}
+```
+
+### POST /api/data
+Submit data to the service
+
+**Request:**
+```json
+{
+  "key": "value",
+  "data": "example"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "id": "12345"
+}
+```

package/src/skills/example/scripts/setup.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+# Setup script for example skill
+
+echo "Setting up example skill..."
+echo "This is a demonstration of v2 skill subdirectory files"
+
+# Check environment
+if [ -z "$USER" ]; then
+    echo "Error: USER environment variable not set"
+    exit 1
+fi
+
+echo "Setup complete for user: $USER"