clawpilot 0.1.1 → 0.2.0

package/src/preflight.js

@@ -0,0 +1,288 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const TROUBLESHOOTING_DOC = 'docs/troubleshooting.md';
+const MIN_OPENCLAW_VERSION = '1.0.0';
+const SKILL_ID = 'clawpilot-productivity';
+
+function createIssue(code, reason, fix) {
+  return {
+    code,
+    reason,
+    fix,
+    docs: TROUBLESHOOTING_DOC
+  };
+}
+
+function createWarning(code, reason, fix) {
+  return {
+    code,
+    reason,
+    fix,
+    docs: TROUBLESHOOTING_DOC
+  };
+}
+
+function parseSemver(text) {
+  const match = String(text || '').match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) {
+    return null;
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    raw: match[0]
+  };
+}
+
+function compareSemver(a, b) {
+  if (a.major !== b.major) {
+    return a.major - b.major;
+  }
+  if (a.minor !== b.minor) {
+    return a.minor - b.minor;
+  }
+  return a.patch - b.patch;
+}
+
+function runCommand(commandRunner, command, args) {
+  try {
+    return commandRunner(command, args, { encoding: 'utf8' });
+  } catch (error) {
+    return {
+      status: 1,
+      error
+    };
+  }
+}
+
+function checkOpenClaw({ commandRunner }) {
+  const result = runCommand(commandRunner, 'openclaw', ['--version']);
+  const output = `${result.stdout || ''} ${result.stderr || ''}`.trim();
+  const errorCode = result.error && result.error.code;
+
+  if (result.status === 0) {
+    const parsed = parseSemver(output);
+    const min = parseSemver(MIN_OPENCLAW_VERSION);
+    if (parsed && min && compareSemver(parsed, min) < 0) {
+      return {
+        ok: false,
+        issue: createIssue(
+          'openclaw_version_unsupported',
+          `OpenClaw version ${parsed.raw} is below required ${MIN_OPENCLAW_VERSION}.`,
+          `Upgrade OpenClaw to ${MIN_OPENCLAW_VERSION} or newer.`
+        )
+      };
+    }
+
+    if (!parsed) {
+      return {
+        ok: true,
+        detail: output || 'openclaw version check passed',
+        warning: createWarning(
+          'openclaw_version_unknown',
+          'OpenClaw version output could not be parsed.',
+          'Run openclaw --version and verify it reports semantic version (x.y.z).'
+        )
+      };
+    }
+
+    return {
+      ok: true,
+      detail: output || 'openclaw version check passed'
+    };
+  }
+
+  if (errorCode === 'ENOENT' || /not found|is not recognized/i.test(output)) {
+    return {
+      ok: false,
+      issue: createIssue(
+        'gateway_missing',
+        'openclaw CLI not found.',
+        'Install OpenClaw CLI and verify with: openclaw --version'
+      )
+    };
+  }
+
+  return {
+    ok: false,
+    issue: createIssue(
+      'gateway_unreachable',
+      output || 'openclaw CLI check failed.',
+      'Run openclaw --version and fix environment PATH or shell profile.'
+    )
+  };
+}
+
+function checkWritableDirectory({ fsOps, dirPath, code, label }) {
+  try {
+    fsOps.mkdirSync(dirPath, { recursive: true });
+    return { ok: true, detail: `${label} writable` };
+  } catch (error) {
+    return {
+      ok: false,
+      issue: createIssue(
+        code,
+        `${label} is not writable: ${dirPath}`,
+        `Grant write access to ${dirPath} or use --home <path> with writable location.`
+      )
+    };
+  }
+}
+
+function checkConfig({ fsOps, configPath }) {
+  if (!fsOps.existsSync(configPath)) {
+    return {
+      ok: true,
+      detail: 'openclaw.json will be created',
+      config: {}
+    };
+  }
+
+  try {
+    const config = JSON.parse(fsOps.readFileSync(configPath, 'utf8'));
+    return {
+      ok: true,
+      detail: 'openclaw.json is valid JSON',
+      config
+    };
+  } catch {
+    return {
+      ok: false,
+      issue: createIssue(
+        'config_invalid_json',
+        'openclaw.json is not valid JSON.',
+        'Fix JSON syntax in openclaw.json before running install.'
+      )
+    };
+  }
+}
+
+function checkGatewayReadiness({ config, env }) {
+  const entry = config?.skills?.entries?.[SKILL_ID];
+  if (!entry) {
+    return {
+      ok: true,
+      detail: 'clawpilot config entry not found yet'
+    };
+  }
+
+  if (entry.delivery?.mode && entry.delivery.mode !== 'openclaw-gateway') {
+    return {
+      ok: true,
+      detail: `delivery mode is ${entry.delivery.mode}`
+    };
+  }
+
+  const warnings = [];
+  if (!entry.delivery?.channel) {
+    warnings.push(
+      createWarning(
+        'delivery_channel_missing',
+        'Gateway delivery channel is not configured.',
+        'Set delivery.channel in openclaw.json or pass --channel during install/run.'
+      )
+    );
+  }
+
+  const hasToken = Boolean(
+    env?.OPENCLAW_GATEWAY_TOKEN ||
+    entry.env?.OPENCLAW_GATEWAY_TOKEN ||
+    entry.delivery?.token
+  );
+  if (!hasToken) {
+    warnings.push(
+      createWarning(
+        'gateway_token_missing',
+        'Gateway token source is not configured.',
+        'Set OPENCLAW_GATEWAY_TOKEN env var or configure token in OpenClaw settings.'
+      )
+    );
+  }
+
+  return {
+    ok: true,
+    detail: 'gateway delivery readiness checked',
+    warnings
+  };
+}
+
+function runPreflight({
+  openClawHome,
+  commandRunner = spawnSync,
+  fsOps = fs,
+  env = process.env
+}) {
+  if (!openClawHome) {
+    throw new Error('openClawHome is required for preflight checks.');
+  }
+
+  const skillsDir = path.join(openClawHome, 'skills');
+  const workspaceDir = path.join(openClawHome, 'workspace');
+  const configPath = path.join(openClawHome, 'openclaw.json');
+
+  const configCheck = checkConfig({ fsOps, configPath });
+  const checks = [
+    { name: 'openclaw_cli', ...checkOpenClaw({ commandRunner }) },
+    {
+      name: 'openclaw_home_writable',
+      ...checkWritableDirectory({
+        fsOps,
+        dirPath: openClawHome,
+        code: 'permission_denied',
+        label: 'OpenClaw home'
+      })
+    },
+    {
+      name: 'skills_dir_writable',
+      ...checkWritableDirectory({
+        fsOps,
+        dirPath: skillsDir,
+        code: 'permission_denied',
+        label: 'OpenClaw skills directory'
+      })
+    },
+    {
+      name: 'workspace_dir_writable',
+      ...checkWritableDirectory({
+        fsOps,
+        dirPath: workspaceDir,
+        code: 'permission_denied',
+        label: 'OpenClaw workspace directory'
+      })
+    },
+    { name: 'openclaw_config', ...configCheck },
+    {
+      name: 'gateway_config_readiness',
+      ...checkGatewayReadiness({ config: configCheck.config, env })
+    }
+  ];
+
+  const issues = checks.filter((check) => !check.ok).map((check) => check.issue);
+  const warnings = checks
+    .flatMap((check) => {
+      const entries = [];
+      if (check.warning) {
+        entries.push(check.warning);
+      }
+      if (Array.isArray(check.warnings)) {
+        entries.push(...check.warnings);
+      }
+      return entries;
+    });
+
+  return {
+    ok: issues.length === 0,
+    checks,
+    issues,
+    warnings
+  };
+}
+
+module.exports = {
+  MIN_OPENCLAW_VERSION,
+  runPreflight,
+  TROUBLESHOOTING_DOC
+};

package/src/runtime/index.js

@@ -0,0 +1,127 @@
+const path = require('node:path');
+const fs = require('node:fs');
+const { loadRolePack } = require('./role-pack');
+const { loadState, saveState } = require('./state-store');
+const { handleMorning, handleMidday, handleEvening } = require('./productivity');
+const { sendViaGateway } = require('./openclaw-gateway');
+const { buildWeeklyReport } = require('./weekly-report');
+const { TROUBLESHOOTING_DOC } = require('../preflight');
+
+const DEFAULT_TASKS = [
+  'Define top priority',
+  'Complete one high-impact deliverable',
+  'Share progress update'
+];
+const SKILL_ID = 'clawpilot-productivity';
+
+function resolveStateFile({ stateFile, openClawHome }) {
+  if (stateFile) {
+    return path.resolve(stateFile);
+  }
+  if (openClawHome) {
+    return path.join(openClawHome, 'workspace', 'clawpilot-runtime-state.json');
+  }
+  return path.resolve('.clawpilot-state.json');
+}
+
+function readRuntimeConfig(openClawHome) {
+  if (!openClawHome) {
+    return {};
+  }
+
+  const configPath = path.join(openClawHome, 'openclaw.json');
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    return config.skills?.entries?.[SKILL_ID] || {};
+  } catch {
+    return {};
+  }
+}
+
+function createRuntimeError(code, reason, fix) {
+  const error = new Error(reason);
+  error.code = code;
+  error.reason = reason;
+  error.fix = fix;
+  error.docs = TROUBLESHOOTING_DOC;
+  return error;
+}
+
+async function runRuntimeCommand(options) {
+  const packageRoot = options.packageRoot || process.cwd();
+  const command = options.command || 'morning';
+  const runtimeConfig = readRuntimeConfig(options.openClawHome);
+  const configuredRolePack = runtimeConfig.runtime?.defaults?.rolePack || runtimeConfig.rolePack || 'hana';
+  const rolePack = loadRolePack(packageRoot, options.rolePack || configuredRolePack);
+  const stateFilePath = resolveStateFile(options);
+  const state = loadState(stateFilePath);
+  const dateKey = options.dateKey || new Date().toISOString().slice(0, 10);
+  const resolvedChannel = options.channel ?? runtimeConfig.delivery?.channel ?? null;
+
+  const handlers = {
+    morning: () =>
+      handleMorning({
+        dateKey,
+        state,
+        tasks: options.tasks && options.tasks.length > 0 ? options.tasks : DEFAULT_TASKS,
+        assistantName: rolePack.name
+      }),
+    midday: () =>
+      handleMidday({
+        dateKey,
+        state,
+        statuses: options.statuses || []
+      }),
+    evening: () =>
+      handleEvening({
+        dateKey,
+        state
+      }),
+    report: () =>
+      {
+        const report = buildWeeklyReport(state);
+        return {
+          message: `${rolePack.name} weekly report\n${report.summary}\nCompletion rate: ${report.completionRate}`
+        };
+      }
+  };
+
+  if (!handlers[command]) {
+    throw new Error(`Unsupported runtime command: ${command}`);
+  }
+
+  const result = handlers[command]();
+  saveState(stateFilePath, state);
+
+  if (!options.dryRun) {
+    if (!resolvedChannel) {
+      throw createRuntimeError(
+        'channel_required',
+        'Channel is required when sending without --dry-run.',
+        'Use --channel <target> or set delivery.channel in openclaw.json.'
+      );
+    }
+    sendViaGateway({
+      channel: resolvedChannel,
+      message: result.message,
+      media: rolePack.avatarUrl
+    });
+  }
+
+  return {
+    command,
+    rolePack,
+    message: result.message,
+    channel: resolvedChannel,
+    stateFile: stateFilePath,
+    deliveryMode: options.dryRun ? 'dry-run' : 'send'
+  };
+}
+
+module.exports = {
+  runRuntimeCommand
+};

package/src/runtime/openclaw-gateway.js

@@ -0,0 +1,135 @@
+const { spawnSync } = require('node:child_process');
+const { TROUBLESHOOTING_DOC } = require('../preflight');
+
+function buildGatewayArgs({ channel, message, media }) {
+  const args = [
+    'message',
+    'send',
+    '--action',
+    'send',
+    '--channel',
+    channel,
+    '--message',
+    message
+  ];
+
+  if (media) {
+    args.push('--media', media);
+  }
+
+  return args;
+}
+
+function classifyGatewayFailure(result = {}) {
+  const stderr = result.stderr || '';
+  const stdout = result.stdout || '';
+  const errorMessage = result.error && result.error.message ? result.error.message : '';
+  const errorCode = result.error && result.error.code ? result.error.code : '';
+  const text = `${stderr}\n${stdout}\n${errorMessage}`.toLowerCase();
+
+  if (errorCode === 'ENOENT' || /enoent|openclaw.*not found|is not recognized/.test(text)) {
+    return {
+      code: 'gateway_missing',
+      reason: 'OpenClaw CLI is not available.',
+      fix: 'Install OpenClaw and verify with: openclaw --version'
+    };
+  }
+
+  if (/invalid token|unauthorized|forbidden|401|403|auth/.test(text)) {
+    return {
+      code: 'auth_invalid',
+      reason: 'Gateway authentication failed.',
+      fix: 'Refresh gateway token and verify channel auth settings.'
+    };
+  }
+
+  if (/channel.*not found|chat.*not found|unknown channel|404/.test(text)) {
+    return {
+      code: 'channel_not_found',
+      reason: 'Target channel was not found.',
+      fix: 'Check --channel value and make sure the destination exists.'
+    };
+  }
+
+  if (/permission denied|eacces/.test(text)) {
+    return {
+      code: 'permission_denied',
+      reason: 'Permission denied while sending through gateway.',
+      fix: 'Grant required permissions to the OpenClaw process and channel.'
+    };
+  }
+
+  if (/gateway.*unavailable|gateway.*offline|connection refused|econnrefused/.test(text)) {
+    return {
+      code: 'gateway_unreachable',
+      reason: 'OpenClaw gateway is not reachable.',
+      fix: 'Start the gateway and verify endpoint connectivity.'
+    };
+  }
+
+  if (/timed?out|etimedout|enotfound|econnreset|network/.test(text)) {
+    return {
+      code: 'network_timeout',
+      reason: 'Network failure occurred while sending.',
+      fix: 'Retry the command and verify network/DNS connectivity.'
+    };
+  }
+
+  if (/invalid payload|bad request|missing required|400/.test(text)) {
+    return {
+      code: 'invalid_payload',
+      reason: 'Gateway rejected the payload.',
+      fix: 'Validate message/channel/media values before sending.'
+    };
+  }
+
+  if (/rate limit|too many requests|429/.test(text)) {
+    return {
+      code: 'rate_limited',
+      reason: 'Gateway or upstream provider rate-limited the request.',
+      fix: 'Retry with backoff and reduce send frequency.'
+    };
+  }
+
+  return {
+    code: 'unknown',
+    reason: 'Gateway send failed.',
+    fix: 'Check gateway logs and troubleshooting documentation.'
+  };
+}
+
+class GatewaySendError extends Error {
+  constructor({ code, reason, fix, result }) {
+    super(`${code}: ${reason}`);
+    this.name = 'GatewaySendError';
+    this.code = code;
+    this.reason = reason;
+    this.fix = fix;
+    this.docs = TROUBLESHOOTING_DOC;
+    this.status = result.status ?? null;
+    this.stderr = result.stderr || '';
+    this.stdout = result.stdout || '';
+  }
+}
+
+function sendViaGateway(payload, runner = spawnSync) {
+  const args = buildGatewayArgs(payload);
+  const result = runner('openclaw', args, { encoding: 'utf8' });
+
+  if (result.error || result.status !== 0) {
+    const failure = classifyGatewayFailure(result);
+    throw new GatewaySendError({
+      ...failure,
+      result
+    });
+  }
+
+  return result.stdout;
+}
+
+module.exports = {
+  buildGatewayArgs,
+  classifyGatewayFailure,
+  GatewaySendError,
+  sendViaGateway
+};

package/src/runtime/productivity.js

@@ -0,0 +1,42 @@
+const { ensureDayState } = require('./state-store');
+
+function handleMorning({ dateKey, state, tasks, assistantName }) {
+  const day = ensureDayState(state, dateKey);
+  day.tasks = tasks.map((title) => ({
+    title,
+    status: 'pending'
+  }));
+
+  return {
+    message: `${assistantName} morning plan:\n- ${tasks.join('\n- ')}`
+  };
+}
+
+function handleMidday({ dateKey, state, statuses }) {
+  const day = ensureDayState(state, dateKey);
+  day.tasks = day.tasks.map((task, index) => ({
+    ...task,
+    status: statuses[index] || task.status
+  }));
+
+  const blockedCount = day.tasks.filter((task) => task.status === 'blocked').length;
+
+  return {
+    message: `Midday check-in complete. blocked count: ${blockedCount}`
+  };
+}
+
+function handleEvening({ dateKey, state }) {
+  const day = ensureDayState(state, dateKey);
+  const doneCount = day.tasks.filter((task) => task.status === 'done').length;
+
+  return {
+    message: `Evening review: ${doneCount}/${day.tasks.length} done. First task for tomorrow: define priorities.`
+  };
+}
+
+module.exports = {
+  handleMorning,
+  handleMidday,
+  handleEvening
+};

package/src/runtime/role-pack.js

@@ -0,0 +1,11 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+function loadRolePack(packageRoot, name = 'hana') {
+  const rolePackPath = path.join(packageRoot, 'templates', 'role-packs', `${name}.json`);
+  return JSON.parse(fs.readFileSync(rolePackPath, 'utf8'));
+}
+
+module.exports = {
+  loadRolePack
+};

package/src/runtime/social-formatters.js

@@ -0,0 +1,22 @@
+function formatWins(wins) {
+  return wins.map((win) => `- ${win}`).join('\n');
+}
+
+function formatSocialPost(channel, data) {
+  const winsBlock = formatWins(data.wins || []);
+  const lesson = data.lesson || '';
+
+  if (channel === 'linkedin') {
+    return `Today I shipped:\n${winsBlock}\nKey lesson: ${lesson}`;
+  }
+
+  if (channel === 'x') {
+    return `Wins:\n${winsBlock}\nLesson: ${lesson}`;
+  }
+
+  return `Daily recap\n${winsBlock}\nLesson: ${lesson}`;
+}
+
+module.exports = {
+  formatSocialPost
+};

package/src/runtime/state-store.js

@@ -0,0 +1,33 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+function loadState(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return { days: {} };
+  }
+
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function saveState(filePath, state) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+function ensureDayState(state, dateKey) {
+  if (!state.days[dateKey]) {
+    state.days[dateKey] = {
+      tasks: [],
+      rescueSprintsUsed: 0,
+      notes: {}
+    };
+  }
+
+  return state.days[dateKey];
+}
+
+module.exports = {
+  loadState,
+  saveState,
+  ensureDayState
+};

package/src/runtime/template-renderer.js

@@ -0,0 +1,7 @@
+function renderTemplate(template, vars) {
+  return template.replace(/\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g, (_, key) => vars[key] ?? '');
+}
+
+module.exports = {
+  renderTemplate
+};

package/src/runtime/weekly-report.js

@@ -0,0 +1,19 @@
+function buildWeeklyReport(state) {
+  const days = state.days || {};
+  const tasks = Object.values(days).flatMap((day) => day.tasks || []);
+  const doneCount = tasks.filter((task) => task.status === 'done').length;
+  const blockedCount = tasks.filter((task) => task.status === 'blocked').length;
+  const totalCount = tasks.length;
+  const completionRate = totalCount > 0
+    ? `${Math.round((doneCount / totalCount) * 100)}%`
+    : '0%';
+
+  return {
+    completionRate,
+    summary: `Done: ${doneCount}, Blocked: ${blockedCount}, Total: ${totalCount}`
+  };
+}
+
+module.exports = {
+  buildWeeklyReport
+};

package/templates/content/evening.md

@@ -0,0 +1,7 @@
+Evening review with {{assistant_name}}.
+
+Completed: {{done_count}} / {{total_count}}
+Wins: {{wins}}
+Lesson: {{lesson}}
+
+Tomorrow first action: {{tomorrow_first_action}}

package/templates/content/midday.md

@@ -0,0 +1,8 @@
+Midday check-in from {{assistant_name}}.
+
+Status:
+- Task 1: {{status_1}}
+- Task 2: {{status_2}}
+- Task 3: {{status_3}}
+
+If blocked, pick one unblock action and run a 25-minute focus sprint.