nightytidy 0.1.0 → 0.2.0

package/README.md

@@ -309,6 +309,18 @@ GitHub Actions on every push/PR to master:
 | GUI Markdown | marked v17 (vendored UMD) |
 | Testing | Vitest v3 |
 
+## Web App (nightytidy.com)
+
+NightyTidy has a web dashboard at [nightytidy.com](https://nightytidy.com) for remote monitoring, scheduling, and analytics. Start the local agent to connect:
+
+```bash
+npx nightytidy agent
+```
+
+The agent runs on your machine at `127.0.0.1:48372`. The web app connects to it via WebSocket — your code never leaves your machine. Firebase handles authentication and stores run history so you can check status from any browser.
+
+**Source**: [nightytidy-web](https://github.com/dorianspitz23/nightytidy-web)
+
 ## License
 
 [MIT](LICENSE)

package/bin/nightytidy.js

@@ -1,3 +1,3 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import { run } from '../src/cli.js';
 run();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nightytidy",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Automated overnight codebase improvement through Claude Code",
   "license": "MIT",
   "author": "Dorian Spitz",
@@ -44,9 +44,11 @@
     "@inquirer/checkbox": "^5.1.0",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
+    "node-cron": "^4.2.1",
     "node-notifier": "^10.0.1",
     "ora": "^9.3.0",
-    "simple-git": "3.33.0"
+    "simple-git": "3.33.0",
+    "ws": "^8.19.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^3.2.4",

package/src/agent/cli-bridge.js

@@ -0,0 +1,138 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { debug, error as logError } from '../logger.js';
+
+export class CliBridge {
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+    this.activeProcess = null;
+  }
+
+  async listSteps() {
+    return this._run(CliBridge.buildArgs({ list: true }));
+  }
+
+  async initRun(steps, timeout) {
+    return this._run(CliBridge.buildArgs({ initRun: true, steps, timeout }));
+  }
+
+  async runStep(stepNum, onOutput) {
+    return this._run(CliBridge.buildArgs({ runStep: stepNum }), onOutput);
+  }
+
+  async finishRun() {
+    return this._run(CliBridge.buildArgs({ finishRun: true }));
+  }
+
+  kill() {
+    if (this.activeProcess) {
+      const pid = this.activeProcess.pid;
+      debug(`Killing CLI process ${pid}`);
+      if (process.platform === 'win32') {
+        spawn('taskkill', ['/F', '/T', '/PID', String(pid)]);
+      } else {
+        this.activeProcess.kill('SIGTERM');
+      }
+      this.activeProcess = null;
+    }
+  }
+
+  static buildArgs(opts) {
+    const args = [];
+    if (opts.list) {
+      args.push('--list', '--json');
+    }
+    if (opts.initRun) {
+      args.push('--init-run');
+      args.push('--skip-dashboard');
+      args.push('--skip-sync');
+      if (opts.steps) args.push('--steps', opts.steps.join(','));
+      if (opts.timeout) args.push('--timeout', String(opts.timeout));
+    }
+    if (opts.runStep !== undefined) {
+      args.push('--run-step', String(opts.runStep));
+    }
+    if (opts.finishRun) {
+      args.push('--finish-run');
+    }
+    return args;
+  }
+
+  static parseOutput(stdout) {
+    const lines = stdout.trim().split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (line.startsWith('{') || line.startsWith('[')) {
+        try {
+          return JSON.parse(line);
+        } catch { /* continue */ }
+      }
+    }
+    return null;
+  }
+
+  _run(args, onOutput) {
+    return new Promise((resolve, reject) => {
+      const binPath = path.resolve(import.meta.dirname, '../../bin/nightytidy.js');
+      const proc = spawn('node', [binPath, ...args], {
+        cwd: this.projectDir,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      this.activeProcess = proc;
+
+      let stdout = '';
+      let stderr = '';
+
+      proc.stdout.on('data', (data) => {
+        const text = data.toString();
+        stdout += text;
+        // Filter the final JSON result line from streaming output — it's the
+        // orchestrator's return value, not Claude's output. The parsed result
+        // is extracted separately by parseOutput() after process close.
+        if (onOutput) {
+          const trimmed = text.trim();
+          if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+            try {
+              const obj = JSON.parse(trimmed);
+              if ('success' in obj && ('step' in obj || 'error' in obj)) return;
+            } catch { /* not JSON, forward as normal output */ }
+          }
+          onOutput(text);
+        }
+      });
+
+      proc.stderr.on('data', (data) => {
+        const text = data.toString();
+        stderr += text;
+        // Filter Node.js ExperimentalWarning noise before forwarding to UI
+        if (onOutput && !text.includes('ExperimentalWarning') && !text.includes('--experimental-')) {
+          onOutput(text);
+        }
+      });
+
+      proc.on('close', (code) => {
+        this.activeProcess = null;
+        const parsed = CliBridge.parseOutput(stdout);
+        resolve({
+          success: code === 0,
+          exitCode: code,
+          stdout,
+          stderr,
+          parsed,
+        });
+      });
+
+      proc.on('error', (err) => {
+        this.activeProcess = null;
+        logError(`CLI process error: ${err.message}`);
+        resolve({
+          success: false,
+          exitCode: -1,
+          stdout,
+          stderr: err.message,
+          parsed: null,
+        });
+      });
+    });
+  }
+}

package/src/agent/config.js

@@ -0,0 +1,51 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { debug } from '../logger.js';
+
+export const CONFIG_VERSION = 1;
+const CONFIG_FILE = 'config.json';
+
+export function getConfigDir() {
+  return path.join(os.homedir(), '.nightytidy');
+}
+
+export function ensureConfigDir(configDir) {
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+    debug(`Created config directory: ${configDir}`);
+  }
+}
+
+export function readConfig(configDir) {
+  const filePath = path.join(configDir, CONFIG_FILE);
+  try {
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    if (data.version === CONFIG_VERSION) return data;
+    debug(`Config version mismatch: ${data.version} → ${CONFIG_VERSION}, migrating`);
+    return migrateConfig(data);
+  } catch {
+    return createDefaultConfig();
+  }
+}
+
+export function writeConfig(configDir, config) {
+  ensureConfigDir(configDir);
+  const filePath = path.join(configDir, CONFIG_FILE);
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
+}
+
+function createDefaultConfig() {
+  return {
+    version: CONFIG_VERSION,
+    port: 48372,
+    token: crypto.randomBytes(24).toString('hex'),
+    machine: os.hostname(),
+  };
+}
+
+function migrateConfig(data) {
+  // Future migrations go here
+  return { ...createDefaultConfig(), ...data, version: CONFIG_VERSION };
+}

package/src/agent/firebase-auth.js

@@ -0,0 +1,61 @@
+import { debug, info, warn } from '../logger.js';
+
+const REFRESH_BUFFER_MS = 15 * 60_000; // Request refresh 15 min before expiry
+
+export class FirebaseAuth {
+  constructor(configDir) {
+    this.configDir = configDir;
+    this.token = null;
+    this.expiresAt = null;
+    this._refreshRequested = false;
+  }
+
+  isAuthenticated() {
+    return this.token !== null && this.expiresAt > Date.now();
+  }
+
+  getToken() {
+    if (!this.isAuthenticated()) return null;
+    return this.token;
+  }
+
+  setToken(token, expiresAt) {
+    this.token = token;
+    this.expiresAt = expiresAt;
+    this._refreshRequested = false;
+    debug('Firebase auth token updated');
+  }
+
+  getAuthHeader() {
+    const token = this.getToken();
+    if (!token) return {};
+    return { Authorization: `Bearer ${token}` };
+  }
+
+  /**
+   * Returns true if the token is within REFRESH_BUFFER_MS of expiry
+   * and a refresh has not already been requested.
+   */
+  needsRefresh() {
+    if (!this.token || !this.expiresAt) return false;
+    if (this._refreshRequested) return false;
+    return this.expiresAt - Date.now() < REFRESH_BUFFER_MS;
+  }
+
+  /**
+   * Mark that a refresh has been requested so we don't spam requests.
+   * Cleared when setToken() is called with a new token.
+   */
+  markRefreshRequested() {
+    this._refreshRequested = true;
+    debug('Firebase auth token refresh requested');
+  }
+
+  // Full OAuth flow will be implemented in integration phase
+  // For now, this is a placeholder that stores/retrieves tokens
+  async authenticate() {
+    info('Firebase authentication required — browser OAuth flow needed');
+    // TODO: Open browser to nightytidy.com/auth/agent, receive token via callback
+    return false;
+  }
+}

package/src/agent/git-integration.js

@@ -0,0 +1,77 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { debug, warn } from '../logger.js';
+
+const execFileAsync = promisify(execFile);
+
+export class AgentGit {
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+  }
+
+  async getDiffStat(baseBranch, runBranch) {
+    return this._exec('git', ['diff', '--stat', `${baseBranch}...${runBranch}`]);
+  }
+
+  async getDiff(baseBranch, runBranch) {
+    return this._exec('git', ['diff', `${baseBranch}...${runBranch}`]);
+  }
+
+  async countFilesChanged(baseBranch, runBranch) {
+    const output = await this._exec('git', ['diff', '--name-only', `${baseBranch}...${runBranch}`]);
+    return output.trim().split('\n').filter(Boolean).length;
+  }
+
+  async rollback(tag) {
+    // Safety: verify tag exists and is a nightytidy tag
+    const tagExists = (await this._exec('git', ['tag', '-l', tag])).trim();
+    if (!tagExists || !tag.startsWith('nightytidy-before-')) {
+      throw new Error(`Invalid rollback tag: ${tag}`);
+    }
+    debug(`Rolling back to tag: ${tag}`);
+    await this._exec('git', ['reset', '--hard', tag]);
+  }
+
+  async createPr(branch, title, body) {
+    try {
+      // Use execFile with args array to prevent command injection
+      const result = await this._exec('gh', [
+        'pr', 'create', '--head', branch, '--title', title, '--body', body,
+      ]);
+      const url = result.trim().split('\n').pop();
+      return { success: true, url };
+    } catch (err) {
+      warn(`PR creation failed: ${err.message}`);
+      return { success: false, error: err.message };
+    }
+  }
+
+  async merge(runBranch, targetBranch) {
+    try {
+      await this._exec('git', ['checkout', targetBranch]);
+      await this._exec('git', ['merge', runBranch, '--no-edit']);
+      return { success: true };
+    } catch (err) {
+      // Abort failed merge
+      try { await this._exec('git', ['merge', '--abort']); } catch { /* ignore */ }
+      return { success: false, conflict: true, error: err.message };
+    }
+  }
+
+  async getReport(branch) {
+    // List files matching NIGHTYTIDY-REPORT*.md on the branch
+    const lsOutput = await this._exec('git', ['ls-tree', '--name-only', branch]);
+    const reportFile = lsOutput.trim().split('\n')
+      .filter(f => f.startsWith('NIGHTYTIDY-REPORT') && f.endsWith('.md'))
+      .sort()
+      .pop(); // Take the latest (highest numbered)
+    if (!reportFile) return null;
+    const content = await this._exec('git', ['show', `${branch}:${reportFile}`]);
+    return { filename: reportFile, content };
+  }
+
+  async _exec(cmd, args) {
+    const { stdout } = await execFileAsync(cmd, args, { cwd: this.projectDir });
+    return stdout;
+  }
+}