gm-skill 0.1.1 → 0.1.2

package/lib/git.js

@@ -0,0 +1,332 @@
+const net = require('net');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const GIT_USER = 'lanmower';
+const GIT_EMAIL = 'almagestfraternite@gmail.com';
+
+function emitGitEvent(severity, message, data = {}) {
+  const logDir = path.join(os.homedir(), '.claude', 'gm-log', new Date().toISOString().split('T')[0]);
+  if (!fs.existsSync(logDir)) {
+    try { fs.mkdirSync(logDir, { recursive: true }); } catch (e) {}
+  }
+  const logFile = path.join(logDir, 'git.jsonl');
+  try {
+    fs.appendFileSync(logFile, JSON.stringify({
+      ts: new Date().toISOString(),
+      subsystem: 'git',
+      severity,
+      message,
+      ...data,
+    }) + '\n');
+  } catch (e) {}
+}
+
+function escapeShellArg(arg) {
+  if (os.platform() === 'win32') {
+    if (!arg) return '""';
+    if (/^[a-zA-Z0-9._\-/:=\\]+$/.test(arg)) return arg;
+    return '"' + arg.replace(/"/g, '\\"').replace(/\$/g, '\\$').replace(/`/g, '\\`') + '"';
+  }
+  if (!arg) return "''";
+  if (/^[a-zA-Z0-9._\-/:=]+$/.test(arg)) return arg;
+  return "'" + arg.replace(/'/g, "'\"'\"'") + "'";
+}
+
+function parseGitStatus(porcelain) {
+  const isDirty = porcelain.trim().length > 0;
+  const lines = porcelain.trim().split('\n').filter(l => l.length > 0);
+  const modified = lines.filter(l => /^[ AM][MD]/.test(l)).map(l => l.substring(3));
+  const untracked = lines.filter(l => /^\?\?/.test(l)).map(l => l.substring(3));
+  const deleted = lines.filter(l => /^[ A]D/.test(l)).map(l => l.substring(3));
+  return { isDirty, modified, untracked, deleted, all: modified.concat(untracked, deleted) };
+}
+
+async function sendSpoolRequest(lang, code, timeoutMs = 30000) {
+  const gmDir = path.join(process.cwd(), '.gm');
+  const spoolIn = path.join(gmDir, 'exec-spool', 'in', lang);
+  const spoolOut = path.join(gmDir, 'exec-spool', 'out');
+
+  if (!fs.existsSync(spoolIn)) {
+    try { fs.mkdirSync(spoolIn, { recursive: true }); } catch (e) {}
+  }
+
+  let taskId = '';
+  try {
+    taskId = fs.readdirSync(spoolOut).filter(f => f.endsWith('.json')).length + 1;
+  } catch (e) {
+    taskId = Math.random().toString(36).substring(7);
+  }
+
+  const ext = lang === 'bash' ? 'sh' : 'js';
+  const inPath = path.join(spoolIn, `${taskId}.${ext}`);
+  const outPath = path.join(spoolOut, `${taskId}.out`);
+  const errPath = path.join(spoolOut, `${taskId}.err`);
+  const jsonPath = path.join(spoolOut, `${taskId}.json`);
+
+  try {
+    fs.writeFileSync(inPath, code, 'utf8');
+  } catch (e) {
+    emitGitEvent('error', 'Could not write spool file', { path: inPath, error: e.message });
+    throw new Error(`Could not write spool request: ${e.message}`);
+  }
+
+  const startTime = Date.now();
+  const deadline = startTime + timeoutMs;
+
+  while (Date.now() < deadline) {
+    if (fs.existsSync(jsonPath)) {
+      try {
+        const metadata = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
+        const stdout = fs.existsSync(outPath) ? fs.readFileSync(outPath, 'utf8') : '';
+        const stderr = fs.existsSync(errPath) ? fs.readFileSync(errPath, 'utf8') : '';
+        return { ok: !metadata.timedOut && metadata.exitCode === 0, stdout, stderr, exitCode: metadata.exitCode, durationMs: metadata.durationMs };
+      } catch (e) {
+        emitGitEvent('error', 'Could not parse spool response', { path: jsonPath, error: e.message });
+      }
+    }
+    await new Promise(r => setTimeout(r, 100));
+  }
+
+  throw new Error(`Spool request timed out after ${timeoutMs}ms`);
+}
+
+async function commit(message, files = [], sessionId = 'unknown') {
+  emitGitEvent('info', 'commit() called', { message: message.substring(0, 72), fileCount: files.length, sessionId });
+
+  if (!message || message.trim().length === 0) {
+    emitGitEvent('error', 'commit message required', { sessionId });
+    throw new Error('Commit message required');
+  }
+
+  const summary = message.split('\n')[0];
+  if (summary.length > 72) {
+    emitGitEvent('warn', 'commit summary exceeds 72 chars', { length: summary.length, sessionId });
+  }
+
+  const filesToStage = files && files.length > 0 ? files : ['.'];
+  const stageCmd = filesToStage.map(f => `git add ${escapeShellArg(f)}`).join(' && ');
+  const commitMsg = message.replace(/"/g, '\\"').replace(/\$/g, '\\$').replace(/`/g, '\\`');
+  const commitCmd = `git -c user.name=${escapeShellArg(GIT_USER)} -c user.email=${escapeShellArg(GIT_EMAIL)} commit -m "${commitMsg}"`;
+
+  const script = `${stageCmd} && ${commitCmd}`;
+
+  try {
+    const result = await sendSpoolRequest('bash', script, 30000);
+    if (!result.ok) {
+      const err = result.stderr || result.stdout || 'unknown error';
+      emitGitEvent('error', 'commit failed', { error: err.substring(0, 200), sessionId });
+      throw new Error(`Commit failed: ${err}`);
+    }
+    emitGitEvent('info', 'commit succeeded', { message: summary, fileCount: files.length, sessionId });
+    return { ok: true, message: summary };
+  } catch (e) {
+    emitGitEvent('error', 'commit error', { error: e.message, sessionId });
+    throw e;
+  }
+}
+
+async function push(branch = 'main', sessionId = 'unknown') {
+  emitGitEvent('info', 'push() called', { branch, sessionId });
+
+  const pushCmd = `git push origin ${escapeShellArg(branch)} 2>&1`;
+
+  try {
+    const result = await sendSpoolRequest('bash', pushCmd, 60000);
+    if (!result.ok || result.stderr.includes('fatal') || result.stdout.includes('fatal')) {
+      const err = result.stderr || result.stdout || 'unknown error';
+
+      if (err.includes('remote: error') || err.includes('Permission denied')) {
+        emitGitEvent('error', 'push auth failed', { branch, sessionId });
+        throw new Error(`Push authentication failed. Check credentials for branch: ${branch}\n${err}`);
+      }
+      if (err.includes('no changes added') || err.includes('nothing to commit')) {
+        emitGitEvent('info', 'push: nothing to push', { branch, sessionId });
+        return { ok: true, message: 'nothing to push' };
+      }
+      emitGitEvent('error', 'push failed', { error: err.substring(0, 200), branch, sessionId });
+      throw new Error(`Push failed: ${err}`);
+    }
+    emitGitEvent('info', 'push succeeded', { branch, sessionId });
+    return { ok: true, message: `pushed ${branch}` };
+  } catch (e) {
+    emitGitEvent('error', 'push error', { error: e.message, branch, sessionId });
+    throw e;
+  }
+}
+
+async function status(sessionId = 'unknown') {
+  emitGitEvent('info', 'status() called', { sessionId });
+
+  const statusCmd = 'git status --porcelain';
+
+  try {
+    const result = await sendSpoolRequest('bash', statusCmd, 10000);
+    if (!result.ok) {
+      emitGitEvent('error', 'status failed', { error: result.stderr, sessionId });
+      throw new Error(`Status check failed: ${result.stderr}`);
+    }
+
+    const parsed = parseGitStatus(result.stdout);
+    emitGitEvent('info', 'status retrieved', { isDirty: parsed.isDirty, modifiedCount: parsed.modified.length, sessionId });
+    return { ok: true, ...parsed };
+  } catch (e) {
+    emitGitEvent('error', 'status error', { error: e.message, sessionId });
+    throw e;
+  }
+}
+
+async function diff(sessionId = 'unknown') {
+  emitGitEvent('info', 'diff() called', { sessionId });
+
+  const diffCmd = 'git diff HEAD';
+
+  try {
+    const result = await sendSpoolRequest('bash', diffCmd, 30000);
+    if (!result.ok && !result.stdout) {
+      emitGitEvent('error', 'diff failed', { error: result.stderr, sessionId });
+      throw new Error(`Diff failed: ${result.stderr}`);
+    }
+
+    emitGitEvent('info', 'diff retrieved', { hasChanges: result.stdout.length > 0, sessionId });
+    return { ok: true, diff: result.stdout };
+  } catch (e) {
+    emitGitEvent('error', 'diff error', { error: e.message, sessionId });
+    throw e;
+  }
+}
+
+async function log(sessionId = 'unknown', count = 10) {
+  emitGitEvent('info', 'log() called', { count, sessionId });
+
+  const logCmd = `git log -${count} --oneline`;
+
+  try {
+    const result = await sendSpoolRequest('bash', logCmd, 10000);
+    if (!result.ok) {
+      emitGitEvent('error', 'log failed', { error: result.stderr, sessionId });
+      throw new Error(`Log failed: ${result.stderr}`);
+    }
+
+    const commits = result.stdout.trim().split('\n').filter(l => l.length > 0);
+    emitGitEvent('info', 'log retrieved', { commitCount: commits.length, sessionId });
+    return { ok: true, commits };
+  } catch (e) {
+    emitGitEvent('error', 'log error', { error: e.message, sessionId });
+    throw e;
+  }
+}
+
+async function checkout(branch, sessionId = 'unknown') {
+  emitGitEvent('info', 'checkout() called', { branch, sessionId });
+
+  if (!branch || branch.trim().length === 0) {
+    emitGitEvent('error', 'branch name required', { sessionId });
+    throw new Error('Branch name required');
+  }
+
+  const checkCmd = `git rev-parse --verify ${escapeShellArg(branch)} 2>&1`;
+
+  try {
+    const checkResult = await sendSpoolRequest('bash', checkCmd, 10000);
+    if (!checkResult.ok || checkResult.stderr.includes('fatal') || checkResult.stdout.includes('fatal')) {
+      emitGitEvent('error', 'checkout: branch not found', { branch, sessionId });
+      throw new Error(`Branch not found: ${branch}`);
+    }
+
+    const checkoutCmd = `git checkout ${escapeShellArg(branch)}`;
+    const result = await sendSpoolRequest('bash', checkoutCmd, 10000);
+
+    if (!result.ok) {
+      emitGitEvent('error', 'checkout failed', { error: result.stderr, branch, sessionId });
+      throw new Error(`Checkout failed: ${result.stderr}`);
+    }
+
+    emitGitEvent('info', 'checkout succeeded', { branch, sessionId });
+    return { ok: true, branch };
+  } catch (e) {
+    emitGitEvent('error', 'checkout error', { error: e.message, branch, sessionId });
+    throw e;
+  }
+}
+
+async function rebase(upstream, sessionId = 'unknown') {
+  emitGitEvent('info', 'rebase() called', { upstream, sessionId });
+
+  if (!upstream || upstream.trim().length === 0) {
+    emitGitEvent('error', 'upstream branch required', { sessionId });
+    throw new Error('Upstream branch required');
+  }
+
+  const rebaseCmd = `git rebase ${escapeShellArg(upstream)} 2>&1`;
+
+  try {
+    const result = await sendSpoolRequest('bash', rebaseCmd, 60000);
+
+    if (result.stderr.includes('CONFLICT') || result.stdout.includes('CONFLICT')) {
+      emitGitEvent('warn', 'rebase: conflicts detected', { upstream, sessionId });
+      const statusCmd = 'git status --porcelain';
+      const statusResult = await sendSpoolRequest('bash', statusCmd, 10000);
+      const conflicts = statusResult.stdout.split('\n').filter(l => l.startsWith('UU') || l.startsWith('AA') || l.startsWith('DD'));
+      return { ok: false, conflicts: true, conflictFiles: conflicts, message: 'Rebase halted due to conflicts. Resolve conflicts and run git rebase --continue' };
+    }
+
+    if (!result.ok) {
+      emitGitEvent('error', 'rebase failed', { error: result.stderr, upstream, sessionId });
+      throw new Error(`Rebase failed: ${result.stderr}`);
+    }
+
+    emitGitEvent('info', 'rebase succeeded', { upstream, sessionId });
+    return { ok: true, upstream };
+  } catch (e) {
+    emitGitEvent('error', 'rebase error', { error: e.message, upstream, sessionId });
+    throw e;
+  }
+}
+
+async function cherryPick(commit, sessionId = 'unknown') {
+  emitGitEvent('info', 'cherryPick() called', { commit, sessionId });
+
+  if (!commit || commit.trim().length === 0) {
+    emitGitEvent('error', 'commit hash required', { sessionId });
+    throw new Error('Commit hash required');
+  }
+
+  const pickCmd = `git cherry-pick ${escapeShellArg(commit)} 2>&1`;
+
+  try {
+    const result = await sendSpoolRequest('bash', pickCmd, 60000);
+
+    if (result.stderr.includes('CONFLICT') || result.stdout.includes('CONFLICT')) {
+      emitGitEvent('warn', 'cherry-pick: conflicts detected', { commit, sessionId });
+      return { ok: false, conflicts: true, message: 'Cherry-pick halted due to conflicts. Resolve conflicts and run git cherry-pick --continue' };
+    }
+
+    if (!result.ok) {
+      emitGitEvent('error', 'cherry-pick failed', { error: result.stderr, commit, sessionId });
+      throw new Error(`Cherry-pick failed: ${result.stderr}`);
+    }
+
+    emitGitEvent('info', 'cherry-pick succeeded', { commit, sessionId });
+    return { ok: true, commit };
+  } catch (e) {
+    emitGitEvent('error', 'cherry-pick error', { error: e.message, commit, sessionId });
+    throw e;
+  }
+}
+
+module.exports = {
+  commit,
+  push,
+  status,
+  diff,
+  log,
+  checkout,
+  rebase,
+  cherryPick,
+  escapeShellArg,
+  parseGitStatus,
+  GIT_USER,
+  GIT_EMAIL,
+};

package/lib/index.js

@@ -0,0 +1,37 @@
+const daemon = require('./daemon-bootstrap.js');
+const manifest = require('./manifest.js');
+const loader = require('./loader.js');
+const prepareModule = require('./prepare.js');
+
+function getSkills() {
+  return manifest.getAllSkills();
+}
+
+function getSkill(name) {
+  return manifest.getSkill(name);
+}
+
+function loadSkill(skillName, baseDir) {
+  return loader.dynamicLoadSkill(skillName, baseDir);
+}
+
+function bootstrapDaemon(daemonName, cmd) {
+  return daemon.spawnDaemon(daemonName, cmd);
+}
+
+module.exports = {
+  getSkills: getSkills,
+  getSkill: getSkill,
+  loadSkill: loadSkill,
+  bootstrapDaemon: bootstrapDaemon,
+  checkState: daemon.checkState,
+  waitForReady: daemon.waitForReady,
+  getSocket: daemon.getSocket,
+  shutdown: daemon.shutdown,
+  emitEvent: daemon.emitEvent,
+  isDaemonRunning: daemon.isDaemonRunning,
+  checkPortReachable: daemon.checkPortReachable,
+  manifest: manifest,
+  loader: loader,
+  prepare: prepareModule.prepare
+};

package/lib/loader.js

@@ -0,0 +1,66 @@
+const path = require('path');
+const fs = require('fs');
+
+function loadSkill(skillName, skillPath) {
+  if (!fs.existsSync(skillPath)) {
+    throw new Error(`Skill path does not exist: ${skillPath}`);
+  }
+
+  const indexPath = path.join(skillPath, 'index.js');
+  if (!fs.existsSync(indexPath)) {
+    throw new Error(`Skill index.js not found at ${indexPath}`);
+  }
+
+  try {
+    const skillModule = require(indexPath);
+    return skillModule;
+  } catch (e) {
+    throw new Error(`Failed to load skill ${skillName} from ${indexPath}: ${e.message}`);
+  }
+}
+
+function dynamicLoadSkill(skillName, baseDir) {
+  const searchDirs = [];
+
+  if (baseDir) {
+    searchDirs.push(path.join(baseDir, 'skills', skillName));
+  }
+
+  searchDirs.push(path.join(__dirname, '..', 'skills', skillName));
+  searchDirs.push(path.join(__dirname, '..', '..', 'gm-starter', 'skills', skillName));
+  searchDirs.push(path.join(process.cwd(), 'skills', skillName));
+
+  for (const searchDir of searchDirs) {
+    if (fs.existsSync(searchDir)) {
+      return loadSkill(skillName, searchDir);
+    }
+  }
+
+  throw new Error(`Skill "${skillName}" not found in any search directory: ${searchDirs.join(', ')}`);
+}
+
+function getSkillPath(skillName, baseDir) {
+  const searchDirs = [];
+
+  if (baseDir) {
+    searchDirs.push(path.join(baseDir, 'skills', skillName));
+  }
+
+  searchDirs.push(path.join(__dirname, '..', 'skills', skillName));
+  searchDirs.push(path.join(__dirname, '..', '..', 'gm-starter', 'skills', skillName));
+  searchDirs.push(path.join(process.cwd(), 'skills', skillName));
+
+  for (const searchDir of searchDirs) {
+    if (fs.existsSync(searchDir)) {
+      return searchDir;
+    }
+  }
+
+  return null;
+}
+
+module.exports = {
+  loadSkill,
+  dynamicLoadSkill,
+  getSkillPath
+};

package/lib/manifest.js

@@ -30,17 +30,20 @@ function parseSkillMarkdown(content) {
 }
 
 function readSkillManifest(skillName) {
-  const skillMdPath = path.join(
-    __dirname,
-    '..',
-    '..',
-    'gm-starter',
-    'skills',
-    skillName,
-    'SKILL.md'
-  );
-
-  if (!fs.existsSync(skillMdPath)) {
+  const searchPaths = [
+    path.join(__dirname, '..', 'skills', skillName, 'SKILL.md'),
+    path.join(__dirname, '..', '..', 'gm-starter', 'skills', skillName, 'SKILL.md')
+  ];
+
+  let skillMdPath = null;
+  for (const p of searchPaths) {
+    if (fs.existsSync(p)) {
+      skillMdPath = p;
+      break;
+    }
+  }
+
+  if (!skillMdPath) {
     return {
       name: skillName,
       description: '',
@@ -69,7 +72,7 @@ function readSkillManifest(skillName) {
 }
 
 function getManifest() {
-  const skills = ['gm', 'gm-execute', 'gm-emit', 'gm-complete'];
+  const skills = ['gm', 'planning', 'gm-execute', 'gm-emit', 'gm-complete', 'update-docs'];
   return {
     name: 'gm-skill',
     version: '1.0.0',
@@ -83,7 +86,7 @@ function getSkill(name) {
 }
 
 function getAllSkills() {
-  const skills = ['gm', 'gm-execute', 'gm-emit', 'gm-complete'];
+  const skills = ['gm', 'planning', 'gm-execute', 'gm-emit', 'gm-complete', 'update-docs'];
   return skills.map(name => readSkillManifest(name));
 }
 

package/lib/prepare.js

@@ -0,0 +1,14 @@
+async function prepare(options = {}) {
+  const sessionId = options.sessionId || process.env.CLAUDE_SESSION_ID || 'default';
+  const cwd = options.cwd || process.cwd();
+
+  return {
+    sessionId,
+    cwd,
+    initialized: true
+  };
+}
+
+module.exports = {
+  prepare
+};

package/lib/spool.js

@@ -0,0 +1,163 @@
+const fs = require('fs');
+const path = require('path');
+
+function getSpoolBaseDir() {
+  return path.join(process.cwd(), '.gm', 'exec-spool');
+}
+
+function generateTaskId() {
+  return `${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
+}
+
+function validateLang(lang) {
+  const valid = ['nodejs', 'python', 'bash', 'typescript', 'go', 'rust', 'c', 'cpp', 'java', 'deno'];
+  return valid.includes(lang) ? lang : 'nodejs';
+}
+
+function getExtForLang(lang) {
+  const langExt = {
+    nodejs: 'js', python: 'py', bash: 'sh', typescript: 'ts', go: 'go',
+    rust: 'rs', c: 'c', cpp: 'cpp', java: 'java', deno: 'ts'
+  };
+  return langExt[lang] || 'js';
+}
+
+function validateVerb(verb) {
+  const valid = ['codesearch', 'recall', 'memorize', 'wait', 'sleep', 'status', 'close', 'browser', 'runner', 'type', 'kill-port', 'forget', 'feedback', 'learn-status', 'learn-debug', 'learn-build', 'discipline', 'pause', 'health'];
+  return valid.includes(verb) ? verb : 'status';
+}
+
+function writeSpool(body, lang = 'nodejs', options = {}) {
+  const validLang = validateLang(lang);
+  const taskId = options.taskId || generateTaskId();
+  const inDir = path.join(getSpoolBaseDir(), 'in', validLang);
+  const inFile = path.join(inDir, `${taskId}.${getExtForLang(validLang)}`);
+
+  fs.mkdirSync(inDir, { recursive: true });
+
+  const sessionId = options.sessionId || process.env.CLAUDE_SESSION_ID;
+  const code = sessionId ? `const SESSION_ID = '${sessionId}';\n${body}` : body;
+  fs.writeFileSync(inFile, code, 'utf8');
+
+  return { id: taskId, path: inFile, lang: validLang, ext: getExtForLang(validLang) };
+}
+
+function writeSpoolVerb(body, verb, options = {}) {
+  const validVerb = validateVerb(verb);
+  const taskId = options.taskId || generateTaskId();
+  const inDir = path.join(getSpoolBaseDir(), 'in', validVerb);
+  const inFile = path.join(inDir, `${taskId}.txt`);
+
+  fs.mkdirSync(inDir, { recursive: true });
+  fs.writeFileSync(inFile, body, 'utf8');
+  return { id: taskId, path: inFile, verb: validVerb };
+}
+
+function readSpoolOutput(id) {
+  const outDir = path.join(getSpoolBaseDir(), 'out');
+  const outFile = path.join(outDir, `${id}.out`);
+  const errFile = path.join(outDir, `${id}.err`);
+  const jsonFile = path.join(outDir, `${id}.json`);
+
+  const stdout = fs.existsSync(outFile) ? fs.readFileSync(outFile, 'utf8') : '';
+  const stderr = fs.existsSync(errFile) ? fs.readFileSync(errFile, 'utf8') : '';
+
+  let metadata = {};
+  if (fs.existsSync(jsonFile)) {
+    try {
+      metadata = JSON.parse(fs.readFileSync(jsonFile, 'utf8'));
+    } catch (e) {
+      metadata = { error: 'Failed to parse metadata' };
+    }
+  }
+
+  return {
+    id, stdout, stderr, metadata,
+    exitCode: metadata.exitCode,
+    durationMs: metadata.durationMs,
+    timedOut: metadata.timedOut || false
+  };
+}
+
+async function waitForCompletion(id, timeoutMs = 30000) {
+  const jsonFile = path.join(getSpoolBaseDir(), 'out', `${id}.json`);
+  const start = Date.now();
+
+  while (Date.now() - start < timeoutMs) {
+    if (fs.existsSync(jsonFile)) {
+      try {
+        const metadata = JSON.parse(fs.readFileSync(jsonFile, 'utf8'));
+        const output = readSpoolOutput(id);
+        return { ok: metadata.exitCode === 0 && !metadata.timedOut, ...output };
+      } catch (e) {
+        await new Promise(r => setTimeout(r, 50));
+      }
+    } else {
+      await new Promise(r => setTimeout(r, 50));
+    }
+  }
+
+  const output = readSpoolOutput(id);
+  return { ok: false, ...output, timedOut: true, stderr: output.stderr + `\n[timeout ${timeoutMs}ms]` };
+}
+
+async function execSpool(body, lang, options = {}) {
+  const timeoutMs = options.timeoutMs || 30000;
+  const sessionId = options.sessionId || process.env.CLAUDE_SESSION_ID;
+  const task = lang === 'nodejs' || lang === 'bash' ? writeSpool(body, lang, { sessionId }) : writeSpoolVerb(body, lang, {});
+  const result = await waitForCompletion(task.id, timeoutMs);
+  if (options.cleanup !== false) {
+    try { fs.unlinkSync(task.path); } catch (e) {}
+  }
+  return result;
+}
+
+async function execNodejs(body, options = {}) {
+  return execSpool(body, 'nodejs', options);
+}
+
+async function execBash(body, options = {}) {
+  return execSpool(body, 'bash', options);
+}
+
+async function execCodesearch(query, options = {}) {
+  return execSpool(query, 'codesearch', options);
+}
+
+async function execRecall(query, options = {}) {
+  return execSpool(query, 'recall', options);
+}
+
+async function execMemorize(fact, options = {}) {
+  return execSpool(fact, 'memorize', options);
+}
+
+function getAllOutputs() {
+  const outDir = path.join(getSpoolBaseDir(), 'out');
+  if (!fs.existsSync(outDir)) return [];
+
+  const files = fs.readdirSync(outDir);
+  const taskIds = new Set();
+  files.forEach(file => {
+    const match = file.match(/^(.+?)\.(out|err|json)$/);
+    if (match) taskIds.add(match[1]);
+  });
+  return Array.from(taskIds).map(id => readSpoolOutput(id));
+}
+
+function cleanupTempFiles(taskId) {
+  const outDir = path.join(getSpoolBaseDir(), 'out');
+  ['.out', '.err', '.json'].forEach(ext => {
+    try {
+      const file = path.join(outDir, `${taskId}${ext}`);
+      if (fs.existsSync(file)) fs.unlinkSync(file);
+    } catch (e) {}
+  });
+}
+
+module.exports = {
+  writeSpool, writeSpoolVerb, readSpoolOutput, waitForCompletion,
+  execNodejs, execBash, execCodesearch, execRecall, execMemorize,
+  getAllOutputs, cleanupTempFiles, getSpoolBaseDir, generateTaskId,
+  validateLang, getExtForLang, validateVerb
+};

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "gm-skill",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Unified skill library for gm platform implementations",
-  "main": "index.js",
+  "main": "lib/index.js",
   "exports": {
-    ".": "./index.js",
+    ".": "./lib/index.js",
     "./daemon-bootstrap": "./lib/daemon-bootstrap.js",
-    "./manifest": "./lib/manifest.js"
+    "./manifest": "./lib/manifest.js",
+    "./prepare": "./lib/prepare.js",
+    "./loader": "./lib/loader.js"
   },
   "scripts": {
     "test": "node test.js"