openclaw-node-harness 2.0.0

package/skills/capability-evolver/scripts/build_public.js

@@ -0,0 +1,350 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function rmDir(dir) {
+  if (!fs.existsSync(dir)) return;
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+function normalizePosix(p) {
+  return p.split(path.sep).join('/');
+}
+
+function isUnder(child, parent) {
+  const rel = path.relative(parent, child);
+  return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+function listFilesRec(dir) {
+  const out = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const ent of entries) {
+    const p = path.join(dir, ent.name);
+    if (ent.isDirectory()) out.push(...listFilesRec(p));
+    else if (ent.isFile()) out.push(p);
+  }
+  return out;
+}
+
+function globToRegex(glob) {
+  // Supports "*" within a single segment and "**" for any depth.
+  const norm = normalizePosix(glob);
+  const parts = norm.split('/').filter(p => p.length > 0);
+  const out = [];
+
+  for (const part of parts) {
+    if (part === '**') {
+      // any number of path segments
+      out.push('(?:.*)');
+      continue;
+    }
+    // Escape regex special chars, then expand "*" wildcards within segment.
+    const esc = part.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '[^/]*');
+    out.push(esc);
+  }
+
+  const re = out.join('\\/');
+  return new RegExp(`^${re}$`);
+}
+
+function matchesAnyGlobs(relPath, globs) {
+  const p = normalizePosix(relPath);
+  for (const g of globs || []) {
+    const re = globToRegex(g);
+    if (re.test(p)) return true;
+  }
+  return false;
+}
+
+function copyFile(srcAbs, destAbs) {
+  ensureDir(path.dirname(destAbs));
+  fs.copyFileSync(srcAbs, destAbs);
+}
+
+function copyEntry(spec, outDirAbs) {
+  const copied = [];
+
+  // Directory glob
+  if (spec.includes('*')) {
+    const all = listFilesRec(REPO_ROOT);
+    const includeRe = globToRegex(spec);
+    for (const abs of all) {
+      const rel = normalizePosix(path.relative(REPO_ROOT, abs));
+      if (!includeRe.test(rel)) continue;
+      const destAbs = path.join(outDirAbs, rel);
+      copyFile(abs, destAbs);
+      copied.push(rel);
+    }
+    return copied;
+  }
+
+  const srcAbs = path.join(REPO_ROOT, spec);
+  if (!fs.existsSync(srcAbs)) return [];
+
+  const st = fs.statSync(srcAbs);
+  if (st.isFile()) {
+    const rel = normalizePosix(spec);
+    copyFile(srcAbs, path.join(outDirAbs, rel));
+    copied.push(rel);
+    return copied;
+  }
+  if (st.isDirectory()) {
+    const files = listFilesRec(srcAbs);
+    for (const abs of files) {
+      const rel = normalizePosix(path.relative(REPO_ROOT, abs));
+      copyFile(abs, path.join(outDirAbs, rel));
+      copied.push(rel);
+    }
+  }
+  return copied;
+}
+
+function applyRewrite(outDirAbs, rewrite) {
+  const rules = rewrite || {};
+  for (const [relFile, cfg] of Object.entries(rules)) {
+    const target = path.join(outDirAbs, relFile);
+    if (!fs.existsSync(target)) continue;
+    let content = fs.readFileSync(target, 'utf8');
+    const reps = (cfg && cfg.replace) || [];
+    for (const r of reps) {
+      const from = String(r.from || '');
+      const to = String(r.to || '');
+      if (!from) continue;
+      content = content.split(from).join(to);
+    }
+    fs.writeFileSync(target, content, 'utf8');
+  }
+}
+
+function rewritePackageJson(outDirAbs) {
+  const p = path.join(outDirAbs, 'package.json');
+  if (!fs.existsSync(p)) return;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(p, 'utf8'));
+    pkg.scripts = {
+      start: 'node index.js',
+      run: 'node index.js run',
+    };
+    fs.writeFileSync(p, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+  } catch (e) {
+    // ignore
+  }
+}
+
+function parseSemver(v) {
+  const m = String(v || '').trim().match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!m) return null;
+  return { major: Number(m[1]), minor: Number(m[2]), patch: Number(m[3]) };
+}
+
+function formatSemver(x) {
+  return `${x.major}.${x.minor}.${x.patch}`;
+}
+
+function bumpSemver(base, bump) {
+  const v = parseSemver(base);
+  if (!v) return null;
+  if (bump === 'major') return `${v.major + 1}.0.0`;
+  if (bump === 'minor') return `${v.major}.${v.minor + 1}.0`;
+  if (bump === 'patch') return `${v.major}.${v.minor}.${v.patch + 1}`;
+  return formatSemver(v);
+}
+
+function git(cmd) {
+  return execSync(cmd, { cwd: REPO_ROOT, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+}
+
+function getBaseReleaseCommit() {
+  // Prefer last "prepare vX.Y.Z" commit; fallback to HEAD~50 range later.
+  try {
+    const hash = git('git log -n 1 --pretty=%H --grep="chore(release): prepare v"');
+    return hash || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function getCommitSubjectsSince(baseCommit) {
+  try {
+    if (!baseCommit) {
+      const out = git('git log -n 30 --pretty=%s');
+      return out ? out.split('\n').filter(Boolean) : [];
+    }
+    const out = git(`git log ${baseCommit}..HEAD --pretty=%s`);
+    return out ? out.split('\n').filter(Boolean) : [];
+  } catch (e) {
+    return [];
+  }
+}
+
+function inferBumpFromSubjects(subjects) {
+  const subs = (subjects || []).map(s => String(s));
+  const hasBreaking = subs.some(s => /\bBREAKING CHANGE\b/i.test(s) || /^[a-z]+(\(.+\))?!:/.test(s));
+  if (hasBreaking) return { bump: 'major', reason: 'breaking change marker in commit subject' };
+
+  const hasFeat = subs.some(s => /^feat(\(.+\))?:/i.test(s));
+  if (hasFeat) return { bump: 'minor', reason: 'feature commit detected (feat:)' };
+
+  const hasFix = subs.some(s => /^(fix|perf)(\(.+\))?:/i.test(s));
+  if (hasFix) return { bump: 'patch', reason: 'fix/perf commit detected' };
+
+  if (subs.length === 0) return { bump: 'none', reason: 'no commits since base release commit' };
+  return { bump: 'patch', reason: 'default to patch for non-breaking changes' };
+}
+
+function suggestVersion() {
+  const pkgPath = path.join(REPO_ROOT, 'package.json');
+  let baseVersion = null;
+  try {
+    baseVersion = JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version;
+  } catch (e) {}
+
+  const baseCommit = getBaseReleaseCommit();
+  const subjects = getCommitSubjectsSince(baseCommit);
+  const decision = inferBumpFromSubjects(subjects);
+
+  let suggested = null;
+  if (decision.bump === 'none') suggested = baseVersion;
+  else suggested = bumpSemver(baseVersion, decision.bump);
+
+  return { baseVersion, baseCommit, subjects, decision, suggestedVersion: suggested };
+}
+
+function writePrivateSemverNote(note) {
+  const privateDir = path.join(REPO_ROOT, 'memory');
+  ensureDir(privateDir);
+  fs.writeFileSync(path.join(privateDir, 'semver_suggestion.json'), JSON.stringify(note, null, 2) + '\n', 'utf8');
+}
+
+function writePrivateSemverPrompt(note) {
+  const privateDir = path.join(REPO_ROOT, 'memory');
+  ensureDir(privateDir);
+  const subjects = Array.isArray(note.subjects) ? note.subjects : [];
+  const semverRule = [
+    'MAJOR.MINOR.PATCH',
+    '- MAJOR: incompatible changes',
+    '- MINOR: backward-compatible features',
+    '- PATCH: backward-compatible bug fixes',
+  ].join('\n');
+
+  const prompt = [
+    'You are a release versioning assistant.',
+    'Decide the next version bump using SemVer rules below.',
+    '',
+    semverRule,
+    '',
+    `Base version: ${note.baseVersion || '(unknown)'}`,
+    `Base commit: ${note.baseCommit || '(unknown)'}`,
+    '',
+    'Recent commit subjects (newest first):',
+    ...subjects.map(s => `- ${s}`),
+    '',
+    'Output JSON only:',
+    '{ "bump": "major|minor|patch|none", "suggestedVersion": "x.y.z", "reason": ["..."] }',
+  ].join('\n');
+
+  fs.writeFileSync(path.join(privateDir, 'semver_prompt.md'), prompt + '\n', 'utf8');
+}
+
+function writeDistVersion(outDirAbs, version) {
+  if (!version) return;
+  const p = path.join(outDirAbs, 'package.json');
+  if (!fs.existsSync(p)) return;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(p, 'utf8'));
+    pkg.version = version;
+    fs.writeFileSync(p, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+  } catch (e) {}
+}
+
+function pruneExcluded(outDirAbs, excludeGlobs) {
+  const all = listFilesRec(outDirAbs);
+  for (const abs of all) {
+    const rel = normalizePosix(path.relative(outDirAbs, abs));
+    if (matchesAnyGlobs(rel, excludeGlobs)) {
+      fs.rmSync(abs, { force: true });
+    }
+  }
+}
+
+function validateNoPrivatePaths(outDirAbs) {
+  // Basic safeguard: forbid docs/ and memory/ in output.
+  const forbiddenPrefixes = ['docs/', 'memory/'];
+  const all = listFilesRec(outDirAbs);
+  for (const abs of all) {
+    const rel = normalizePosix(path.relative(outDirAbs, abs));
+    for (const pref of forbiddenPrefixes) {
+      if (rel.startsWith(pref)) {
+        throw new Error(`Build validation failed: forbidden path in output: ${rel}`);
+      }
+    }
+  }
+}
+
+function main() {
+  const manifestPath = path.join(REPO_ROOT, 'public.manifest.json');
+  const manifest = readJson(manifestPath);
+  const outDir = String(manifest.outDir || 'dist-public');
+  const outDirAbs = path.join(REPO_ROOT, outDir);
+
+  // SemVer suggestion (private). This does not modify the source repo version.
+  const semver = suggestVersion();
+  writePrivateSemverNote(semver);
+  writePrivateSemverPrompt(semver);
+
+  rmDir(outDirAbs);
+  ensureDir(outDirAbs);
+
+  const include = manifest.include || [];
+  const exclude = manifest.exclude || [];
+
+  const copied = [];
+  for (const spec of include) {
+    copied.push(...copyEntry(spec, outDirAbs));
+  }
+
+  pruneExcluded(outDirAbs, exclude);
+  applyRewrite(outDirAbs, manifest.rewrite);
+  rewritePackageJson(outDirAbs);
+
+  // Prefer explicit version; otherwise use suggested version.
+  const releaseVersion = process.env.RELEASE_VERSION || semver.suggestedVersion;
+  if (releaseVersion) writeDistVersion(outDirAbs, releaseVersion);
+
+  validateNoPrivatePaths(outDirAbs);
+
+  // Write build manifest for private verification (do not include in dist-public/).
+  const buildInfo = {
+    built_at: new Date().toISOString(),
+    outDir,
+    files: copied.sort(),
+  };
+  const privateDir = path.join(REPO_ROOT, 'memory');
+  ensureDir(privateDir);
+  fs.writeFileSync(path.join(privateDir, 'public_build_info.json'), JSON.stringify(buildInfo, null, 2) + '\n', 'utf8');
+
+  process.stdout.write(`Built public output at ${outDir}\n`);
+  if (semver && semver.suggestedVersion) {
+    process.stdout.write(`Suggested version: ${semver.suggestedVersion}\n`);
+    process.stdout.write(`SemVer decision: ${semver.decision ? semver.decision.bump : 'unknown'}\n`);
+  }
+}
+
+try {
+  main();
+} catch (e) {
+  process.stderr.write(`${e.message}\n`);
+  process.exit(1);
+}
+

package/skills/capability-evolver/scripts/export_history.js

@@ -0,0 +1,98 @@
+const fs = require('fs');
+const path = require('path');
+const REPO_ROOT = path.resolve(__dirname, '..');
+try {
+  require('dotenv').config({ path: path.join(REPO_ROOT, '.env') });
+} catch (e) {
+  // dotenv may be missing; proceed gracefully
+}
+
+const DOC_TOKEN = 'NwV1dKCLyoPdIvx3biRcKS1Jnwg'; // The new doc
+const LOG_FILE = path.join(REPO_ROOT, 'memory', 'mad_dog_evolution.log');
+const TOKEN_FILE = path.join(REPO_ROOT, 'memory', 'feishu_token.json');
+
+async function exportEvolutionHistory() {
+    let token;
+    try { token = JSON.parse(fs.readFileSync(TOKEN_FILE)).token; } catch(e) {}
+    if (!token) return console.error("No token");
+
+    let logContent = '';
+    try { logContent = fs.readFileSync(LOG_FILE, 'utf8'); } catch(e) { return console.error("No log file"); }
+
+    // Parse Log
+    const cycles = [];
+    const regex = /Evolution Cycle #(\d+)([\s\S]*?)(?:Cycle End|System:)/g;
+    let match;
+    while ((match = regex.exec(logContent)) !== null) {
+        let details = match[2].trim();
+        // Clean up details
+        details = details.replace(/\[.*?\]/g, '').replace(/\n+/g, '\n').trim();
+        if (details.length > 500) details = details.substring(0, 500) + '...';
+        
+        cycles.push({
+            id: match[1],
+            content: details
+        });
+    }
+
+    if (cycles.length === 0) {
+        // Fallback: Just dump the last 50 lines
+        cycles.push({ id: "Unknown", content: logContent.split('\n').slice(-50).join('\n') });
+    }
+
+    // Reverse to show latest first
+    cycles.reverse();
+
+    // Format for Feishu Doc (Markdown)
+    let markdown = "# Evolution History (Loop)\n\n> Auto-generated report of self-improvement cycles.\n\n";
+    
+    // Split into chunks if too big
+    const chunks = [];
+    let currentChunk = markdown;
+    
+    for (const cycle of cycles) {
+        const entry = `### Cycle #${cycle.id}\n${cycle.content}\n\n---\n\n`;
+        if (currentChunk.length + entry.length > 8000) { // Safety limit
+            chunks.push(currentChunk);
+            currentChunk = entry;
+        } else {
+            currentChunk += entry;
+        }
+    }
+    chunks.push(currentChunk);
+
+    // Append Chunks
+    console.log(`Exporting ${chunks.length} chunks...`);
+    
+    for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        console.log(`Uploading Chunk ${i+1}/${chunks.length}...`);
+        
+        // Fallback: Send as Code Block to avoid parsing errors
+        const blocks = [{
+            block_type: 14, // Code
+            code: {
+                style: { language: 1 }, // Plain Text
+                elements: [{ text_run: { content: chunk, text_element_style: {} } }]
+            }
+        }];
+
+        const res = await fetch(`https://open.feishu.cn/open-apis/docx/v1/documents/${DOC_TOKEN}/blocks/${DOC_TOKEN}/children`, {
+            method: 'POST',
+            headers: { 
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json; charset=utf-8'
+            },
+            body: JSON.stringify({ children: blocks })
+        });
+        
+        const data = await res.json();
+        if (data.code !== 0) console.error(`Chunk ${i+1} failed:`, JSON.stringify(data));
+        else console.log(`Chunk ${i+1} success.`);
+        
+        await new Promise(r => setTimeout(r, 500));
+    }
+}
+
+exportEvolutionHistory();
+

package/skills/capability-evolver/scripts/extract_log.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const path = require('path');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const LOG_FILE = path.join(REPO_ROOT, 'memory', 'mad_dog_evolution.log');
+const OUT_FILE = path.join(REPO_ROOT, 'evolution_history.md');
+
+function parseLog() {
+    if (!fs.existsSync(LOG_FILE)) {
+        console.log("Log file not found.");
+        return;
+    }
+
+    const content = fs.readFileSync(LOG_FILE, 'utf8');
+    const lines = content.split('\n');
+    
+    const reports = [];
+    let currentTimestamp = null;
+
+    // Regex for Feishu command
+    // node skills/feishu-card/send.js --title "..." --color ... --text "..."
+    const cmdRegex = /node skills\/feishu-card\/send\.js --title "(.*?)" --color \w+ --text "(.*?)"/;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        
+        // 1. Capture Timestamp
+        if (line.includes('Cycle Start:')) {
+            // Format: Cycle Start: Sun Feb  1 19:17:44 UTC 2026
+            const dateStr = line.split('Cycle Start: ')[1].trim();
+            try {
+                currentTimestamp = new Date(dateStr);
+            } catch (e) {
+                currentTimestamp = null;
+            }
+        }
+
+        const match = line.match(cmdRegex);
+        if (match) {
+            const title = match[1];
+            let text = match[2];
+            
+            // Clean up text (unescape newlines)
+            text = text.replace(/\\n/g, '\n').replace(/\\"/g, '"');
+
+            if (currentTimestamp) {
+                reports.push({
+                    ts: currentTimestamp,
+                    title: title,
+                    text: text,
+                    id: title // Cycle ID is in title
+                });
+            }
+        }
+    }
+
+    // Deduplicate by ID (keep latest timestamp?)
+    const uniqueReports = {};
+    reports.forEach(r => {
+        uniqueReports[r.id] = r;
+    });
+
+    const sortedReports = Object.values(uniqueReports).sort((a, b) => a.ts - b.ts);
+
+    let md = "# Evolution History (Extracted)\n\n";
+    sortedReports.forEach(r => {
+        // Convert to CST (UTC+8)
+        const cstDate = r.ts.toLocaleString("zh-CN", {
+            timeZone: "Asia/Shanghai", 
+            hour12: false,
+            year: 'numeric', month: '2-digit', day: '2-digit',
+            hour: '2-digit', minute: '2-digit', second: '2-digit'
+        });
+
+        md += `### ${r.title} (${cstDate})\n`;
+        md += `${r.text}\n\n`;
+        md += `---\n\n`;
+    });
+
+    fs.writeFileSync(OUT_FILE, md);
+    console.log(`Extracted ${sortedReports.length} reports to ${OUT_FILE}`);
+}
+
+parseLog();
+

package/skills/capability-evolver/scripts/generate_history.js

@@ -0,0 +1,75 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Separator for git log parsing (something unlikely to be in commit messages)
+const SEP = '|||';
+const REPO_ROOT = path.resolve(__dirname, '..');
+
+try {
+    // Git command:
+    // --reverse: Oldest to Newest (Time Sequence)
+    // --grep: Filter by keyword
+    // --format: Hash, Date (ISO), Author, Subject, Body
+    const cmd = `git log --reverse --grep="Evolution" --format="%H${SEP}%ai${SEP}%an${SEP}%s${SEP}%b"`;
+    
+    console.log('Executing git log...');
+    const output = execSync(cmd, { 
+        encoding: 'utf8', 
+        cwd: REPO_ROOT,
+        maxBuffer: 1024 * 1024 * 10 // 10MB buffer just in case
+    });
+
+    const entries = output.split('\n').filter(line => line.trim().length > 0);
+    
+    let markdown = '# Evolution History (Time Sequence)\n\n';
+    markdown += '> Filter: "Evolution"\n';
+    markdown += '> Timezone: CST (UTC+8)\n\n';
+    
+    let count = 0;
+
+    entries.forEach(entry => {
+        const parts = entry.split(SEP);
+        if (parts.length < 4) return;
+
+        const hash = parts[0];
+        const dateStr = parts[1];
+        const author = parts[2];
+        const subject = parts[3];
+        const body = parts[4] || '';
+
+        // Parse Date and Convert to UTC+8
+        const date = new Date(dateStr);
+        // Add 8 hours (28800000 ms) to UTC timestamp to shift it
+        // Then formatting it as ISO will look like UTC but represent CST values
+        const cstDate = new Date(date.getTime() + 8 * 60 * 60 * 1000);
+        
+        // Format: YYYY-MM-DD HH:mm:ss
+        const timeStr = cstDate.toISOString().replace('T', ' ').substring(0, 19);
+
+        markdown += `## ${timeStr}\n`;
+        markdown += `- Commit: \`${hash.substring(0, 7)}\`\n`;
+        markdown += `- Subject: ${subject}\n`;
+        
+        if (body.trim()) {
+            // Indent body for better readability
+            const formattedBody = body.trim().split('\n').map(l => `> ${l}`).join('\n');
+            markdown += `- Details:\n${formattedBody}\n`;
+        }
+        markdown += '\n';
+        count++;
+    });
+
+    const outDir = path.join(REPO_ROOT, 'memory');
+    if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+    const outPath = path.join(outDir, 'evolution_history.md');
+    fs.writeFileSync(outPath, markdown);
+    
+    console.log(`Successfully generated report with ${count} entries.`);
+    console.log(`Saved to: ${outPath}`);
+
+} catch (e) {
+    console.error('Error generating history:', e.message);
+    process.exit(1);
+}
+