@qelos/aidev 0.1.0 → 0.1.1

package/src/commands/schedule.ts

@@ -1,179 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import * as readline from 'node:readline/promises';
-import { stdin as input, stdout as output } from 'node:process';
-import { logger } from '../logger';
-import { isWindows, findBin } from '../platform';
-import chalk from 'chalk';
-
-// ─── Preset schedules ────────────────────────────────────────────────────────
-
-const PRESETS: Array<{ label: string; cron: string }> = [
-  { label: 'Every 15 minutes', cron: '*/15 * * * *' },
-  { label: 'Every 30 minutes', cron: '*/30 * * * *' },
-  { label: 'Every hour',       cron: '0 * * * *'    },
-  { label: 'Every 5 hours',    cron: '0 */5 * * *'  },
-  { label: 'Every day at 8am', cron: '0 8 * * *'    },
-];
-
-async function pickCron(): Promise<string> {
-  console.log('\n  Select a schedule:');
-  PRESETS.forEach((p, i) =>
-    console.log(`    ${chalk.cyan(String(i + 1))}. ${p.label}  ${chalk.dim(p.cron)}`)
-  );
-
-  const rl = readline.createInterface({ input, output });
-  try {
-    while (true) {
-      const raw = await rl.question(`\n  Choice ${chalk.dim('[1]')}: `);
-      const val = raw.trim() || '1';
-      const idx = parseInt(val, 10);
-      if (idx >= 1 && idx <= PRESETS.length) return PRESETS[idx - 1].cron;
-      console.log(chalk.yellow(`  Enter a number between 1 and ${PRESETS.length}.`));
-    }
-  } finally {
-    rl.close();
-  }
-}
-
-// ─── Shared helpers ───────────────────────────────────────────────────────────
-
-function getAidevBin(): string {
-  return findBin('aidev') ?? 'aidev';
-}
-
-// ─── Unix (crontab) ───────────────────────────────────────────────────────────
-
-const UNIX_MARKER_PREFIX = '# aidev-cwd:';
-
-function getCrontab(): string {
-  const result = spawnSync('crontab', ['-l'], { encoding: 'utf8' });
-  return result.status === 0 ? result.stdout || '' : '';
-}
-
-function setCrontab(content: string): boolean {
-  const result = spawnSync('crontab', ['-'], { input: content, encoding: 'utf8' });
-  return result.status === 0;
-}
-
-function scheduleSetUnix(cronExpr: string): void {
-  const cwd = process.cwd();
-  const marker = `${UNIX_MARKER_PREFIX}${cwd}`;
-  const aidevBin = getAidevBin();
-  const newLine = `${cronExpr} cd ${cwd} && ${aidevBin} run ${marker}`;
-
-  const lines = getCrontab().split('\n').filter((l) => !l.includes(marker));
-  lines.push(newLine);
-  const updated = lines.join('\n').replace(/\n+$/, '') + '\n';
-
-  if (setCrontab(updated)) {
-    logger.success(`Cron schedule set: ${cronExpr}`);
-    logger.info(`Entry: ${newLine}`);
-  } else {
-    logger.error('Failed to update crontab');
-    process.exit(1);
-  }
-}
-
-function scheduleGetUnix(): void {
-  const cwd = process.cwd();
-  const marker = `${UNIX_MARKER_PREFIX}${cwd}`;
-  const entry = getCrontab().split('\n').find((l) => l.includes(marker));
-
-  if (entry) {
-    logger.info(`Current schedule for ${cwd}:`);
-    console.log(entry);
-  } else {
-    logger.warn(`No schedule found for ${cwd}`);
-    logger.info('Use "aidev schedule set" to configure one.');
-  }
-}
-
-// ─── Windows (schtasks) ───────────────────────────────────────────────────────
-
-/**
- * Converts a cron expression to schtasks /sc + /mo + /st arguments.
- * Supports the subset used by the preset list.
- */
-function cronToSchtasksArgs(cron: string): string[] | null {
-  // */N * * * *  →  every N minutes
-  const everyMin = cron.match(/^\*\/(\d+) \* \* \* \*$/);
-  if (everyMin) return ['/sc', 'MINUTE', '/mo', everyMin[1]];
-
-  // 0 * * * *  →  every hour
-  if (cron === '0 * * * *') return ['/sc', 'HOURLY', '/mo', '1'];
-
-  // 0 */N * * *  →  every N hours
-  const everyHour = cron.match(/^0 \*\/(\d+) \* \* \*$/);
-  if (everyHour) return ['/sc', 'HOURLY', '/mo', everyHour[1]];
-
-  // 0 H * * *  →  daily at H:00
-  const daily = cron.match(/^0 (\d+) \* \* \*$/);
-  if (daily) return ['/sc', 'DAILY', '/st', `${daily[1].padStart(2, '0')}:00`];
-
-  return null;
-}
-
-/** Stable task name derived from cwd — safe for Task Scheduler. */
-function windowsTaskName(cwd: string): string {
-  const sanitized = cwd.replace(/[:\\\/]+/g, '-').replace(/^-+|-+$/g, '');
-  return `aidev\\${sanitized}`;
-}
-
-function scheduleSetWindows(cronExpr: string): void {
-  const cwd = process.cwd();
-  const schtasksArgs = cronToSchtasksArgs(cronExpr);
-  if (!schtasksArgs) {
-    logger.error(
-      `Cron expression "${cronExpr}" cannot be mapped to Windows Task Scheduler.\n` +
-      '  Use "aidev schedule set" (no argument) to choose a supported preset.'
-    );
-    process.exit(1);
-  }
-
-  const taskName = windowsTaskName(cwd);
-  const aidevBin = getAidevBin();
-  // cmd /c: run command and exit; /d: change drive+dir
-  const command = `cmd /c cd /d "${cwd}" && "${aidevBin}" run`;
-
-  const result = spawnSync(
-    'schtasks',
-    ['/create', '/f', '/tn', taskName, '/tr', command, ...schtasksArgs],
-    { encoding: 'utf8' }
-  );
-
-  if (result.status === 0) {
-    logger.success(`Task Scheduler entry created: ${taskName}`);
-    logger.info(`Schedule: ${cronExpr}`);
-  } else {
-    logger.error(`Failed to create Task Scheduler entry:\n${result.stderr}`);
-    process.exit(1);
-  }
-}
-
-function scheduleGetWindows(): void {
-  const cwd = process.cwd();
-  const taskName = windowsTaskName(cwd);
-
-  const result = spawnSync('schtasks', ['/query', '/tn', taskName, '/fo', 'LIST'], {
-    encoding: 'utf8',
-  });
-
-  if (result.status === 0) {
-    logger.info(`Task Scheduler entry for ${cwd}:`);
-    console.log(result.stdout.trim());
-  } else {
-    logger.warn(`No Task Scheduler entry found for ${cwd}`);
-    logger.info('Use "aidev schedule set" to configure one.');
-  }
-}
-
-// ─── Public API ───────────────────────────────────────────────────────────────
-
-export async function scheduleSetCommand(cronExpr?: string): Promise<void> {
-  if (!cronExpr) cronExpr = await pickCron();
-  isWindows ? scheduleSetWindows(cronExpr) : scheduleSetUnix(cronExpr);
-}
-
-export async function scheduleGetCommand(): Promise<void> {
-  isWindows ? scheduleGetWindows() : scheduleGetUnix();
-}

package/src/config.ts

@@ -1,59 +0,0 @@
-import * as dotenv from 'dotenv';
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-import { Config, AgentName } from './types';
-import { detectRemote } from './git';
-
-export function loadConfig(customEnvPath?: string): Config {
-  const envPath = customEnvPath
-    ? path.resolve(customEnvPath)
-    : path.join(process.cwd(), '.env.aidev');
-
-  if (customEnvPath && !fs.existsSync(envPath)) {
-    throw new Error(`Env file not found: ${envPath}`);
-  }
-  if (fs.existsSync(envPath)) {
-    dotenv.config({ path: envPath });
-  }
-
-  const required = ['CLICKUP_API_KEY', 'CLICKUP_TEAM_ID', 'CLICKUP_TAG'];
-  for (const key of required) {
-    if (!process.env[key]) {
-      throw new Error(`Missing required config: ${key}. Run 'aidev init' to create .env.aidev`);
-    }
-  }
-
-  const validAgents: AgentName[] = ['claude', 'cursor'];
-  const agentsRaw = process.env.AGENTS || 'claude,cursor';
-  const agents = agentsRaw
-    .split(',')
-    .map((s) => s.trim().toLowerCase())
-    .filter(Boolean) as AgentName[];
-  const invalid = agents.filter((a) => !validAgents.includes(a));
-  if (invalid.length) {
-    throw new Error(`Invalid agent(s): ${invalid.join(', ')}. Valid: ${validAgents.join(', ')}`);
-  }
-  if (agents.length === 0) {
-    throw new Error(`AGENTS must contain at least one agent. Valid: ${validAgents.join(', ')}`);
-  }
-
-  const devNotesMode = (process.env.DEV_NOTES_MODE || 'smart') as Config['devNotesMode'];
-  if (!['smart', 'always'].includes(devNotesMode)) {
-    throw new Error(`Invalid DEV_NOTES_MODE: ${devNotesMode}. Must be smart or always`);
-  }
-
-  return {
-    provider: process.env.PROVIDER || 'clickup',
-    clickupApiKey: process.env.CLICKUP_API_KEY!,
-    clickupTeamId: process.env.CLICKUP_TEAM_ID!,
-    clickupTag: process.env.CLICKUP_TAG!,
-    clickupPendingStatus: process.env.CLICKUP_PENDING_STATUS || 'pending',
-    clickupInReviewStatus: process.env.CLICKUP_IN_REVIEW_STATUS || 'review',
-    assigneeTag: process.env.ASSIGNEE_TAG || '',
-    gitRemote: process.env.GIT_REMOTE || detectRemote() || 'origin',
-    githubBaseBranch: process.env.GITHUB_BASE_BRANCH || 'main',
-    githubRepo: process.env.GITHUB_REPO || '',
-    agents,
-    devNotesMode,
-  };
-}

package/src/git.ts

@@ -1,109 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { logger } from './logger';
-
-function git(args: string[], cwd?: string): { stdout: string; stderr: string; status: number } {
-  const result = spawnSync('git', args, {
-    cwd: cwd || process.cwd(),
-    encoding: 'utf8',
-  });
-  return {
-    stdout: result.stdout || '',
-    stderr: result.stderr || '',
-    status: result.status ?? 1,
-  };
-}
-
-export function remoteBranchExists(remote: string, branch: string): boolean {
-  const result = git(['ls-remote', '--heads', remote, branch]);
-  return result.status === 0 && result.stdout.trim().length > 0;
-}
-
-export function fetchAndCheckout(remote: string, baseBranch: string): boolean {
-  logger.debug(`git fetch ${remote}`);
-  const fetch = git(['fetch', remote]);
-  if (fetch.status !== 0) {
-    logger.error(`git fetch failed: ${fetch.stderr}`);
-    return false;
-  }
-
-  logger.debug(`git checkout ${baseBranch}`);
-  const checkout = git(['checkout', baseBranch]);
-  if (checkout.status !== 0) {
-    logger.error(`git checkout ${baseBranch} failed: ${checkout.stderr}`);
-    return false;
-  }
-
-  logger.debug(`git pull ${remote} ${baseBranch}`);
-  const pull = git(['pull', remote, baseBranch]);
-  if (pull.status !== 0) {
-    logger.error(`git pull failed: ${pull.stderr}`);
-    return false;
-  }
-
-  return true;
-}
-
-export function createBranch(branch: string): boolean {
-  logger.debug(`git checkout -b ${branch}`);
-  const result = git(['checkout', '-b', branch]);
-  if (result.status !== 0) {
-    logger.error(`git checkout -b ${branch} failed: ${result.stderr}`);
-    return false;
-  }
-  return true;
-}
-
-export function hasChanges(): boolean {
-  const result = git(['status', '--porcelain']);
-  return result.status === 0 && result.stdout.trim().length > 0;
-}
-
-export function addAll(): boolean {
-  const result = git(['add', '-A']);
-  return result.status === 0;
-}
-
-export function commit(message: string): boolean {
-  logger.debug(`git commit -m "${message}"`);
-  const result = git(['commit', '-m', message]);
-  if (result.status !== 0) {
-    logger.error(`git commit failed: ${result.stderr}`);
-    return false;
-  }
-  return true;
-}
-
-export function push(remote: string, branch: string): boolean {
-  logger.debug(`git push ${remote} ${branch}`);
-  const result = git(['push', remote, branch]);
-  if (result.status !== 0) {
-    logger.error(`git push failed: ${result.stderr}`);
-    return false;
-  }
-  return true;
-}
-
-export function deleteBranch(branch: string): void {
-  git(['checkout', '-']);
-  git(['branch', '-D', branch]);
-}
-
-/** Returns the name of the first usable remote (prefers origin). */
-export function detectRemote(): string | null {
-  // Verify origin exists first
-  const originCheck = git(['remote', 'get-url', 'origin']);
-  if (originCheck.status === 0) return 'origin';
-
-  // Fall back to first listed remote
-  const list = git(['remote']);
-  const first = list.stdout.trim().split('\n')[0]?.trim();
-  return first || null;
-}
-
-export function slugify(text: string): string {
-  return text
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-|-$/g, '')
-    .slice(0, 50);
-}

package/src/logger.ts

@@ -1,53 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import chalk from 'chalk';
-
-const LOG_FILE = path.join(process.cwd(), 'aidev.log');
-
-// Strip ANSI escape codes for clean file output
-function strip(s: string): string {
-  return s.replace(/\x1B\[[0-9;]*m/g, '');
-}
-
-function timestamp(): string {
-  return new Date().toISOString();
-}
-
-function writeLog(level: string, msg: string): void {
-  const line = `${timestamp()} [${level}] ${strip(msg)}\n`;
-  fs.appendFileSync(LOG_FILE, line, 'utf8');
-}
-
-export function logRunStart(): void {
-  const sep = '─'.repeat(60);
-  fs.appendFileSync(LOG_FILE, `\n${sep}\n${timestamp()} [run] started\n${sep}\n`, 'utf8');
-}
-
-export const logger = {
-  info: (msg: string) => {
-    console.log(chalk.blue('[aidev]'), msg);
-    writeLog('info', msg);
-  },
-  success: (msg: string) => {
-    console.log(chalk.green('[aidev]'), msg);
-    writeLog('success', msg);
-  },
-  warn: (msg: string) => {
-    console.log(chalk.yellow('[aidev]'), msg);
-    writeLog('warn', msg);
-  },
-  error: (msg: string) => {
-    console.error(chalk.red('[aidev]'), msg);
-    writeLog('error', msg);
-  },
-  task: (msg: string) => {
-    console.log(chalk.cyan('[task]'), msg);
-    writeLog('task', msg);
-  },
-  debug: (msg: string) => {
-    if (process.env.DEBUG) {
-      console.log(chalk.gray('[debug]'), msg);
-      writeLog('debug', msg);
-    }
-  },
-};

package/src/platform.ts

@@ -1,33 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-
-export const isWindows = process.platform === 'win32';
-
-/**
- * Finds the full path of a binary by searching PATH (and PATHEXT on Windows).
- * Returns the resolved path, or null if not found.
- * Uses only Node.js fs — no `which` / `where` subprocess.
- */
-export function findBin(name: string): string | null {
-  const dirs = (process.env.PATH ?? '').split(path.delimiter).filter(Boolean);
-  const exts = isWindows
-    ? (process.env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').map((e) => e.toLowerCase())
-    : [''];
-
-  for (const dir of dirs) {
-    for (const ext of exts) {
-      const full = path.join(dir, name + ext);
-      try {
-        fs.accessSync(full, fs.constants.F_OK);
-        return full;
-      } catch {
-        // not here — keep searching
-      }
-    }
-  }
-  return null;
-}
-
-export function commandExists(name: string): boolean {
-  return findBin(name) !== null;
-}

package/src/providers/base.ts

@@ -1,8 +0,0 @@
-import { Task, Comment } from '../types';
-
-export interface TaskProvider {
-  fetchTasks(): Promise<Task[]>;
-  postComment(taskId: string, text: string): Promise<void>;
-  getComments(taskId: string): Promise<Comment[]>;
-  updateStatus(taskId: string, status: string): Promise<void>;
-}

package/src/providers/clickup.ts

@@ -1,107 +0,0 @@
-import { Task, Comment, Config } from '../types';
-import { TaskProvider } from './base';
-import { logger } from '../logger';
-
-export class ClickUpProvider implements TaskProvider {
-  private apiKey: string;
-  private teamId: string;
-  private tag: string;
-  private assigneeTag: string;
-
-  constructor(config: Config) {
-    this.apiKey = config.clickupApiKey;
-    this.teamId = config.clickupTeamId;
-    this.tag = config.clickupTag;
-    this.assigneeTag = config.assigneeTag;
-  }
-
-  private async request<T>(path: string, options: RequestInit = {}): Promise<T> {
-    const url = `https://api.clickup.com/api/v2${path}`;
-    const res = await fetch(url, {
-      ...options,
-      headers: {
-        Authorization: this.apiKey,
-        'Content-Type': 'application/json',
-        ...(options.headers || {}),
-      },
-    });
-
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`ClickUp API error ${res.status}: ${body}`);
-    }
-
-    return res.json() as Promise<T>;
-  }
-
-  async fetchTasks(): Promise<Task[]> {
-    logger.debug(`Fetching tasks with tag "${this.tag}" from team ${this.teamId}`);
-
-    interface RawTask {
-      id: string;
-      name: string;
-      description?: string;
-      status: { status: string };
-      url: string;
-      tags: Array<{ name: string }>;
-    }
-
-    interface TasksResponse {
-      tasks: RawTask[];
-    }
-
-    const data = await this.request<TasksResponse>(
-      `/team/${this.teamId}/task?tags[]=${encodeURIComponent(this.tag)}&subtasks=true&include_closed=false`
-    );
-
-    return data.tasks.map((t) => ({
-      id: t.id,
-      name: t.name,
-      description: t.description || '',
-      status: t.status.status.toLowerCase(),
-      url: t.url,
-      tags: t.tags.map((tag) => tag.name),
-    }));
-  }
-
-  async postComment(taskId: string, text: string): Promise<void> {
-    logger.debug(`Posting comment to task ${taskId}`);
-    await this.request(`/task/${taskId}/comment`, {
-      method: 'POST',
-      body: JSON.stringify({ comment_text: text }),
-    });
-  }
-
-  async getComments(taskId: string): Promise<Comment[]> {
-    logger.debug(`Fetching comments for task ${taskId}`);
-
-    interface RawComment {
-      id: string;
-      comment_text: string;
-      user: { username: string; id: number };
-      date: string;
-    }
-
-    interface CommentsResponse {
-      comments: RawComment[];
-    }
-
-    const data = await this.request<CommentsResponse>(`/task/${taskId}/comment`);
-
-    return data.comments.map((c) => ({
-      id: c.id,
-      text: c.comment_text,
-      author: c.user.username,
-      authorId: String(c.user.id),
-      date: parseInt(c.date, 10),
-    }));
-  }
-
-  async updateStatus(taskId: string, status: string): Promise<void> {
-    logger.debug(`Updating task ${taskId} status to "${status}"`);
-    await this.request(`/task/${taskId}`, {
-      method: 'PUT',
-      body: JSON.stringify({ status }),
-    });
-  }
-}

package/src/providers/index.ts

@@ -1,20 +0,0 @@
-import { Config } from '../types';
-import { TaskProvider } from './base';
-import { ClickUpProvider } from './clickup';
-
-export function createProvider(config: Config): TaskProvider {
-  switch (config.provider.toLowerCase()) {
-    case 'clickup':
-      return new ClickUpProvider(config);
-    case 'jira':
-      throw new Error('Jira provider is not yet implemented. Contributions welcome!');
-    case 'notion':
-      throw new Error('Notion provider is not yet implemented. Contributions welcome!');
-    case 'trello':
-      throw new Error('Trello provider is not yet implemented. Contributions welcome!');
-    default:
-      throw new Error(`Unknown provider: ${config.provider}`);
-  }
-}
-
-export { TaskProvider };

package/src/types.ts

@@ -1,33 +0,0 @@
-export interface Task {
-  id: string;
-  name: string;
-  description: string;
-  status: string;
-  url: string;
-  tags: string[];
-}
-
-export interface Comment {
-  id: string;
-  text: string;
-  author: string;
-  authorId: string;
-  date: number; // epoch ms
-}
-
-export type AgentName = 'claude' | 'cursor';
-
-export interface Config {
-  provider: string;
-  clickupApiKey: string;
-  clickupTeamId: string;
-  clickupTag: string;
-  clickupPendingStatus: string;
-  clickupInReviewStatus: string;
-  assigneeTag: string;
-  gitRemote: string;
-  githubBaseBranch: string;
-  githubRepo: string;
-  agents: AgentName[];
-  devNotesMode: 'smart' | 'always';
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "lib": ["ES2020"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}