@qelos/aidev 0.1.0

package/src/commands/run.ts

@@ -0,0 +1,283 @@
+import { Config, Task, Comment } from '../types';
+import { TaskProvider } from '../providers';
+import { AIRunner } from '../ai';
+import { logger, logRunStart } from '../logger';
+import * as git from '../git';
+
+const SKIP_STATUSES = new Set(['closed', 'done', 'cancelled', 'complete']);
+
+export type RunFilter = 'all' | 'open' | 'pending';
+
+export async function runCommand(
+  filter: RunFilter,
+  config: Config,
+  provider: TaskProvider,
+  runners: AIRunner[]
+): Promise<void> {
+  logRunStart();
+  logger.info(`Fetching tasks (filter: ${filter})...`);
+  const tasks = await provider.fetchTasks();
+  logger.info(`Found ${tasks.length} tagged task(s)`);
+
+  let processed = 0;
+  let skipped = 0;
+
+  for (const task of tasks) {
+    const result = await processTask(task, filter, config, provider, runners);
+    if (result === 'processed') processed++;
+    else skipped++;
+  }
+
+  logger.success(`Done. Processed: ${processed}, Skipped: ${skipped}`);
+}
+
+async function processTask(
+  task: Task,
+  filter: RunFilter,
+  config: Config,
+  provider: TaskProvider,
+  runners: AIRunner[]
+): Promise<'processed' | 'skipped'> {
+  const isPending = task.status.toLowerCase() === config.clickupPendingStatus.toLowerCase();
+
+  logger.task(`[${task.id}] "${task.name}" (status: ${task.status})`);
+
+  // Skip terminal statuses
+  if (SKIP_STATUSES.has(task.status.toLowerCase())) {
+    logger.debug(`Skipping — terminal status: ${task.status}`);
+    return 'skipped';
+  }
+
+  // Skip if remote branch already exists for this task
+  const branchName = `${task.id}/${git.slugify(task.name)}`;
+  if (git.remoteBranchExists(config.gitRemote, branchName)) {
+    logger.debug(`Skipping — branch already exists: ${branchName}`);
+    return 'skipped';
+  }
+
+  // Apply filter
+  if (filter === 'open' && isPending) {
+    logger.debug('Skipping — filter=open, task is pending');
+    return 'skipped';
+  }
+  if (filter === 'pending' && !isPending) {
+    logger.debug('Skipping — filter=pending, task is not pending');
+    return 'skipped';
+  }
+
+  // Handle pending tasks: check if a human replied
+  if (isPending) {
+    const hasReply = await checkForHumanReply(task, provider);
+    if (!hasReply) {
+      logger.debug('Skipping — pending task has no human reply yet');
+      return 'skipped';
+    }
+    logger.info('Pending task has a human reply — proceeding');
+  } else {
+    // Check if task needs clarification
+    const clarification = await checkNeedsClarification(task, config, provider, runners);
+    if (clarification) {
+      await provider.postComment(task.id, clarification);
+      await provider.updateStatus(task.id, config.clickupPendingStatus);
+      logger.info(`Posted clarification question, set status to ${config.clickupPendingStatus}`);
+      return 'skipped';
+    }
+  }
+
+  // Implement the task
+  await implementTask(task, branchName, config, provider, runners);
+  return 'processed';
+}
+
+async function checkForHumanReply(task: Task, provider: TaskProvider): Promise<boolean> {
+  const comments = await provider.getComments(task.id);
+  if (comments.length < 2) return false;
+
+  // The last comment should be from a human (not a bot — heuristic: not containing "[aidev]")
+  const lastComment = comments[comments.length - 1];
+  return !lastComment.text.includes('[aidev]');
+}
+
+async function checkNeedsClarification(
+  task: Task,
+  config: Config,
+  provider: TaskProvider,
+  runners: AIRunner[]
+): Promise<string | null> {
+  if (config.devNotesMode === 'always') {
+    return `Any dev notes or implementation preferences for this task?\n\nTask: ${task.name}`;
+  }
+
+  // smart mode: ask AI if the task is clear
+  const runner = runners.find((r) => r.isAvailable());
+  if (!runner) {
+    logger.warn('No AI runner available — skipping clarification check');
+    return null;
+  }
+
+  const clarificationPrompt = `You are a senior software developer reviewing a task.
+Determine if the following task has enough information to implement without further clarification.
+
+Task name: ${task.name}
+Task description: ${task.description || '(no description)'}
+
+Respond with valid JSON only:
+{
+  "clear": true|false,
+  "question": "question to ask if not clear, or null"
+}`;
+
+  const result = await runner.run(clarificationPrompt);
+  if (!result.success) {
+    logger.warn('Clarification check failed — proceeding without clarification');
+    return null;
+  }
+
+  try {
+    const jsonMatch = result.output.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) return null;
+    const parsed = JSON.parse(jsonMatch[0]) as { clear: boolean; question?: string | null };
+    if (!parsed.clear && parsed.question) {
+      return parsed.question;
+    }
+  } catch {
+    logger.debug('Could not parse clarification response — proceeding');
+  }
+
+  return null;
+}
+
+async function implementTask(
+  task: Task,
+  branchName: string,
+  config: Config,
+  provider: TaskProvider,
+  runners: AIRunner[]
+): Promise<void> {
+  logger.info(`Implementing task: ${task.name}`);
+
+  // Mark as in progress
+  try {
+    await provider.updateStatus(task.id, 'in progress');
+    await provider.postComment(task.id, `[aidev] Starting implementation on branch \`${branchName}\``);
+  } catch (err) {
+    logger.warn(`Could not update task status: ${err}`);
+  }
+
+  // Prepare git branch
+  if (!git.fetchAndCheckout(config.gitRemote, config.githubBaseBranch)) {
+    logger.error('Failed to prepare base branch');
+    await provider.postComment(task.id, '[aidev] Failed to prepare git branch. Manual intervention needed.');
+    return;
+  }
+
+  if (!git.createBranch(branchName)) {
+    logger.error(`Failed to create branch ${branchName}`);
+    return;
+  }
+
+  // Get conversation context for pending tasks
+  let context = '';
+  try {
+    const comments = await provider.getComments(task.id);
+    if (comments.length > 0) {
+      context = '\n\nConversation context:\n' + comments.map((c) => `${c.author}: ${c.text}`).join('\n');
+    }
+  } catch {
+    // ignore
+  }
+
+  const implementPrompt = buildImplementPrompt(task, context);
+
+  // Run AI runners in order with fallback
+  let implemented = false;
+  let previousNotes = '';
+
+  for (const runner of runners) {
+    if (!runner.isAvailable()) {
+      logger.debug(`${runner.name} not available, skipping`);
+      continue;
+    }
+
+    logger.info(`Running ${runner.name}...`);
+    const result = await runner.run(implementPrompt, previousNotes || undefined);
+
+    if (result.success) {
+      implemented = true;
+      break;
+    }
+
+    logger.warn(`${runner.name} failed — trying next runner`);
+    previousNotes = `Previous runner (${runner.name}) output:\n${result.output}\nErrors:\n${result.error}`;
+  }
+
+  if (!implemented) {
+    logger.error('All AI runners failed');
+    await provider.postComment(task.id, '[aidev] All AI runners failed. Manual implementation needed.');
+    git.deleteBranch(branchName);
+    return;
+  }
+
+  // Check if AI made changes
+  if (!git.hasChanges()) {
+    logger.warn('AI runner produced no file changes');
+    await provider.postComment(
+      task.id,
+      '[aidev] AI runner completed but made no code changes. More information may be needed.'
+    );
+    git.deleteBranch(branchName);
+    return;
+  }
+
+  // Commit and push
+  if (!git.addAll() || !git.commit(`[aidev] Implement: ${task.name}\n\nTask: ${task.url}`)) {
+    logger.error('Failed to commit changes');
+    return;
+  }
+
+  if (!git.push(config.gitRemote, branchName)) {
+    logger.error('Failed to push branch');
+    return;
+  }
+
+  // Post completion comment
+  const prUrl = buildPRUrl(config, branchName);
+  const comment = buildCompletionComment(branchName, prUrl, config);
+  await provider.postComment(task.id, comment);
+  await provider.updateStatus(task.id, config.clickupInReviewStatus);
+
+  logger.success(`Task implemented: branch ${branchName} pushed`);
+}
+
+function buildImplementPrompt(task: Task, context: string): string {
+  return `You are implementing a software development task. Make the necessary code changes to complete the task described below.
+
+Task: ${task.name}
+
+Description:
+${task.description || '(no description provided)'}
+${context}
+
+Please implement the required changes. Focus on correctness and follow the existing code style in the project.`;
+}
+
+function buildPRUrl(config: Config, branch: string): string {
+  if (!config.githubRepo) return '';
+  const encoded = encodeURIComponent(branch);
+  return `https://github.com/${config.githubRepo}/compare/${config.githubBaseBranch}...${encoded}?expand=1`;
+}
+
+function buildCompletionComment(branch: string, prUrl: string, config: Config): string {
+  const lines = [
+    `[aidev] Implementation complete!`,
+    ``,
+    `Branch: \`${branch}\``,
+  ];
+
+  if (prUrl) {
+    lines.push(`Open PR: ${prUrl}`);
+  }
+
+  lines.push(``, `Status set to: ${config.clickupInReviewStatus}`);
+  return lines.join('\n');
+}

package/src/commands/schedule.ts

@@ -0,0 +1,179 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,109 @@
+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

@@ -0,0 +1,53 @@
+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);
+    }
+  },
+};