@wrongstack/plugins 0.1.0

package/dist/shell-check.js

@@ -0,0 +1,225 @@
+import { execSync } from 'child_process';
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+// src/shell-check/index.ts
+var API_VERSION = "^0.1.10";
+function runShellCheck(files, severity, cwd) {
+  if (!existsSync("shellcheck")) {
+    try {
+      execSync("shellcheck --version", { encoding: "utf-8", stdio: "ignore" });
+    } catch {
+      throw new Error("shellcheck is not installed. Install via: apt install shellcheck / brew install shellcheck");
+    }
+  }
+  const levelMap = {
+    error: "error",
+    warning: "warning",
+    info: "info",
+    style: "style"
+  };
+  const args = [
+    "-f",
+    "json",
+    "-S",
+    levelMap[severity] ?? "warning",
+    ...files
+  ];
+  let raw;
+  try {
+    raw = execSync(`shellcheck ${args.join(" ")}`, {
+      encoding: "utf-8",
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 6e4
+    });
+  } catch (err) {
+    const e = err;
+    if (e.stderr && !e.stderr.includes("shellcheck")) {
+      raw = e.stderr;
+    } else {
+      return [];
+    }
+  }
+  if (!raw.trim()) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed.map((item) => ({
+      file: item.file,
+      line: item.line,
+      column: item.column,
+      level: item.level,
+      code: item.code,
+      message: item.message
+    }));
+  } catch {
+    return [];
+  }
+}
+function findShellFiles(dir, pattern) {
+  const results = [];
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".git") {
+        results.push(...findShellFiles(full, pattern));
+      } else if (entry.isFile() && (entry.name.endsWith(".sh") || entry.name === "Dockerfile")) {
+        if (!pattern || entry.name.includes(pattern)) {
+          results.push(full);
+        }
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+var plugin = {
+  name: "shell-check",
+  version: "0.1.0",
+  description: "Runs shellcheck analysis on bash/shell scripts and surfaces issues with severity levels",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, pipelines: ["toolCall"] },
+  defaultConfig: {
+    severity: "warning",
+    severityThreshold: "warning",
+    ignoredCodes: [],
+    autoScanOnBash: false
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      severity: { type: "string", enum: ["error", "warning", "info", "style"], default: "warning" },
+      severityThreshold: { type: "string", enum: ["error", "warning", "info", "style"], default: "warning" },
+      ignoredCodes: { type: "array", items: { type: "string" }, default: [] },
+      autoScanOnBash: { type: "boolean", default: false }
+    }
+  },
+  setup(api) {
+    api.tools.register({
+      name: "shellcheck",
+      description: "Run shellcheck analysis on shell script files. Returns issues with file, line, column, severity, code, and message.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          files: {
+            type: "array",
+            items: { type: "string" },
+            description: "Shell script files to check"
+          },
+          severity: {
+            type: "string",
+            enum: ["error", "warning", "info", "style"],
+            default: "warning",
+            description: "Minimum severity level to report"
+          },
+          fix: {
+            type: "boolean",
+            default: false,
+            description: "Apply safe automatic fixes where possible"
+          }
+        },
+        required: ["files"]
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        const files = input["files"];
+        const severity = input["severity"] ?? "warning";
+        let issues;
+        try {
+          issues = runShellCheck(files, severity);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { ok: false, error: msg, issues: [] };
+        }
+        const byFile = {};
+        for (const issue of issues) {
+          (byFile[issue.file] ??= []).push(issue);
+        }
+        const errorCount = issues.filter((i) => i.level === "error").length;
+        const warningCount = issues.filter((i) => i.level === "warning").length;
+        const infoCount = issues.filter((i) => i.level === "info").length;
+        const styleCount = issues.filter((i) => i.level === "style").length;
+        api.metrics.counter("issues_found", issues.length, { severity });
+        api.metrics.histogram("issues_per_file", issues.length / Math.max(files.length, 1));
+        return {
+          ok: true,
+          filesScanned: files.length,
+          issues,
+          summary: {
+            total: issues.length,
+            errors: errorCount,
+            warnings: warningCount,
+            info: infoCount,
+            style: styleCount
+          },
+          byFile,
+          recommendation: errorCount > 0 ? "Fix errors before deploying." : warningCount > 0 ? "Review and fix warnings for better script quality." : "No issues found."
+        };
+      }
+    });
+    api.tools.register({
+      name: "shellcheck_scan",
+      description: "Recursively scan a directory for shell scripts and run shellcheck on all found files.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          directory: {
+            type: "string",
+            default: ".",
+            description: "Directory to scan"
+          },
+          pattern: {
+            type: "string",
+            default: "",
+            description: "Filename pattern to match (default: all .sh files)"
+          },
+          severity: {
+            type: "string",
+            enum: ["error", "warning", "info", "style"],
+            default: "warning"
+          }
+        }
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        const dir = input["directory"] ?? ".";
+        const pattern = input["pattern"] ?? "";
+        const severity = input["severity"] ?? "warning";
+        const files = findShellFiles(dir, pattern);
+        if (files.length === 0) {
+          return { ok: true, filesScanned: 0, issues: [], summary: { total: 0 } };
+        }
+        let issues;
+        try {
+          issues = runShellCheck(files, severity);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { ok: false, error: msg, issues: [], filesScanned: 0 };
+        }
+        const byFile = {};
+        for (const issue of issues) {
+          (byFile[issue.file] ??= []).push(issue);
+        }
+        return {
+          ok: true,
+          filesScanned: files.length,
+          filesWithIssues: Object.keys(byFile).length,
+          issues,
+          summary: {
+            total: issues.length,
+            errors: issues.filter((i) => i.level === "error").length,
+            warnings: issues.filter((i) => i.level === "warning").length
+          },
+          byFile
+        };
+      }
+    });
+    api.log.info("shell-check plugin loaded", { version: "0.1.0" });
+  }
+};
+var shell_check_default = plugin;
+
+export { shell_check_default as default };

package/dist/template-engine.d.ts

@@ -0,0 +1,15 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * template-engine plugin — File template expansion with variable substitution.
+ *
+ * Tools registered:
+ * - template_expand: Expand a template string with variables
+ * - template_render: Read a template file and expand it
+ * - template_create: Save a named template to the plugin store
+ * - template_list: List all saved templates
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/template-engine.js

@@ -0,0 +1,267 @@
+// src/template-engine/index.ts
+var API_VERSION = "^0.1.10";
+function expandTemplate(template, variables) {
+  let result = template;
+  result = result.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    const value = variables[key];
+    if (value !== void 0) return value;
+    return match;
+  });
+  return result;
+}
+function expandConditionals(template, variables) {
+  return template.replace(
+    /\{\{#if\s+(\w+)\}\}([\s\S]*?)\{\{\/if\}\}/g,
+    (_, key, content) => {
+      const val = variables[key];
+      return val !== void 0 && val !== "" && val !== "false" && val !== "0" ? content : "";
+    }
+  );
+}
+function expandLoops(template, variables) {
+  return template.replace(
+    /\{\{#each\s+(\w+)\}\}([\s\S]*?)\{\{\/each\}\}/g,
+    (_, key, content) => {
+      const val = variables[key];
+      if (!val) return "";
+      if (typeof val === "string" && val.includes(",")) {
+        const items = val.split(",").map((s) => s.trim());
+        return items.map((item) => expandTemplate(content, { ...variables, [key]: item })).join("\n");
+      }
+      return expandTemplate(content, variables);
+    }
+  );
+}
+function renderTemplate(template, variables) {
+  let result = template;
+  result = expandConditionals(result, variables);
+  result = expandLoops(result, variables);
+  result = expandTemplate(result, variables);
+  {
+    result = result.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  }
+  return result;
+}
+function renderTemplateRaw(template, variables) {
+  let result = template;
+  result = expandConditionals(result, variables);
+  result = expandLoops(result, variables);
+  result = expandTemplate(result, variables);
+  return result;
+}
+var plugin = {
+  name: "template-engine",
+  version: "0.1.0",
+  description: "Expands file templates with variable substitution, conditionals, and loops",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true },
+  defaultConfig: {
+    autoEscapeHtml: true,
+    templateDir: "./templates",
+    strictVariables: false
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      autoEscapeHtml: { type: "boolean", default: true },
+      templateDir: { type: "string", default: "./templates" },
+      strictVariables: { type: "boolean", default: false }
+    }
+  },
+  setup(api) {
+    const templates = /* @__PURE__ */ new Map();
+    api.tools.register({
+      name: "template_expand",
+      description: "Expand a template string with variable substitution. Supports {{variable}}, {{#if var}}...{{/if}} conditionals, and {{#each items}}...{{/each}} loops.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          template: { type: "string", description: "Template string with {{variable}} placeholders" },
+          variables: {
+            type: "object",
+            description: "Variables to substitute into the template",
+            additionalProperties: { type: "string" }
+          },
+          outputPath: { type: "string", description: "Optional path to write the expanded result" },
+          raw: { type: "boolean", default: false, description: "Disable HTML auto-escaping" }
+        },
+        required: ["template", "variables"]
+      },
+      permission: "auto",
+      mutating: true,
+      async execute(input) {
+        const template = input["template"];
+        const variables = input["variables"];
+        const outputPath = input["outputPath"];
+        const raw = input["raw"] ?? false;
+        if (!template || typeof template !== "string") {
+          return { ok: false, error: "template is required and must be a string" };
+        }
+        if (!variables || typeof variables !== "object") {
+          return { ok: false, error: "variables is required and must be an object" };
+        }
+        let result;
+        try {
+          result = raw ? renderTemplateRaw(template, variables) : renderTemplate(template, variables);
+        } catch (err) {
+          return { ok: false, error: String(err) };
+        }
+        if (outputPath) {
+          const { writeFileSync } = await import('fs');
+          writeFileSync(outputPath, result, "utf-8");
+          return {
+            ok: true,
+            outputPath,
+            contentLength: result.length,
+            message: `Wrote ${result.length} characters to ${outputPath}`
+          };
+        }
+        return {
+          ok: true,
+          result,
+          contentLength: result.length,
+          variableCount: Object.keys(variables).length
+        };
+      }
+    });
+    api.tools.register({
+      name: "template_render",
+      description: "Read a template file from disk and expand it with the given variables.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          templatePath: { type: "string", description: "Path to the template file" },
+          variables: {
+            type: "object",
+            description: "Variables to substitute",
+            additionalProperties: { type: "string" }
+          },
+          outputPath: { type: "string", description: "Optional path to write the rendered result" },
+          raw: { type: "boolean", default: false }
+        },
+        required: ["templatePath", "variables"]
+      },
+      permission: "auto",
+      mutating: true,
+      async execute(input) {
+        const templatePath = input["templatePath"];
+        const variables = input["variables"];
+        const outputPath = input["outputPath"];
+        const raw = input["raw"] ?? false;
+        if (!templatePath || typeof templatePath !== "string") {
+          return { ok: false, error: "templatePath is required and must be a string" };
+        }
+        if (!variables || typeof variables !== "object") {
+          return { ok: false, error: "variables is required and must be an object" };
+        }
+        let content;
+        try {
+          const { readFileSync } = await import('fs');
+          content = readFileSync(templatePath, "utf-8");
+        } catch (err) {
+          return { ok: false, error: `Could not read template file: ${err}` };
+        }
+        let result;
+        try {
+          result = raw ? renderTemplateRaw(content, variables) : renderTemplate(content, variables);
+        } catch (err) {
+          return { ok: false, error: `Template rendering failed: ${err}` };
+        }
+        if (outputPath) {
+          const { writeFileSync } = await import('fs');
+          writeFileSync(outputPath, result, "utf-8");
+          return {
+            ok: true,
+            templatePath,
+            outputPath,
+            message: `Rendered and wrote ${result.length} chars to ${outputPath}`
+          };
+        }
+        return {
+          ok: true,
+          templatePath,
+          result,
+          contentLength: result.length
+        };
+      }
+    });
+    api.tools.register({
+      name: "template_create",
+      description: "Save a named template to the plugin's template store for later use.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Unique name for this template" },
+          content: { type: "string", description: "Template content with {{variable}} placeholders" },
+          description: { type: "string", description: "Optional description of what this template is for" }
+        },
+        required: ["name", "content"]
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        const name = input["name"];
+        const content = input["content"];
+        const description = input["description"];
+        if (!name || typeof name !== "string" || name.trim() === "") {
+          return { ok: false, error: "name is required and must be a non-empty string" };
+        }
+        if (!content || typeof content !== "string") {
+          return { ok: false, error: "content is required and must be a string" };
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const existing = templates.get(name);
+        const tmpl = {
+          name,
+          content,
+          description,
+          createdAt: existing?.createdAt ?? now,
+          updatedAt: now
+        };
+        templates.set(name, tmpl);
+        api.metrics.gauge("template_count", templates.size);
+        return {
+          ok: true,
+          name,
+          message: existing ? `Updated template '${name}'.` : `Created template '${name}'.`,
+          createdAt: tmpl.createdAt
+        };
+      }
+    });
+    api.tools.register({
+      name: "template_list",
+      description: "List all templates saved in the plugin's template store.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      mutating: false,
+      async execute() {
+        const list = Array.from(templates.values()).map((t) => ({
+          name: t.name,
+          description: t.description,
+          contentLength: t.content.length,
+          createdAt: t.createdAt,
+          updatedAt: t.updatedAt
+        }));
+        return {
+          ok: true,
+          count: list.length,
+          templates: list
+        };
+      }
+    });
+    api.registerSystemPromptContributor(async () => [
+      {
+        type: "text",
+        text: `Template engine available:
+- template_expand: expand a template string with {{variable}}, {{#if}} conditionals, {{#each}} loops
+- template_render: render a template file with variables
+- template_create: save a named template
+- template_list: list saved templates`
+      }
+    ]);
+    api.log.info("template-engine plugin loaded", { version: "0.1.0" });
+  }
+};
+var template_engine_default = plugin;
+
+export { template_engine_default as default };

package/dist/web-search.d.ts

@@ -0,0 +1,13 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * web-search plugin — Cached web search with deduplication and ranking.
+ *
+ * Tools registered:
+ * - web_search: Search the web with caching and deduplication
+ * - web_fetch: Fetch a URL and return content as markdown
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };