@qelos/aidev 0.1.0 → 0.1.2

package/src/commands/init.ts

@@ -1,296 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as readline from 'node:readline/promises';
-import { stdin as input, stdout as output } from 'node:process';
-import { logger } from '../logger';
-import { detectRemote } from '../git';
-import chalk from 'chalk';
-
-const VALID_AGENTS = ['claude', 'cursor'] as const;
-
-// Patterns we want guaranteed in .gitignore.
-// Each entry: [pattern to write, regex that matches equivalent existing lines]
-const GITIGNORE_RULES: Array<[string, RegExp]> = [
-  ['.env.*',   /^\.env[\.\*]/m],
-  ['*.log',    /^\*\.log/m],
-];
-
-function ensureGitignore(): void {
-  const gitignorePath = path.join(process.cwd(), '.gitignore');
-  const existing = fs.existsSync(gitignorePath)
-    ? fs.readFileSync(gitignorePath, 'utf8')
-    : '';
-
-  const missing = GITIGNORE_RULES
-    .filter(([, regex]) => !regex.test(existing))
-    .map(([pattern]) => pattern);
-
-  if (missing.length === 0) return;
-
-  const addition = (existing.endsWith('\n') || existing === '' ? '' : '\n')
-    + missing.join('\n') + '\n';
-  fs.appendFileSync(gitignorePath, addition, 'utf8');
-  logger.info(`.gitignore — added: ${missing.join(', ')}`);
-}
-
-interface ClickUpMember {
-  id: number;
-  username: string;
-  email: string;
-}
-
-interface Answers {
-  clickupApiKey: string;
-  clickupTeamId: string;
-  clickupTag: string;
-  clickupPendingStatus: string;
-  clickupInReviewStatus: string;
-  assigneeTag: string;
-  gitRemote: string;
-  githubBaseBranch: string;
-  githubRepo: string;
-  agents: string;
-  devNotesMode: string;
-}
-
-function dim(s: string) {
-  return chalk.dim(s);
-}
-
-function hint(s: string) {
-  return chalk.dim(`(${s})`);
-}
-
-async function ask(
-  rl: readline.Interface,
-  question: string,
-  defaultVal = '',
-  required = false
-): Promise<string> {
-  const suffix = defaultVal ? chalk.dim(` [${defaultVal}]`) : '';
-  while (true) {
-    const raw = await rl.question(`  ${question}${suffix}: `);
-    const val = raw.trim() || defaultVal;
-    if (required && !val) {
-      console.log(chalk.yellow(`  This field is required.`));
-      continue;
-    }
-    return val;
-  }
-}
-
-async function choose(
-  rl: readline.Interface,
-  question: string,
-  options: string[],
-  defaultVal: string
-): Promise<string> {
-  const opts = options
-    .map((o) => (o === defaultVal ? chalk.cyan(o) : o))
-    .join(chalk.dim(' | '));
-  while (true) {
-    const raw = await rl.question(`  ${question} ${dim(`[${opts}]`)}: `);
-    const val = raw.trim() || defaultVal;
-    if (!options.includes(val)) {
-      console.log(chalk.yellow(`  Choose one of: ${options.join(', ')}`));
-      continue;
-    }
-    return val;
-  }
-}
-
-async function pickAgents(rl: readline.Interface): Promise<string> {
-  const available = [...VALID_AGENTS];
-
-  console.log(`\n  Available agents:`);
-  available.forEach((a, i) => console.log(`    ${chalk.cyan(String(i + 1))}. ${a}`));
-
-  console.log(
-    `\n  Enter agents ${hint('numbers or names, comma-separated — first = primary, rest = fallback')}`
-  );
-
-  while (true) {
-    const raw = await rl.question(`  Agents in order ${dim(`[${available.join(',')}]`)}: `);
-
-    if (!raw.trim()) return available.join(',');
-
-    const parts = raw.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
-    const resolved = parts.map((p) => {
-      const idx = parseInt(p, 10);
-      if (!isNaN(idx) && idx >= 1 && idx <= available.length) return available[idx - 1];
-      return p;
-    });
-
-    const invalid = resolved.filter((r) => !available.includes(r as typeof available[number]));
-    if (invalid.length) {
-      console.log(chalk.yellow(`  Unknown agent(s): ${invalid.join(', ')}. Valid: ${available.join(', ')}`));
-      continue;
-    }
-
-    const unique = [...new Set(resolved)];
-    if (unique.length !== resolved.length) {
-      console.log(chalk.yellow(`  Duplicate agents removed: ${unique.join(', ')}`));
-    }
-    return unique.join(',');
-  }
-}
-
-async function fetchCurrentUser(apiKey: string): Promise<ClickUpMember | null> {
-  try {
-    const res = await fetch('https://api.clickup.com/api/v2/user', {
-      headers: { Authorization: apiKey },
-    });
-    if (!res.ok) return null;
-    const data = await res.json() as { user: ClickUpMember };
-    return data.user;
-  } catch {
-    return null;
-  }
-}
-
-async function pickAssignee(rl: readline.Interface, apiKey: string): Promise<string> {
-  process.stdout.write(`  ${chalk.dim('Fetching current user...')}\r`);
-  const user = await fetchCurrentUser(apiKey);
-  process.stdout.write('                              \r');
-
-  if (!user) {
-    return ask(rl, `Assignee tag ${hint('optional — could not fetch user')}`, '');
-  }
-
-  const display = user.username && user.username !== 'null'
-    ? `${user.username} <${user.email}>`
-    : user.email;
-  return ask(rl, `Assignee tag`, display);
-}
-
-function section(title: string) {
-  console.log('\n' + chalk.bold.underline(title));
-}
-
-/** Wraps value in double quotes if it contains spaces or special chars. */
-function envVal(val: string): string {
-  return /[\s#"']/.test(val) ? `"${val.replace(/"/g, '\\"')}"` : val;
-}
-
-function line(key: string, val: string): string | null {
-  return val ? `${key}=${envVal(val)}` : null;
-}
-
-function renderEnv(a: Answers): string {
-  const lines = [
-    `PROVIDER=clickup`,
-    line('CLICKUP_API_KEY', a.clickupApiKey),
-    line('CLICKUP_TEAM_ID', a.clickupTeamId),
-    line('CLICKUP_TAG', a.clickupTag),
-    `CLICKUP_PENDING_STATUS=${envVal(a.clickupPendingStatus)}`,
-    `CLICKUP_IN_REVIEW_STATUS=${envVal(a.clickupInReviewStatus)}`,
-    ``,
-    line('ASSIGNEE_TAG', a.assigneeTag),
-    `GIT_REMOTE=${envVal(a.gitRemote)}`,
-    `GITHUB_BASE_BRANCH=${envVal(a.githubBaseBranch)}`,
-    line('GITHUB_REPO', a.githubRepo),
-    ``,
-    `# Agents to use, in fallback order (comma-separated: claude, cursor)`,
-    `AGENTS=${a.agents}`,
-    ``,
-    `# DEV_NOTES_MODE: smart (only ask when unclear) | always (ask before every task)`,
-    `DEV_NOTES_MODE=${a.devNotesMode}`,
-    ``,
-  ];
-  return lines.filter((l) => l !== null).join('\n');
-}
-
-export async function initCommand(): Promise<void> {
-  const dest = path.join(process.cwd(), '.env.aidev');
-
-  if (fs.existsSync(dest)) {
-    const rl0 = readline.createInterface({ input, output });
-    const overwrite = await rl0.question(
-      chalk.yellow('.env.aidev already exists. Reconfigure? ') + dim('[y/N] ')
-    );
-    rl0.close();
-    if (overwrite.trim().toLowerCase() !== 'y') {
-      logger.info('Keeping existing .env.aidev.');
-      return;
-    }
-    console.log();
-  }
-
-  console.log(chalk.bold('\naidev setup') + dim(' — press Enter to accept defaults\n'));
-
-  const rl = readline.createInterface({ input, output });
-
-  try {
-    // ── ClickUp ──────────────────────────────────────────────
-    section('ClickUp');
-    const globalEnvHint = hint('leave blank to use global env var');
-    const clickupApiKey = await ask(rl, `API key ${globalEnvHint}`, '');
-    const clickupTeamId = await ask(rl, `Team / workspace ID ${globalEnvHint}`, '');
-    const folderName = path.basename(process.cwd());
-    const clickupTag = await ask(
-      rl,
-      `Tag to filter tasks ${hint('tasks with this tag will be picked up')}`,
-      folderName
-    );
-    const clickupPendingStatus = await ask(rl, 'Pending status name', 'pending');
-    const clickupInReviewStatus = await ask(rl, 'In-review status name', 'review');
-
-    // ── Git / GitHub ─────────────────────────────────────────
-    section('Git & GitHub');
-    const detectedRemote = detectRemote() ?? 'origin';
-    const gitRemote = await ask(rl, 'Git remote', detectedRemote);
-    const githubBaseBranch = await ask(rl, 'Base branch', 'main');
-    const githubRepo = await ask(
-      rl,
-      `GitHub repo ${hint('owner/repo — used for PR links, optional')}`,
-      ''
-    );
-
-    // ── AI agents ────────────────────────────────────────────
-    section('AI agents');
-    const agents = await pickAgents(rl);
-    const devNotesMode = await choose(
-      rl,
-      `Dev notes mode ${hint('smart = ask AI if unclear, always = ask before every task')}`,
-      ['smart', 'always'],
-      'smart'
-    );
-
-    // ── Assignee ─────────────────────────────────────────────
-    section('Assignee');
-    const effectiveApiKey = clickupApiKey || process.env.CLICKUP_API_KEY || '';
-    let assigneeTag: string;
-
-    if (effectiveApiKey) {
-      assigneeTag = await pickAssignee(rl, effectiveApiKey);
-    } else {
-      assigneeTag = await ask(
-        rl,
-        `Assignee tag ${hint('optional — provide API key above to auto-detect')}`,
-        ''
-      );
-    }
-
-    const answers: Answers = {
-      clickupApiKey,
-      clickupTeamId,
-      clickupTag,
-      clickupPendingStatus,
-      clickupInReviewStatus,
-      assigneeTag,
-      gitRemote,
-      githubBaseBranch,
-      githubRepo,
-      agents,
-      devNotesMode,
-    };
-
-    ensureGitignore();
-    fs.writeFileSync(dest, renderEnv(answers), 'utf8');
-    console.log();
-    logger.success(`.env.aidev written to ${dest}`);
-    logger.info(`Agents: ${agents} ${dim('(first = primary, rest = fallback)')}`);
-  } finally {
-    rl.close();
-  }
-}

package/src/commands/run.ts

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