clawpilot 0.1.1

package/README.md

@@ -0,0 +1,67 @@
+# clawpilot
+
+OpenClaw productivity copilot installer and skill package.
+
+## What it does
+
+`clawpilot` installs a productivity-focused OpenClaw skill with a simple daily loop:
+- Morning planning (top 3 tasks)
+- Midday progress check
+- Evening review and next-step setup
+
+The installer also:
+- Copies `skill/` into `~/.openclaw/skills/clawpilot-productivity`
+- Adds or updates `clawpilot-productivity` under `openclaw.json`
+- Injects a productivity section into `workspace/SOUL.md` (idempotent)
+- Writes a default `workspace/IDENTITY.md`
+
+## Install
+
+```bash
+npx clawpilot@latest
+```
+
+Or run locally:
+
+```bash
+npm install
+npm run test
+node bin/cli.js install
+```
+
+## CLI options
+
+```bash
+clawpilot install [options]
+```
+
+Options:
+- `--home <path>`: Override OpenClaw home directory
+- `--force`: Replace existing skill installation
+- `--morning <HH:mm>`: Morning check-in time (default `09:00`)
+- `--midday <HH:mm>`: Midday check-in time (default `14:00`)
+- `--evening <HH:mm>`: Evening check-in time (default `21:30`)
+
+## OpenClaw paths
+
+By default, the installer writes to:
+- `~/.openclaw/skills/clawpilot-productivity/`
+- `~/.openclaw/openclaw.json`
+- `~/.openclaw/workspace/SOUL.md`
+- `~/.openclaw/workspace/IDENTITY.md`
+
+You can override the target path with:
+
+```bash
+node bin/cli.js install --home /custom/path
+```
+
+## Development
+
+```bash
+npm test
+```
+
+## Publish
+
+See `docs/PUBLISH_CHECKLIST.md`.

package/bin/cli.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+const os = require('node:os');
+const path = require('node:path');
+const { installSkill, DEFAULT_SCHEDULE } = require('../src/install');
+
+function printHelp() {
+  console.log('clawpilot - OpenClaw productivity copilot');
+  console.log('');
+  console.log('Usage:');
+  console.log('  clawpilot install [options]');
+  console.log('  clawpilot --help');
+  console.log('');
+  console.log('Commands:');
+  console.log('  install    Install clawpilot-productivity skill into OpenClaw');
+  console.log('');
+  console.log('Options:');
+  console.log('  --home <path>       Override OpenClaw home directory');
+  console.log('  --force             Replace existing clawpilot skill installation');
+  console.log(`  --morning <HH:mm>   Morning check-in time (default: ${DEFAULT_SCHEDULE.morning})`);
+  console.log(`  --midday <HH:mm>    Midday check-in time (default: ${DEFAULT_SCHEDULE.midday})`);
+  console.log(`  --evening <HH:mm>   Evening check-in time (default: ${DEFAULT_SCHEDULE.evening})`);
+}
+
+function parseOptions(args) {
+  const options = {
+    force: false,
+    schedule: {}
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--force') {
+      options.force = true;
+      continue;
+    }
+    if (arg === '--home') {
+      options.openClawHome = args[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--morning') {
+      options.schedule.morning = args[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--midday') {
+      options.schedule.midday = args[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--evening') {
+      options.schedule.evening = args[index + 1];
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown option: ${arg}`);
+  }
+
+  return options;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0] || 'install';
+  const commandArgs = args.slice(1);
+
+  if (command === '--help' || command === '-h' || command === 'help') {
+    printHelp();
+    return;
+  }
+
+  if (command !== 'install') {
+    console.error(`Unknown command: ${command}`);
+    console.error('Run "clawpilot --help" for usage.');
+    process.exitCode = 1;
+    return;
+  }
+
+  const projectRoot = path.resolve(__dirname, '..');
+  const options = parseOptions(commandArgs);
+  const openClawHome = options.openClawHome || process.env.OPENCLAW_HOME || path.join(os.homedir(), '.openclaw');
+
+  const result = await installSkill({
+    openClawHome,
+    packageRoot: projectRoot,
+    schedule: options.schedule,
+    force: options.force
+  });
+
+  console.log(`Installed skill at: ${result.skillDir}`);
+  console.log(`Updated config at: ${result.configPath}`);
+  console.log(`Updated workspace SOUL at: ${result.workspaceSoulPath}`);
+  console.log(`Updated workspace identity at: ${result.identityPath}`);
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exitCode = 1;
+});

package/docs/PUBLISH_CHECKLIST.md

@@ -0,0 +1,22 @@
+# Publish Checklist
+
+Use this checklist before publishing a new `clawpilot` version to npm.
+
+1. Verify tests:
+   - `npm test`
+2. Verify installer behavior locally:
+   - `node bin/cli.js install --home <temp-dir>`
+3. Review package metadata:
+   - `name`
+   - `version`
+   - `bin`
+   - `license`
+4. Confirm npm auth:
+   - `npm whoami`
+5. Dry-run package contents:
+   - `npm pack --dry-run`
+6. Publish:
+   - `npm publish --access public`
+7. Validate release:
+   - `npm view clawpilot version`
+   - `npx clawpilot@latest --help`

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "clawpilot",
+  "version": "0.1.1",
+  "description": "OpenClaw productivity copilot installer and skill package.",
+  "private": false,
+  "bin": {
+    "clawpilot": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "skill/",
+    "templates/",
+    "docs/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "openclaw",
+    "claw",
+    "productivity",
+    "copilot"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/RyanSparkc/clawpilot.git"
+  },
+  "homepage": "https://github.com/RyanSparkc/clawpilot#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/skill/SKILL.md

@@ -0,0 +1,22 @@
+# Clawpilot Productivity Skill
+
+You are a productivity copilot focused on helping the user ship meaningful work each day.
+
+## Core Loop
+
+1. Morning planning:
+   - Ask for the user's top 3 outcome-based tasks.
+   - Ensure each task is specific and verifiable.
+2. Midday check-in:
+   - Ask what is done, blocked, or deferred.
+   - Help remove one blocker.
+3. Evening review:
+   - Summarize completed work.
+   - Capture one improvement for tomorrow.
+
+## Tone and Constraints
+
+- Keep responses short and action-oriented.
+- Be supportive and direct.
+- Avoid guilt, shame, or perfectionist framing.
+- Prefer one next action when the user is stuck.

package/skill/manifest.json

@@ -0,0 +1,6 @@
+{
+  "id": "clawpilot-productivity",
+  "name": "Clawpilot Productivity",
+  "version": "0.1.0",
+  "entry": "SOUL.md"
+}

package/src/install.js

@@ -0,0 +1,181 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SKILL_ID = 'clawpilot-productivity';
+const MARKER_START = '<!-- clawpilot:productivity:start -->';
+const MARKER_END = '<!-- clawpilot:productivity:end -->';
+const DEFAULT_SCHEDULE = {
+  morning: '09:00',
+  midday: '14:00',
+  evening: '21:30'
+};
+
+function copyDir(source, destination) {
+  fs.mkdirSync(destination, { recursive: true });
+  const entries = fs.readdirSync(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = path.join(source, entry.name);
+    const destinationPath = path.join(destination, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(sourcePath, destinationPath);
+    } else {
+      fs.copyFileSync(sourcePath, destinationPath);
+    }
+  }
+}
+
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      result[key] = deepMerge(result[key] || {}, value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+
+function readJson(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeJson(filePath, data) {
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+function upsertInstalledSkill(config) {
+  if (!Array.isArray(config.installedSkills)) {
+    config.installedSkills = [];
+  }
+  if (!config.installedSkills.includes(SKILL_ID)) {
+    config.installedSkills.push(SKILL_ID);
+  }
+}
+
+function normalizeSchedule(schedule) {
+  return {
+    ...DEFAULT_SCHEDULE,
+    ...(schedule || {})
+  };
+}
+
+function upsertWorkspaceSoul(soulPath, injectionText) {
+  const normalizedInjection = `${MARKER_START}\n${injectionText.trim()}\n${MARKER_END}`;
+  const existing = fs.existsSync(soulPath)
+    ? fs.readFileSync(soulPath, 'utf8')
+    : '# Agent Soul\n';
+  const markerRegex = new RegExp(`${MARKER_START}[\\s\\S]*?${MARKER_END}\\n?`, 'g');
+  const cleaned = existing.replace(markerRegex, '').trimEnd();
+  const nextContent = `${cleaned}\n\n${normalizedInjection}\n`;
+  fs.writeFileSync(soulPath, nextContent, 'utf8');
+}
+
+function ensureSkillManifest(skillDir) {
+  const manifestPath = path.join(skillDir, 'manifest.json');
+  if (fs.existsSync(manifestPath)) {
+    return;
+  }
+
+  const manifest = {
+    id: SKILL_ID,
+    name: 'Clawpilot Productivity',
+    version: '0.1.0',
+    entry: 'SOUL.md'
+  };
+  writeJson(manifestPath, manifest);
+}
+
+async function installSkill({
+  openClawHome,
+  packageRoot,
+  schedule,
+  force = false,
+  timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC'
+}) {
+  const skillsDir = path.join(openClawHome, 'skills');
+  const skillDir = path.join(openClawHome, 'skills', SKILL_ID);
+  const workspaceDir = path.join(openClawHome, 'workspace');
+  const configPath = path.join(openClawHome, 'openclaw.json');
+  const soulPath = path.join(skillDir, 'SOUL.md');
+  const workspaceSoulPath = path.join(workspaceDir, 'SOUL.md');
+  const identityPath = path.join(workspaceDir, 'IDENTITY.md');
+
+  const skillSourceDir = path.join(packageRoot, 'skill');
+  const templateDir = path.join(packageRoot, 'templates');
+  const baseSoulTemplate = fs.readFileSync(path.join(templateDir, 'soul.productivity.md'), 'utf8');
+  const injectionTemplate = fs.readFileSync(path.join(templateDir, 'soul-injection.md'), 'utf8');
+  const identityTemplate = fs.readFileSync(path.join(templateDir, 'identity.md'), 'utf8');
+
+  fs.mkdirSync(openClawHome, { recursive: true });
+  fs.mkdirSync(skillsDir, { recursive: true });
+  fs.mkdirSync(workspaceDir, { recursive: true });
+
+  if (fs.existsSync(skillDir)) {
+    if (!force) {
+      throw new Error(`Skill already installed: ${skillDir}. Re-run with force to replace.`);
+    }
+    fs.rmSync(skillDir, { recursive: true, force: true });
+  }
+
+  if (fs.existsSync(skillSourceDir)) {
+    copyDir(skillSourceDir, skillDir);
+  } else {
+    fs.mkdirSync(skillDir, { recursive: true });
+  }
+
+  fs.writeFileSync(soulPath, baseSoulTemplate, 'utf8');
+  ensureSkillManifest(skillDir);
+  upsertWorkspaceSoul(workspaceSoulPath, injectionTemplate);
+  fs.writeFileSync(identityPath, identityTemplate, 'utf8');
+
+  let config = readJson(configPath);
+  const existingEntry = (((config.skills || {}).entries || {})[SKILL_ID]) || {};
+  const mergedEntry = deepMerge(existingEntry, {
+    enabled: true,
+    mode: 'productivity',
+    timezone,
+    schedule: normalizeSchedule(schedule)
+  });
+
+  config = deepMerge(config, {
+    skills: {
+      entries: {
+        [SKILL_ID]: mergedEntry
+      },
+      load: {
+        extraDirs: Array.isArray(config.skills?.load?.extraDirs)
+          ? config.skills.load.extraDirs
+          : []
+      }
+    }
+  });
+
+  if (!config.skills.load.extraDirs.includes(skillsDir)) {
+    config.skills.load.extraDirs.push(skillsDir);
+  }
+
+  upsertInstalledSkill(config);
+  writeJson(configPath, config);
+
+  return {
+    skillDir,
+    configPath,
+    workspaceSoulPath,
+    identityPath
+  };
+}
+
+module.exports = {
+  installSkill,
+  SKILL_ID,
+  DEFAULT_SCHEDULE
+};

package/templates/identity.md

@@ -0,0 +1,6 @@
+# IDENTITY.md
+
+- Name: Clawpilot
+- Role: Productivity Copilot
+- Style: Calm, concise, practical, and supportive
+- Focus: Daily execution, momentum, and measurable outcomes

package/templates/soul-injection.md

@@ -0,0 +1,14 @@
+## Clawpilot Productivity Loop
+
+Run this daily structure with minimal friction:
+
+- Morning: ask for 3 outcome-based tasks and make each one measurable.
+- Midday: collect status (`done`, `blocked`, or `deferred`) and unblock one thing.
+- Evening: summarize wins, note one lesson, and queue tomorrow's first action.
+
+Coaching rules:
+
+- Keep guidance direct and practical.
+- Use supportive language, never guilt-driven language.
+- If progress is behind, offer one focused 25-minute rescue sprint.
+- Avoid long motivational monologues.

package/templates/soul.productivity.md

@@ -0,0 +1,17 @@
+# Clawpilot Productivity Copilot
+
+You are a friendly productivity partner focused on work execution.
+
+Daily flow:
+- Morning: define top 3 outcome-based tasks.
+- Midday: check progress and identify one blocker.
+- Evening: review completion and prepare tomorrow's first task.
+
+Tone:
+- Keep responses concise, practical, and supportive.
+- Avoid guilt-driven language.
+- Prioritize momentum over perfection.
+
+Recovery mode:
+- If user is behind, suggest one 25-minute rescue sprint.
+- Limit rescue mode to two times per week.