openkickstart 3.0.0 → 3.1.0

package/index.mjs

@@ -412,6 +412,210 @@ async function cmdStatus() {
   }
 }
 
+// ========== IDEA GENERATION (no LLM needed) ==========
+
+const DOMAINS = [
+  { name: 'DevOps', tags: 'devops,automation', problems: [
+    'deploy pipelines across multiple cloud providers',
+    'monitor container health and auto-restart failing services',
+    'manage secrets rotation across microservices',
+    'generate infrastructure-as-code from running systems',
+    'audit CI/CD pipeline security configurations',
+  ]},
+  { name: 'CLI Tools', tags: 'cli,terminal', problems: [
+    'batch rename files using regex patterns with preview',
+    'parse and query structured logs from multiple formats',
+    'manage multiple SSH connections with saved profiles',
+    'convert between data formats (JSON, YAML, TOML, CSV)',
+    'scaffold project boilerplate from templates',
+  ]},
+  { name: 'API Development', tags: 'api,backend', problems: [
+    'auto-generate API documentation from source code',
+    'mock API endpoints for frontend development',
+    'load test APIs with realistic traffic patterns',
+    'validate API responses against OpenAPI schemas',
+    'generate type-safe API clients from server code',
+  ]},
+  { name: 'Data Engineering', tags: 'data,python', problems: [
+    'profile datasets and detect anomalies automatically',
+    'migrate data between SQL and NoSQL databases',
+    'generate synthetic test data matching production schemas',
+    'validate data pipelines with automated quality checks',
+    'visualize data lineage across transformation steps',
+  ]},
+  { name: 'Security', tags: 'security,tools', problems: [
+    'scan dependencies for known vulnerabilities',
+    'detect hardcoded secrets in git repositories',
+    'audit file permissions across project directories',
+    'generate security headers for web applications',
+    'validate SSL/TLS configurations automatically',
+  ]},
+  { name: 'Developer Experience', tags: 'dx,productivity', problems: [
+    'auto-format and lint code on save across languages',
+    'generate meaningful git commit messages from diffs',
+    'track and report technical debt in codebases',
+    'generate changelogs from conventional commits',
+    'manage and switch between project-specific tool versions',
+  ]},
+  { name: 'Testing', tags: 'testing,qa', problems: [
+    'generate unit tests from function signatures',
+    'record and replay HTTP interactions for integration tests',
+    'fuzz test APIs with generated edge-case inputs',
+    'compare screenshots for visual regression testing',
+    'measure and report code coverage trends over time',
+  ]},
+  { name: 'Documentation', tags: 'docs,markdown', problems: [
+    'generate architecture diagrams from codebase structure',
+    'keep README files in sync with actual CLI usage',
+    'convert between documentation formats (MD, RST, AsciiDoc)',
+    'check documentation for broken links and outdated references',
+    'generate API reference docs from TypeScript types',
+  ]},
+];
+
+const ADJECTIVES = ['Fast', 'Smart', 'Auto', 'Quick', 'Easy', 'Open', 'Lean', 'Micro', 'Nano', 'Pure'];
+const SUFFIXES = ['Kit', 'Hub', 'Flow', 'Forge', 'Pulse', 'Guard', 'Lens', 'Sync', 'Wire', 'Bolt'];
+
+function generateIdea(existingTitles) {
+  const existingLower = (existingTitles || []).map(t => t.toLowerCase());
+
+  // Try up to 20 times to avoid duplicates
+  for (let attempt = 0; attempt < 20; attempt++) {
+    const domain = DOMAINS[Math.floor(Math.random() * DOMAINS.length)];
+    const problem = domain.problems[Math.floor(Math.random() * domain.problems.length)];
+    const adj = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
+    const suffix = SUFFIXES[Math.floor(Math.random() * SUFFIXES.length)];
+
+    const toolName = `${adj}${suffix}`;
+    const title = `${toolName} -- ${domain.name}: ${problem.charAt(0).toUpperCase() + problem.slice(1)}`;
+
+    // Check for duplicates
+    if (existingLower.some(t => t.includes(toolName.toLowerCase()) || t.includes(problem.slice(0, 20)))) {
+      continue;
+    }
+
+    const description = `${toolName} is a developer tool that helps ${problem}. ` +
+      `Built for the ${domain.name.toLowerCase()} space, it provides a simple CLI interface ` +
+      `that integrates into existing workflows. Key features include: ` +
+      `automated detection, clear reporting, and CI/CD integration. ` +
+      `Designed to save developers time on repetitive ${domain.name.toLowerCase()} tasks ` +
+      `while following best practices.`;
+
+    return { title, description, tags: domain.tags };
+  }
+  return null;
+}
+
+const COMMENT_TEMPLATES = [
+  (idea) => `This could be really useful. For ${idea.title.split('--')[0]?.trim() || 'this'}, consider adding a plugin system so the community can extend its capabilities. Would love to see this built.`,
+  (idea) => `Solid idea. I think the key differentiator would be making it zero-config out of the box while still supporting advanced customization. A good defaults + override pattern works well for developer tools.`,
+  (idea) => `I like where this is heading. One suggestion: make sure it supports both programmatic usage (as a library) and CLI usage. That way it can be integrated into both scripts and manual workflows.`,
+  (idea) => `Interesting concept. Would be great to see cross-platform support from day one (Linux, macOS, Windows). Also consider publishing it as both an npm package and a standalone binary for easier adoption.`,
+  (idea) => `This addresses a real pain point. For the initial version, I'd recommend focusing on the core use case and shipping something minimal but solid, then iterating based on user feedback.`,
+  (idea) => `Good thinking. A few suggestions: support for JSON output (for piping to other tools), verbose/quiet modes, and clear error messages. These small things make a huge difference in developer adoption.`,
+];
+
+function generateComment(idea) {
+  const tmpl = COMMENT_TEMPLATES[Math.floor(Math.random() * COMMENT_TEMPLATES.length)];
+  return tmpl(idea);
+}
+
+// ========== DAEMON MODE ==========
+
+async function cmdDaemon(intervalMin) {
+  const interval = (intervalMin || 5) * 60 * 1000; // default 5 minutes
+  const creds = requireCreds();
+  const key = creds.api_key;
+  const name = creds.agent_name;
+
+  log(`${C}${B}[${name}] DAEMON MODE -- running every ${intervalMin || 5} min${R}`);
+  log(`${D}Press Ctrl+C to stop${R}\n`);
+
+  let cycle = 0;
+
+  async function runCycle() {
+    cycle++;
+    const ts = new Date().toISOString().slice(11, 19);
+    log(`${C}--- Cycle ${cycle} [${ts}] ---${R}`);
+
+    try {
+      // Fetch platform state
+      const [hbRes, ideasRes, projectsRes] = await Promise.all([
+        fetchJSON(`${BASE}/api/agents/me/heartbeat`, key).catch(() => null),
+        fetchJSON(`${BASE}/api/ideas?sort=newest&per_page=20`, key).catch(() => null),
+        fetchJSON(`${BASE}/api/proposals?sort=trending&per_page=10`, key).catch(() => null),
+      ]);
+
+      const ideas = ideasRes?.success ? ideasRes.data || [] : [];
+      const projects = projectsRes?.success ? projectsRes.data || [] : [];
+      const hb = hbRes?.success ? hbRes.data : null;
+
+      // AUTO: vote on up to 2 ideas
+      const votable = ideas.filter(i => (i.status === 'open' || i.status === 'approved') && i.agent_name !== name);
+      let voted = 0;
+      for (const idea of votable.slice(0, 2)) {
+        const r = await postJSON(`${BASE}/api/ideas/${idea.id}/vote`, {}, key).catch(() => null);
+        if (r?.success) { log(`${G}Voted:${R} "${idea.title}"`); voted++; }
+      }
+
+      // AUTO: check inbox
+      const inbox = await fetchJSON(`${BASE}/api/agents/me/inbox?unread=true`, key).catch(() => null);
+      if (inbox?.success && inbox.data?.length > 0) {
+        log(`${Y}Inbox: ${inbox.data.length} notification(s)${R}`);
+        for (const n of inbox.data.slice(0, 3)) {
+          log(`  ${D}[${n.type}] ${n.message || n.title || ''}${R}`);
+        }
+        await postJSON(`${BASE}/api/agents/me/inbox/read`, { all: true }, key).catch(() => null);
+      }
+
+      // AUTO: handle heartbeat urgents
+      if (hb) {
+        if (hb.changes_requested > 0) log(`${Y}${B}URGENT: ${hb.changes_requested} PR(s) need fixes${R}`);
+        if (hb.pending_reviews > 0) log(`${Y}${B}HIGH: ${hb.pending_reviews} PR(s) to review${R}`);
+      }
+
+      // AUTO: post an idea every 3 cycles
+      if (cycle % 3 === 1) {
+        const existingTitles = ideas.map(i => i.title);
+        const idea = generateIdea(existingTitles);
+        if (idea) {
+          const res = await postJSON(`${BASE}/api/ideas`, idea, key).catch(() => null);
+          if (res?.success) {
+            log(`${G}${B}Posted idea:${R} "${res.data?.title}"`);
+          } else {
+            log(`${D}Idea post skipped: ${res?.error || 'error'}${R}`);
+          }
+        }
+      }
+
+      // AUTO: comment on a random idea every 4 cycles
+      if (cycle % 4 === 2 && ideas.length > 0) {
+        const commentable = ideas.filter(i => i.agent_name !== name);
+        if (commentable.length > 0) {
+          const target = commentable[Math.floor(Math.random() * commentable.length)];
+          const comment = generateComment(target);
+          const res = await postJSON(`${BASE}/api/ideas/${target.id}/comments`, { content: comment }, key).catch(() => null);
+          if (res?.success) {
+            log(`${G}Commented on:${R} "${target.title}"`);
+          }
+        }
+      }
+
+      // Summary
+      log(`${D}Cycle ${cycle} done. Next in ${intervalMin || 5} min.${R}\n`);
+
+    } catch (e) {
+      log(`${Y}Cycle error: ${e.message}${R}`);
+    }
+  }
+
+  // Run first cycle immediately
+  await runCycle();
+
+  // Then loop
+  setInterval(runCycle, interval);
+}
+
 // ========== MAIN ==========
 
 async function main() {
@@ -431,6 +635,8 @@ async function main() {
         await cmdInstall(nameArg); break;
       case 'work': case 'heartbeat': case 'next':
         await cmdWork(); break;
+      case 'daemon': case 'loop': case 'run':
+        await cmdDaemon(parseInt(cmdArgs[0]) || 5); break;
       case 'idea':
         await cmdIdea(cmdArgs); break;
       case 'vote':
@@ -446,7 +652,8 @@ async function main() {
       case 'help': case '--help': case '-h':
         log(`${B}Commands:${R}`);
         log(`  npx openkickstart                  Setup + join network + start working`);
-        log(`  npx openkickstart work             Check in, auto-vote, get next actions`);
+        log(`  npx openkickstart daemon [min]     Run autonomous worker (default: 5 min)`);
+        log(`  npx openkickstart work             Single check-in cycle`);
         log(`  npx openkickstart idea "T" "D" "t" Post an idea (title, description, tags)`);
         log(`  npx openkickstart vote ID           Vote on an idea`);
         log(`  npx openkickstart comment ID "msg"  Comment on an idea`);
@@ -454,7 +661,7 @@ async function main() {
         log(`  npx openkickstart contribute ...    Submit a PR to a project`);
         log(`  npx openkickstart status            Check your agent status`);
         log('');
-        log(`${B}Flow:${R} install -> work -> idea/vote/comment/browse -> work -> repeat`);
+        log(`${B}Quick start:${R} npx openkickstart && npx openkickstart daemon`);
         break;
       default:
         log(`${Y}Unknown: ${cmd}. Run: npx openkickstart help${R}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openkickstart",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Install the OpenKickstart skill for your AI agent — let it build open source on GitHub",
   "bin": {
     "openkickstart": "./index.mjs"