@masslessai/push-todo 3.0.0

package/lib/machine-id.js

@@ -0,0 +1,101 @@
+/**
+ * Machine Identification for Push CLI.
+ *
+ * Generates and persists a unique machine identifier used for:
+ * - Atomic task claiming (prevents multi-Mac race conditions)
+ * - Task attribution (which Mac executed a task)
+ * - Worktree naming (prevents branch conflicts)
+ *
+ * File location: ~/.config/push/machine_id
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { homedir, hostname, platform, release, version, arch } from 'os';
+import { join, dirname } from 'path';
+import { randomUUID } from 'crypto';
+
+const MACHINE_ID_FILE = join(homedir(), '.config', 'push', 'machine_id');
+
+/**
+ * Get or create a unique machine identifier.
+ *
+ * Format: "{hostname}-{random_hex}"
+ * Example: "Yuxiang-MacBook-Pro-a1b2c3d4"
+ *
+ * The ID is persisted to disk and reused across sessions.
+ *
+ * @returns {string} Unique machine identifier
+ */
+export function getMachineId() {
+  // Try to read existing ID
+  if (existsSync(MACHINE_ID_FILE)) {
+    try {
+      const storedId = readFileSync(MACHINE_ID_FILE, 'utf8').trim();
+      if (storedId) {
+        return storedId;
+      }
+    } catch {
+      // Fall through to generate new ID
+    }
+  }
+
+  // Generate new ID: hostname + random suffix
+  const host = hostname(); // e.g., "Yuxiang-MacBook-Pro"
+  const randomSuffix = randomUUID().slice(0, 8); // e.g., "a1b2c3d4"
+  const machineId = `${host}-${randomSuffix}`;
+
+  // Persist to disk
+  try {
+    mkdirSync(dirname(MACHINE_ID_FILE), { recursive: true });
+    writeFileSync(MACHINE_ID_FILE, machineId);
+  } catch {
+    // If we can't persist, still return the ID for this session
+  }
+
+  return machineId;
+}
+
+/**
+ * Get human-readable machine name.
+ *
+ * Returns the hostname without the random suffix.
+ * Example: "Yuxiang-MacBook-Pro"
+ *
+ * @returns {string} Human-readable machine name
+ */
+export function getMachineName() {
+  return hostname();
+}
+
+/**
+ * Get full machine information for debugging.
+ *
+ * @returns {Object} Machine info
+ */
+export function getMachineInfo() {
+  return {
+    machineId: getMachineId(),
+    machineName: getMachineName(),
+    platform: platform(),      // "darwin" for macOS
+    release: release(),        // OS kernel version
+    version: version(),        // OS version string
+    arch: arch(),              // "arm64" or "x64"
+  };
+}
+
+/**
+ * Delete the stored machine ID (for testing/debugging).
+ * The next call to getMachineId() will generate a new ID.
+ */
+export function resetMachineId() {
+  if (existsSync(MACHINE_ID_FILE)) {
+    try {
+      const { unlinkSync } = require('fs');
+      unlinkSync(MACHINE_ID_FILE);
+    } catch {
+      // Ignore errors
+    }
+  }
+}
+
+export { MACHINE_ID_FILE };

package/lib/project-registry.js

@@ -0,0 +1,279 @@
+/**
+ * Project Registry for Push CLI.
+ *
+ * Maps git_remote to local paths for global daemon routing.
+ * Enables the daemon to route tasks to the correct project directory.
+ *
+ * File location: ~/.config/push/projects.json
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, statSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const REGISTRY_FILE = join(homedir(), '.config', 'push', 'projects.json');
+const REGISTRY_VERSION = 1;
+
+/**
+ * Project Registry class.
+ * Manages the local project registry for global daemon routing.
+ */
+class ProjectRegistry {
+  constructor() {
+    this._ensureConfigDir();
+    this._data = this._load();
+  }
+
+  _ensureConfigDir() {
+    const dir = join(homedir(), '.config', 'push');
+    mkdirSync(dir, { recursive: true });
+  }
+
+  _load() {
+    if (!existsSync(REGISTRY_FILE)) {
+      return {
+        version: REGISTRY_VERSION,
+        projects: {},
+        defaultProject: null
+      };
+    }
+
+    try {
+      const content = readFileSync(REGISTRY_FILE, 'utf8');
+      const data = JSON.parse(content);
+
+      // Migration: handle older versions if needed
+      if ((data.version || 0) < REGISTRY_VERSION) {
+        return this._migrate(data);
+      }
+
+      return data;
+    } catch {
+      return {
+        version: REGISTRY_VERSION,
+        projects: {},
+        defaultProject: null
+      };
+    }
+  }
+
+  _save() {
+    writeFileSync(REGISTRY_FILE, JSON.stringify(this._data, null, 2));
+  }
+
+  _migrate(data) {
+    // Future: handle migrations as needed
+    data.version = REGISTRY_VERSION;
+    return data;
+  }
+
+  /**
+   * Register a project.
+   *
+   * @param {string} gitRemote - Normalized git remote (e.g., "github.com/user/repo")
+   * @param {string} localPath - Absolute local path
+   * @returns {boolean} True if newly registered, false if updated existing
+   */
+  register(gitRemote, localPath) {
+    const isNew = !(gitRemote in this._data.projects);
+    const now = new Date().toISOString();
+
+    if (isNew) {
+      this._data.projects[gitRemote] = {
+        localPath,
+        registeredAt: now,
+        lastUsed: now
+      };
+    } else {
+      this._data.projects[gitRemote].localPath = localPath;
+      this._data.projects[gitRemote].lastUsed = now;
+    }
+
+    // Set as default if first project
+    if (this._data.defaultProject === null) {
+      this._data.defaultProject = gitRemote;
+    }
+
+    this._save();
+    return isNew;
+  }
+
+  /**
+   * Get local path for a git remote.
+   * Updates lastUsed timestamp.
+   *
+   * @param {string} gitRemote - Normalized git remote
+   * @returns {string|null} Local path or null if not registered
+   */
+  getPath(gitRemote) {
+    const project = this._data.projects[gitRemote];
+    if (project) {
+      // Update last_used
+      project.lastUsed = new Date().toISOString();
+      this._save();
+      return project.localPath;
+    }
+    return null;
+  }
+
+  /**
+   * Get local path without updating lastUsed.
+   * Useful for status checks and listing operations.
+   *
+   * @param {string} gitRemote - Normalized git remote
+   * @returns {string|null} Local path or null if not registered
+   */
+  getPathWithoutUpdate(gitRemote) {
+    const project = this._data.projects[gitRemote];
+    return project ? project.localPath : null;
+  }
+
+  /**
+   * List all registered projects.
+   *
+   * @returns {Object} Dict of gitRemote -> localPath
+   */
+  listProjects() {
+    const result = {};
+    for (const [remote, info] of Object.entries(this._data.projects)) {
+      result[remote] = info.localPath;
+    }
+    return result;
+  }
+
+  /**
+   * List all registered projects with full metadata.
+   *
+   * @returns {Object} Dict of gitRemote -> {localPath, registeredAt, lastUsed}
+   */
+  listProjectsWithMetadata() {
+    return { ...this._data.projects };
+  }
+
+  /**
+   * Unregister a project.
+   *
+   * @param {string} gitRemote - Normalized git remote
+   * @returns {boolean} True if was registered, false if not found
+   */
+  unregister(gitRemote) {
+    if (gitRemote in this._data.projects) {
+      delete this._data.projects[gitRemote];
+
+      if (this._data.defaultProject === gitRemote) {
+        // Set new default
+        const remaining = Object.keys(this._data.projects);
+        this._data.defaultProject = remaining.length > 0 ? remaining[0] : null;
+      }
+
+      this._save();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get the default project's git remote.
+   *
+   * @returns {string|null}
+   */
+  getDefaultProject() {
+    return this._data.defaultProject;
+  }
+
+  /**
+   * Set a project as the default.
+   *
+   * @param {string} gitRemote
+   * @returns {boolean} True if successful
+   */
+  setDefaultProject(gitRemote) {
+    if (gitRemote in this._data.projects) {
+      this._data.defaultProject = gitRemote;
+      this._save();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Return the number of registered projects.
+   *
+   * @returns {number}
+   */
+  projectCount() {
+    return Object.keys(this._data.projects).length;
+  }
+
+  /**
+   * Check if a project is registered.
+   *
+   * @param {string} gitRemote
+   * @returns {boolean}
+   */
+  isRegistered(gitRemote) {
+    return gitRemote in this._data.projects;
+  }
+
+  /**
+   * Validate that all registered paths still exist.
+   *
+   * @returns {Array} List of invalid entries
+   */
+  validatePaths() {
+    const invalid = [];
+
+    for (const [gitRemote, info] of Object.entries(this._data.projects)) {
+      const path = info.localPath;
+
+      try {
+        const stats = statSync(path);
+        if (!stats.isDirectory()) {
+          invalid.push({
+            gitRemote,
+            localPath: path,
+            reason: 'not_a_directory'
+          });
+        } else if (!existsSync(join(path, '.git'))) {
+          invalid.push({
+            gitRemote,
+            localPath: path,
+            reason: 'not_a_git_repo'
+          });
+        }
+      } catch {
+        invalid.push({
+          gitRemote,
+          localPath: path,
+          reason: 'path_not_found'
+        });
+      }
+    }
+
+    return invalid;
+  }
+}
+
+// Singleton instance
+let _registry = null;
+
+/**
+ * Get the singleton registry instance.
+ *
+ * @returns {ProjectRegistry}
+ */
+export function getRegistry() {
+  if (_registry === null) {
+    _registry = new ProjectRegistry();
+  }
+  return _registry;
+}
+
+/**
+ * Reset the singleton (for testing).
+ */
+export function resetRegistry() {
+  _registry = null;
+}
+
+export { ProjectRegistry, REGISTRY_FILE };

package/lib/utils/colors.js

@@ -0,0 +1,126 @@
+/**
+ * Terminal color utilities for Push CLI.
+ *
+ * ANSI escape codes for terminal styling.
+ * Automatically disables colors when not outputting to a TTY.
+ */
+
+const isColorEnabled = process.stdout.isTTY && !process.env.NO_COLOR;
+
+/**
+ * ANSI escape codes.
+ */
+export const codes = {
+  // Reset
+  reset: '\x1b[0m',
+
+  // Styles
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+
+  // Colors
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+
+  // Bright colors
+  brightBlack: '\x1b[90m',
+  brightRed: '\x1b[91m',
+  brightGreen: '\x1b[92m',
+  brightYellow: '\x1b[93m',
+  brightBlue: '\x1b[94m',
+  brightMagenta: '\x1b[95m',
+  brightCyan: '\x1b[96m',
+  brightWhite: '\x1b[97m',
+
+  // Background colors
+  bgBlack: '\x1b[40m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m',
+
+  // Cursor control
+  clearScreen: '\x1b[2J',
+  cursorHome: '\x1b[H',
+  hideCursor: '\x1b[?25l',
+  showCursor: '\x1b[?25h',
+  clearLine: '\x1b[2K',
+  cursorUp: '\x1b[1A',
+  cursorDown: '\x1b[1B',
+};
+
+/**
+ * Wrap text with color codes.
+ *
+ * @param {string} text - Text to color
+ * @param {string} code - ANSI code
+ * @returns {string} Colored text (or plain text if colors disabled)
+ */
+function wrap(text, code) {
+  if (!isColorEnabled) {
+    return text;
+  }
+  return `${code}${text}${codes.reset}`;
+}
+
+// Style functions
+export const bold = (text) => wrap(text, codes.bold);
+export const dim = (text) => wrap(text, codes.dim);
+export const italic = (text) => wrap(text, codes.italic);
+export const underline = (text) => wrap(text, codes.underline);
+
+// Color functions
+export const red = (text) => wrap(text, codes.red);
+export const green = (text) => wrap(text, codes.green);
+export const yellow = (text) => wrap(text, codes.yellow);
+export const blue = (text) => wrap(text, codes.blue);
+export const magenta = (text) => wrap(text, codes.magenta);
+export const cyan = (text) => wrap(text, codes.cyan);
+export const white = (text) => wrap(text, codes.white);
+
+// Bright color functions
+export const brightRed = (text) => wrap(text, codes.brightRed);
+export const brightGreen = (text) => wrap(text, codes.brightGreen);
+export const brightYellow = (text) => wrap(text, codes.brightYellow);
+export const brightBlue = (text) => wrap(text, codes.brightBlue);
+export const brightCyan = (text) => wrap(text, codes.brightCyan);
+
+// Combined styles
+export const error = (text) => wrap(text, codes.red);
+export const success = (text) => wrap(text, codes.green);
+export const warning = (text) => wrap(text, codes.yellow);
+export const info = (text) => wrap(text, codes.cyan);
+export const muted = (text) => wrap(text, codes.dim);
+
+/**
+ * Status indicator symbols with colors.
+ */
+export const symbols = {
+  running: isColorEnabled ? `${codes.green}●${codes.reset}` : '*',
+  queued: isColorEnabled ? `${codes.yellow}○${codes.reset}` : 'o',
+  completed: isColorEnabled ? `${codes.green}✓${codes.reset}` : '+',
+  failed: isColorEnabled ? `${codes.red}✗${codes.reset}` : 'x',
+  timeout: isColorEnabled ? `${codes.red}⏱${codes.reset}` : 'T',
+  backlog: isColorEnabled ? `${codes.blue}📦${codes.reset}` : '[B]',
+  pinned: isColorEnabled ? `${codes.yellow}📌${codes.reset}` : '[P]',
+};
+
+/**
+ * Check if colors are enabled.
+ *
+ * @returns {boolean}
+ */
+export function colorsEnabled() {
+  return isColorEnabled;
+}