gm-skill 0.1.0

package/README.md

@@ -0,0 +1,99 @@
+# gm-skill
+
+Unified skill library for gm platform implementations.
+
+## Installation
+
+```bash
+npm install gm-skill
+```
+
+## Usage
+
+### Daemon Bootstrap Functions
+
+```javascript
+const {
+  ensureRsLearningDaemonRunning,
+  ensureRsCodeinsightDaemonRunning,
+  ensureRsSearchDaemonRunning,
+  ensureAcptoapiRunning,
+  checkPortReachable
+} = require('gm-skill');
+```
+
+#### Functions
+
+- `ensureRsLearningDaemonRunning()` - Ensures rs-learn daemon is running
+- `ensureRsCodeinsightDaemonRunning()` - Ensures rs-codeinsight daemon is running
+- `ensureRsSearchDaemonRunning()` - Ensures rs-search daemon is running
+- `ensureAcptoapiRunning()` - Ensures acptoapi daemon is running
+- `checkPortReachable(host, port, timeoutMs)` - Check if a port is reachable
+
+All functions are async and return an object with `ok` and additional metadata.
+
+### Spool Dispatch Helpers
+
+```javascript
+const { spool } = require('gm-skill');
+const { writeSpool, readSpoolOutput, waitForCompletion, getAllOutputs } = spool;
+```
+
+#### Functions
+
+- `writeSpool(body, lang, options)` - Write code to spool input directory; returns `{ id, path, lang, ext }`
+  - `body` (string) - Code to execute
+  - `lang` (string, default: `'nodejs'`) - Language: nodejs, python, bash, typescript, go, rust, c, cpp, java, deno
+  - `options` (object, optional) - `{ taskId, sessionId }`
+- `readSpoolOutput(id)` - Read completed task output; returns `{ id, stdout, stderr, metadata, exitCode, durationMs, timedOut }`
+- `waitForCompletion(id, timeoutMs)` - Poll for task completion; returns promise with `{ ok, ...output }`
+- `getAllOutputs()` - Enumerate all completed tasks in spool directory; returns array of output objects
+
+All paths are platform-aware (Windows and POSIX compatible).
+
+#### Example
+
+```javascript
+const { spool } = require('gm-skill');
+
+const result = spool.writeSpool('console.log("hello")', 'nodejs');
+console.log(result.id);
+
+const output = await spool.waitForCompletion(result.id, 30000);
+console.log(output.stdout);
+```
+
+### Skill Manifests
+
+```javascript
+const { manifest } = require('gm-skill');
+const { getManifest, getSkill, getAllSkills } = manifest;
+```
+
+#### Functions
+
+- `getManifest()` - Get full package manifest with all 4 core skills; returns `{ name, version, description, skills: [...] }`
+- `getSkill(name)` - Get individual skill manifest by name (gm, gm-execute, gm-emit, gm-complete); returns skill object with metadata
+- `getAllSkills()` - Get array of all 4 core skills with full metadata; returns `[{ name, description, allowedTools, compatiblePlatforms, endToEnd, skillMdContent }, ...]`
+
+Skill metadata includes:
+- `name` - Skill identifier
+- `description` - Human-readable skill purpose
+- `allowedTools` - Array of tool names the skill permits
+- `compatiblePlatforms` - Array of platforms this skill targets
+- `endToEnd` - Boolean flag indicating end-to-end skill vs helper
+- `skillMdContent` - Full SKILL.md file content
+
+#### Example
+
+```javascript
+const { manifest } = require('gm-skill');
+
+const allSkills = manifest.getAllSkills();
+allSkills.forEach(skill => {
+  console.log(`${skill.name}: ${skill.description}`);
+});
+
+const gmSkill = manifest.getSkill('gm');
+console.log('Allowed tools:', gmSkill.allowedTools);
+```

package/index.js

@@ -0,0 +1,9 @@
+const daemonBootstrap = require('../gm-starter/lib/daemon-bootstrap.js');
+const spool = require('../gm-starter/lib/spool.js');
+const manifest = require('./lib/manifest.js');
+
+module.exports = {
+  ...daemonBootstrap,
+  spool,
+  manifest
+};

package/lib/manifest.js

@@ -0,0 +1,96 @@
+const fs = require('fs');
+const path = require('path');
+
+function parseSkillMarkdown(content) {
+  const normalized = content.replace(/\r\n/g, '\n');
+  const match = normalized.match(/^---\n([\s\S]*?)\n---/);
+
+  if (!match) return {};
+
+  const frontmatter = match[1];
+  const metadata = {};
+
+  frontmatter.split('\n').forEach(line => {
+    const colonIdx = line.indexOf(':');
+    if (colonIdx === -1) return;
+
+    const key = line.substring(0, colonIdx).trim();
+    const value = line.substring(colonIdx + 1).trim();
+
+    if (key === 'allowed-tools') {
+      metadata.allowedTools = value
+        .split(',')
+        .map(t => t.trim().replace(/^['\"]|['\"]$/g, ''));
+    } else {
+      metadata[key] = value;
+    }
+  });
+
+  return metadata;
+}
+
+function readSkillManifest(skillName) {
+  const skillMdPath = path.join(
+    __dirname,
+    '..',
+    '..',
+    'gm-starter',
+    'skills',
+    skillName,
+    'SKILL.md'
+  );
+
+  if (!fs.existsSync(skillMdPath)) {
+    return {
+      name: skillName,
+      description: '',
+      allowedTools: [],
+      compatiblePlatforms: [],
+      endToEnd: false,
+      skillMdContent: ''
+    };
+  }
+
+  const content = fs.readFileSync(skillMdPath, 'utf8');
+  const metadata = parseSkillMarkdown(content);
+
+  return {
+    name: metadata.name || skillName,
+    description: metadata.description || '',
+    version: metadata.version || '1.0.0',
+    category: metadata.category || 'skill',
+    allowedTools: metadata.allowedTools || [],
+    compatiblePlatforms: metadata['compatible-platforms']
+      ? metadata['compatible-platforms'].split(',').map(p => p.trim())
+      : [],
+    endToEnd: metadata['end-to-end'] === 'true',
+    skillMdContent: content
+  };
+}
+
+function getManifest() {
+  const skills = ['gm', 'gm-execute', 'gm-emit', 'gm-complete'];
+  return {
+    name: 'gm-skill',
+    version: '1.0.0',
+    description: 'gm skill manifest and daemon bootstrap integration',
+    skills: skills.map(name => readSkillManifest(name))
+  };
+}
+
+function getSkill(name) {
+  return readSkillManifest(name);
+}
+
+function getAllSkills() {
+  const skills = ['gm', 'gm-execute', 'gm-emit', 'gm-complete'];
+  return skills.map(name => readSkillManifest(name));
+}
+
+module.exports = {
+  getManifest,
+  getSkill,
+  getAllSkills,
+  parseSkillMarkdown,
+  readSkillManifest
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "gm-skill",
+  "version": "0.1.0",
+  "description": "Unified skill library for gm platform implementations",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./daemon-bootstrap": "./index.js",
+    "./manifest": "./lib/manifest.js"
+  },
+  "scripts": {
+    "test": "node test.js"
+  },
+  "keywords": [
+    "gm",
+    "skills",
+    "daemon",
+    "bootstrap"
+  ],
+  "author": "AnEntrypoint",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AnEntrypoint/gm.git"
+  },
+  "homepage": "https://github.com/AnEntrypoint/gm#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/test.js

@@ -0,0 +1,89 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const assert = require('assert');
+const { spool } = require('./index.js');
+
+const testDir = path.join(os.tmpdir(), 'gm-skill-test');
+
+function cleanup() {
+  if (fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true });
+  }
+}
+
+async function runTests() {
+  cleanup();
+  process.chdir(testDir);
+  fs.mkdirSync(testDir, { recursive: true });
+
+  console.log('Testing spool.writeSpool...');
+  const writeResult = spool.writeSpool('console.log("test output")', 'nodejs');
+  assert(writeResult.id, 'writeSpool returns id');
+  assert(writeResult.path, 'writeSpool returns path');
+  assert(writeResult.lang === 'nodejs', 'writeSpool returns correct lang');
+  assert(writeResult.ext === 'js', 'writeSpool returns correct ext');
+  assert(fs.existsSync(writeResult.path), 'spool file created on disk');
+  const fileContent = fs.readFileSync(writeResult.path, 'utf-8');
+  assert(fileContent.includes('console.log("test output")'), 'spool file contains body');
+  console.log('✓ writeSpool works');
+
+  console.log('\nTesting spool.readSpoolOutput (empty case)...');
+  const nonExistentId = 'does-not-exist';
+  const emptyRead = spool.readSpoolOutput(nonExistentId);
+  assert.strictEqual(emptyRead.id, nonExistentId, 'readSpoolOutput returns id');
+  assert.strictEqual(emptyRead.stdout, '', 'readSpoolOutput returns empty stdout when no output');
+  assert.strictEqual(emptyRead.stderr, '', 'readSpoolOutput returns empty stderr when no output');
+  assert(emptyRead.metadata, 'readSpoolOutput returns metadata object');
+  console.log('✓ readSpoolOutput handles missing files gracefully');
+
+  console.log('\nTesting spool.getAllOutputs...');
+  const baseDir = spool.getSpoolBaseDir();
+  const outDir = path.join(baseDir, 'out');
+  fs.mkdirSync(outDir, { recursive: true });
+
+  fs.writeFileSync(path.join(outDir, 'task1.out'), 'output1');
+  fs.writeFileSync(path.join(outDir, 'task1.json'), JSON.stringify({ exitCode: 0 }));
+  fs.writeFileSync(path.join(outDir, 'task2.err'), 'error2');
+  fs.writeFileSync(path.join(outDir, 'task2.json'), JSON.stringify({ exitCode: 1 }));
+
+  const allOutputs = spool.getAllOutputs();
+  assert(allOutputs.length === 2, 'getAllOutputs returns 2 tasks');
+  const ids = allOutputs.map(o => o.id).sort();
+  assert(ids.includes('task1') && ids.includes('task2'), 'getAllOutputs returns correct task ids');
+  const task1 = allOutputs.find(o => o.id === 'task1');
+  assert(task1.stdout === 'output1', 'getAllOutputs includes stdout');
+  const task2 = allOutputs.find(o => o.id === 'task2');
+  assert(task2.stderr === 'error2', 'getAllOutputs includes stderr');
+  console.log('✓ getAllOutputs enumerates completed tasks');
+
+  console.log('\nTesting spool.waitForCompletion (timeout)...');
+  const timeoutResult = await spool.waitForCompletion('instant-timeout', 100);
+  assert(timeoutResult.timedOut === true, 'waitForCompletion times out gracefully');
+  assert(timeoutResult.ok === false, 'waitForCompletion returns ok:false on timeout');
+  console.log('✓ waitForCompletion respects timeout');
+
+  console.log('\nTesting spool helpers with different languages...');
+  const pyResult = spool.writeSpool('print("hello")', 'python');
+  assert(pyResult.ext === 'py', 'writeSpool maps python to .py');
+  const tsResult = spool.writeSpool('console.log()', 'typescript');
+  assert(tsResult.ext === 'ts', 'writeSpool maps typescript to .ts');
+  const bashResult = spool.writeSpool('echo hello', 'bash');
+  assert(bashResult.ext === 'sh', 'writeSpool maps bash to .sh');
+  console.log('✓ writeSpool handles language variants');
+
+  console.log('\nTesting platform-aware paths...');
+  const baseDir2 = spool.getSpoolBaseDir();
+  assert(baseDir2, 'getSpoolBaseDir returns a path');
+  assert(baseDir2.includes('.gm'), 'spool path contains .gm directory');
+  console.log('✓ Platform paths are set correctly');
+
+  cleanup();
+  console.log('\n✓✓✓ All tests passed ✓✓✓');
+}
+
+runTests().catch(e => {
+  console.error('Test failed:', e.message);
+  cleanup();
+  process.exit(1);
+});