@wipcomputer/wip-ai-devops-toolbox 1.9.20

package/tools/wip-universal-installer/detect.mjs

@@ -0,0 +1,130 @@
+/**
+ * wip-universal-installer/detect.mjs
+ * Interface detection logic. Scans a repo and reports which interfaces it exposes.
+ * Importable by other tools. Zero dependencies.
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join, basename } from 'node:path';
+
+function readJSON(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Detect all interfaces in a repo.
+ * Returns { interfaces, pkg } where interfaces is an object keyed by interface type.
+ */
+export function detectInterfaces(repoPath) {
+  const interfaces = {};
+  const pkg = readJSON(join(repoPath, 'package.json'));
+
+  // 1. CLI: package.json has bin entry
+  if (pkg?.bin) {
+    interfaces.cli = { bin: pkg.bin, name: pkg.name };
+  }
+
+  // 2. Module: package.json has main or exports
+  if (pkg?.main || pkg?.exports) {
+    interfaces.module = { main: pkg.main || pkg.exports };
+  }
+
+  // 3. MCP Server: mcp-server.mjs/js/ts or dist/mcp-server.js
+  const mcpFiles = ['mcp-server.mjs', 'mcp-server.js', 'mcp-server.ts', 'dist/mcp-server.js'];
+  for (const f of mcpFiles) {
+    if (existsSync(join(repoPath, f))) {
+      interfaces.mcp = { file: f, name: pkg?.name || basename(repoPath) };
+      break;
+    }
+  }
+
+  // 4. OpenClaw Plugin: openclaw.plugin.json exists
+  const ocPlugin = join(repoPath, 'openclaw.plugin.json');
+  if (existsSync(ocPlugin)) {
+    interfaces.openclaw = { config: readJSON(ocPlugin), path: ocPlugin };
+  }
+
+  // 5. Skill: SKILL.md exists
+  if (existsSync(join(repoPath, 'SKILL.md'))) {
+    interfaces.skill = { path: join(repoPath, 'SKILL.md') };
+  }
+
+  // 6. Claude Code Hook: guard.mjs or claudeCode.hook in package.json
+  if (pkg?.claudeCode?.hook) {
+    interfaces.claudeCodeHook = pkg.claudeCode.hook;
+  } else if (existsSync(join(repoPath, 'guard.mjs'))) {
+    interfaces.claudeCodeHook = {
+      event: 'PreToolUse',
+      matcher: 'Edit|Write',
+      command: `node "${join(repoPath, 'guard.mjs')}"`,
+      timeout: 5
+    };
+  }
+
+  return { interfaces, pkg };
+}
+
+/**
+ * Describe detected interfaces as a human-readable summary.
+ */
+export function describeInterfaces(interfaces) {
+  const lines = [];
+  const names = Object.keys(interfaces);
+
+  if (names.length === 0) {
+    return 'No interfaces detected.';
+  }
+
+  if (interfaces.cli) {
+    const bins = typeof interfaces.cli.bin === 'string' ? [interfaces.cli.name] : Object.keys(interfaces.cli.bin);
+    lines.push(`CLI: ${bins.join(', ')}`);
+  }
+  if (interfaces.module) lines.push(`Module: ${JSON.stringify(interfaces.module.main)}`);
+  if (interfaces.mcp) lines.push(`MCP Server: ${interfaces.mcp.file}`);
+  if (interfaces.openclaw) lines.push(`OpenClaw Plugin: ${interfaces.openclaw.config?.name || 'detected'}`);
+  if (interfaces.skill) lines.push(`Skill: SKILL.md`);
+  if (interfaces.claudeCodeHook) lines.push(`Claude Code Hook: ${interfaces.claudeCodeHook.event || 'PreToolUse'}`);
+
+  return `${names.length} interface(s): ${names.join(', ')}\n${lines.map(l => `  ${l}`).join('\n')}`;
+}
+
+/**
+ * Detect if a repo is a toolbox (has tools/ subdirectories with package.json).
+ * Returns array of { name, path } for each sub-tool, or empty array if not a toolbox.
+ */
+export function detectToolbox(repoPath) {
+  const toolsDir = join(repoPath, 'tools');
+  if (!existsSync(toolsDir)) return [];
+
+  try {
+    const entries = readdirSync(toolsDir, { withFileTypes: true });
+    return entries
+      .filter(e => e.isDirectory() && existsSync(join(toolsDir, e.name, 'package.json')))
+      .map(e => ({ name: e.name, path: join(toolsDir, e.name) }));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Detect interfaces and return a structured JSON-serializable result.
+ */
+export function detectInterfacesJSON(repoPath) {
+  const { interfaces, pkg } = detectInterfaces(repoPath);
+  return {
+    repo: basename(repoPath),
+    package: pkg?.name || null,
+    version: pkg?.version || null,
+    interfaces: Object.fromEntries(
+      Object.entries(interfaces).map(([type, info]) => [type, {
+        detected: true,
+        ...info,
+      }])
+    ),
+    interfaceCount: Object.keys(interfaces).length,
+  };
+}

package/tools/wip-universal-installer/examples/minimal/README.md

@@ -0,0 +1,20 @@
+# Minimal Universal Interface Template
+
+The smallest possible agent-native tool. Four files, four interfaces.
+
+```
+core.mjs         ← your logic
+cli.mjs          ← thin CLI wrapper
+mcp-server.mjs   ← MCP server
+SKILL.md         ← agent instructions
+package.json     ← name, bin, exports
+```
+
+Copy this folder, rename everything, replace `hello()` with your functions.
+
+## Test it
+
+```bash
+node cli.mjs world       # Hello, world!
+wip-install --dry-run .  # Detected 4 interface(s): cli, module, mcp, skill
+```

package/tools/wip-universal-installer/examples/minimal/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: my-tool
+version: 1.0.0
+description: A minimal example tool.
+metadata:
+  category: example
+  capabilities:
+    - hello
+author:
+  name: Your Name
+---
+
+# my-tool
+
+A minimal example of the six-door pattern.
+
+## When to Use This Skill
+
+Use `hello` when you need to greet someone.
+
+## API Reference
+
+### hello(options)
+
+```javascript
+import { hello } from './core.mjs';
+hello({ name: 'world' }); // "Hello, world!"
+```

package/tools/wip-universal-installer/examples/minimal/cli.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { hello } from './core.mjs';
+const name = process.argv[2];
+console.log(hello({ name }));

package/tools/wip-universal-installer/examples/minimal/core.mjs

@@ -0,0 +1,8 @@
+/**
+ * Minimal six-door tool template.
+ * Replace this with your actual logic.
+ */
+
+export function hello({ name = 'world' } = {}) {
+  return `Hello, ${name}!`;
+}

package/tools/wip-universal-installer/examples/minimal/mcp-server.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { hello } from './core.mjs';
+
+const server = new Server(
+  { name: 'my-tool', version: '1.0.0' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler({ method: 'tools/list' }, async () => ({
+  tools: [{
+    name: 'hello',
+    description: 'Say hello',
+    inputSchema: {
+      type: 'object',
+      properties: { name: { type: 'string' } },
+    },
+  }],
+}));
+
+server.setRequestHandler({ method: 'tools/call' }, async (req) => ({
+  content: [{ type: 'text', text: hello(req.params.arguments) }],
+}));
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/tools/wip-universal-installer/examples/minimal/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "my-tool",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "core.mjs",
+  "bin": {
+    "my-tool": "./cli.mjs"
+  },
+  "exports": {
+    ".": "./core.mjs"
+  }
+}