@iservu-inc/adf-cli 0.14.5 → 0.16.0

package/lib/commands/import.js

@@ -0,0 +1,439 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const inquirer = require('inquirer');
+const { detectArtifactType, getArtifactTypes, isValidType } = require('../utils/artifact-detector');
+
+/**
+ * Import Command
+ * Import existing markdown documentation into ADF
+ */
+
+/**
+ * Generate a session ID for imported artifacts
+ * @returns {string} - Session ID in format: {timestamp}_imported
+ */
+function generateSessionId() {
+  const now = new Date();
+  const timestamp = now.toISOString()
+    .replace(/[-:]/g, '')
+    .replace('T', '_')
+    .split('.')[0];
+  return `${timestamp}_imported`;
+}
+
+/**
+ * Normalize markdown content with ADF metadata
+ * @param {string} content - Original content
+ * @param {string} type - Artifact type
+ * @param {string} sourcePath - Original source path
+ * @returns {string} - Normalized content
+ */
+function normalizeContent(content, type, sourcePath) {
+  // Check if frontmatter already exists
+  const hasFrontmatter = content.startsWith('---');
+
+  const adfMetadata = {
+    adf_type: type,
+    adf_imported: true,
+    adf_source: sourcePath,
+    adf_imported_at: new Date().toISOString()
+  };
+
+  if (hasFrontmatter) {
+    // Insert ADF metadata into existing frontmatter
+    return content.replace(/^---\s*\n/, `---\n${formatYamlMetadata(adfMetadata)}`);
+  }
+
+  // Add new frontmatter
+  const frontmatter = `---\n${formatYamlMetadata(adfMetadata)}---\n\n`;
+  return frontmatter + content;
+}
+
+/**
+ * Format metadata as YAML
+ * @param {Object} metadata - Metadata object
+ * @returns {string} - YAML formatted string
+ */
+function formatYamlMetadata(metadata) {
+  return Object.entries(metadata)
+    .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+    .join('\n') + '\n';
+}
+
+/**
+ * Create session directory structure
+ * @param {string} projectPath - Project root
+ * @param {string} sessionId - Session ID
+ * @returns {Object} - Paths object
+ */
+async function createSessionStructure(projectPath, sessionId) {
+  const sessionsDir = path.join(projectPath, '.adf', 'sessions');
+  const sessionPath = path.join(sessionsDir, sessionId);
+  const outputsPath = path.join(sessionPath, 'outputs');
+  const customPath = path.join(outputsPath, 'custom');
+  const sourcesPath = path.join(sessionPath, 'sources');
+
+  await fs.ensureDir(outputsPath);
+  await fs.ensureDir(customPath);
+  await fs.ensureDir(sourcesPath);
+
+  return { sessionPath, outputsPath, customPath, sourcesPath };
+}
+
+/**
+ * Create session metadata
+ * @param {string} sessionPath - Session directory path
+ * @param {Array} sourceFiles - List of source files
+ * @param {Array} artifactTypes - List of artifact types
+ * @param {string} projectPath - Project root path
+ */
+async function createSessionMetadata(sessionPath, sourceFiles, artifactTypes, projectPath) {
+  const metadata = {
+    framework: 'imported',
+    importedAt: new Date().toISOString(),
+    sourceFiles: sourceFiles.map(f => path.relative(projectPath, f)),
+    artifactTypes: [...new Set(artifactTypes)],
+    projectPath: projectPath
+  };
+
+  await fs.writeJson(path.join(sessionPath, '_metadata.json'), metadata, { spaces: 2 });
+
+  const progress = {
+    status: 'completed',
+    canResume: false,
+    importedArtifacts: sourceFiles.length,
+    completedBlocks: artifactTypes,
+    totalBlocks: artifactTypes.length,
+    totalQuestionsAnswered: 0,
+    lastUpdated: new Date().toISOString()
+  };
+
+  await fs.writeJson(path.join(sessionPath, '_progress.json'), progress, { spaces: 2 });
+}
+
+/**
+ * Resolve files from input arguments (handles globs and directories)
+ * @param {Array} inputs - File paths, directories, or glob patterns
+ * @returns {Promise<Array>} - Resolved file paths
+ */
+async function resolveFiles(inputs) {
+  const files = [];
+
+  for (const input of inputs) {
+    const fullPath = path.resolve(input);
+
+    if (!await fs.pathExists(fullPath)) {
+      console.warn(chalk.yellow(`⚠️  File not found: ${input}`));
+      continue;
+    }
+
+    const stats = await fs.stat(fullPath);
+
+    if (stats.isDirectory()) {
+      // Scan directory for markdown files
+      const dirFiles = await fs.readdir(fullPath);
+      for (const file of dirFiles) {
+        if (file.endsWith('.md') || file.endsWith('.markdown')) {
+          files.push(path.join(fullPath, file));
+        }
+      }
+    } else if (stats.isFile() && (fullPath.endsWith('.md') || fullPath.endsWith('.markdown'))) {
+      files.push(fullPath);
+    } else {
+      console.warn(chalk.yellow(`⚠️  Skipping non-markdown file: ${input}`));
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Interactive type selection for a file
+ * @param {string} filePath - File path
+ * @param {Object} detection - Auto-detection result
+ * @returns {Promise<Object>} - Final type selection
+ */
+async function promptForType(filePath, detection) {
+  const types = getArtifactTypes();
+  const filename = path.basename(filePath);
+
+  console.log(chalk.cyan(`\n📄 ${filename}`));
+
+  if (detection.confidence > 0) {
+    console.log(chalk.gray(`   Auto-detected: ${detection.config.name} (${detection.confidence}% confidence)`));
+  }
+
+  const choices = [
+    ...Object.entries(types).map(([key, config]) => ({
+      name: `${config.name} → ${config.outputFile}`,
+      value: key
+    })),
+    { name: chalk.yellow('Custom (specify name)'), value: 'custom' },
+    { name: chalk.gray('Skip this file'), value: 'skip' }
+  ];
+
+  // Pre-select detected type if high confidence
+  const defaultChoice = detection.confidence >= 60 ? detection.type : undefined;
+
+  const { selectedType } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selectedType',
+      message: `Select artifact type for ${filename}:`,
+      choices,
+      default: defaultChoice
+    }
+  ]);
+
+  if (selectedType === 'skip') {
+    return null;
+  }
+
+  if (selectedType === 'custom') {
+    const { customName } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'customName',
+        message: 'Enter custom artifact name:',
+        default: filename.replace(/\.md$/, ''),
+        validate: input => input.trim().length > 0 || 'Name cannot be empty'
+      }
+    ]);
+
+    return {
+      type: 'custom',
+      customName: customName.trim(),
+      outputFile: `custom/${customName.trim().toLowerCase().replace(/\s+/g, '-')}.md`
+    };
+  }
+
+  return {
+    type: selectedType,
+    outputFile: types[selectedType].outputFile
+  };
+}
+
+/**
+ * Main import function
+ * @param {Array} files - Files to import
+ * @param {Object} options - Command options
+ */
+async function importArtifacts(files, options = {}) {
+  const cwd = process.cwd();
+  const adfDir = path.join(cwd, '.adf');
+
+  // Ensure .adf directory exists
+  if (!await fs.pathExists(adfDir)) {
+    console.log(chalk.yellow('\n⚠️  No .adf directory found. Creating one...'));
+    await fs.ensureDir(adfDir);
+  }
+
+  // Resolve all input files
+  const resolvedFiles = await resolveFiles(files);
+
+  if (resolvedFiles.length === 0) {
+    console.error(chalk.red('\n❌ No valid markdown files found to import.'));
+    console.log(chalk.yellow('Specify .md files, directories, or use glob patterns.\n'));
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan.bold(`\n📥 Importing ${resolvedFiles.length} file(s)...\n`));
+
+  // Dry run mode
+  if (options.dryRun) {
+    console.log(chalk.yellow.bold('DRY RUN - No changes will be made\n'));
+  }
+
+  // Process each file
+  const imports = [];
+  const skipped = [];
+
+  for (const filePath of resolvedFiles) {
+    const detection = await detectArtifactType(filePath);
+    let finalType;
+
+    if (options.interactive) {
+      // Interactive mode - prompt for each file
+      finalType = await promptForType(filePath, detection);
+      if (!finalType) {
+        skipped.push(filePath);
+        continue;
+      }
+    } else if (options.type) {
+      // Explicit type provided via --type flag
+      if (!isValidType(options.type)) {
+        console.error(chalk.red(`\n❌ Invalid artifact type: ${options.type}`));
+        console.log(chalk.yellow('Valid types: prd, architecture, stories, tasks, specification, constitution, plan, prp, custom\n'));
+        process.exit(1);
+      }
+
+      if (options.type === 'custom') {
+        const customName = options.name || path.basename(filePath, '.md');
+        finalType = {
+          type: 'custom',
+          customName,
+          outputFile: `custom/${customName.toLowerCase().replace(/\s+/g, '-')}.md`
+        };
+      } else {
+        const types = getArtifactTypes();
+        finalType = {
+          type: options.type,
+          outputFile: types[options.type].outputFile
+        };
+      }
+    } else {
+      // Auto-detection mode
+      if (detection.confidence < 50) {
+        console.log(chalk.yellow(`⚠️  Low confidence (${detection.confidence}%) for ${path.basename(filePath)}`));
+        console.log(chalk.gray(`   Detected as: ${detection.config.name}`));
+        console.log(chalk.gray(`   Use --interactive or --type to specify manually\n`));
+      }
+
+      finalType = {
+        type: detection.type,
+        outputFile: detection.config.outputFile,
+        confidence: detection.confidence
+      };
+    }
+
+    imports.push({
+      sourcePath: filePath,
+      ...finalType
+    });
+
+    if (!options.dryRun) {
+      console.log(chalk.green(`✓ ${path.basename(filePath)}`));
+      console.log(chalk.gray(`  → ${finalType.outputFile} (${finalType.type})`));
+    }
+  }
+
+  if (options.dryRun) {
+    console.log(chalk.cyan.bold('\nWould import:\n'));
+    for (const item of imports) {
+      console.log(chalk.green(`  ${path.basename(item.sourcePath)}`));
+      console.log(chalk.gray(`    → ${item.outputFile} (${item.type})`));
+    }
+    if (skipped.length > 0) {
+      console.log(chalk.yellow(`\nWould skip: ${skipped.length} file(s)\n`));
+    }
+    return;
+  }
+
+  if (imports.length === 0) {
+    console.log(chalk.yellow('\nNo files to import after processing.\n'));
+    return;
+  }
+
+  // Create session
+  const spinner = ora('Creating import session...').start();
+
+  try {
+    const sessionId = options.session === 'latest'
+      ? await findLatestSession(cwd)
+      : options.session || generateSessionId();
+
+    const { sessionPath, outputsPath, customPath, sourcesPath } = await createSessionStructure(cwd, sessionId);
+
+    // Copy and normalize files
+    const artifactTypes = [];
+
+    for (const item of imports) {
+      // Read source
+      const content = await fs.readFile(item.sourcePath, 'utf-8');
+
+      // Normalize content
+      const normalized = options.noNormalize
+        ? content
+        : normalizeContent(content, item.type, path.relative(cwd, item.sourcePath));
+
+      // Determine output path
+      let outputPath;
+      if (item.type === 'custom') {
+        outputPath = path.join(customPath, item.customName
+          ? `${item.customName.toLowerCase().replace(/\s+/g, '-')}.md`
+          : path.basename(item.sourcePath));
+      } else {
+        outputPath = path.join(outputsPath, item.outputFile);
+      }
+
+      // Write normalized content
+      await fs.ensureDir(path.dirname(outputPath));
+      await fs.writeFile(outputPath, normalized);
+
+      // Preserve original
+      const originalFilename = `original_${path.basename(item.sourcePath)}`;
+      await fs.copy(item.sourcePath, path.join(sourcesPath, originalFilename));
+
+      artifactTypes.push(item.type);
+    }
+
+    // Create metadata
+    await createSessionMetadata(
+      sessionPath,
+      imports.map(i => i.sourcePath),
+      artifactTypes,
+      cwd
+    );
+
+    spinner.succeed(`Created import session: ${chalk.cyan(sessionId)}`);
+
+    console.log(chalk.gray(`\n  Session: .adf/sessions/${sessionId}/`));
+    console.log(chalk.gray(`  Artifacts: ${imports.length}`));
+    console.log(chalk.gray(`  Types: ${[...new Set(artifactTypes)].join(', ')}`));
+
+    if (skipped.length > 0) {
+      console.log(chalk.yellow(`  Skipped: ${skipped.length} file(s)`));
+    }
+
+    console.log(chalk.green.bold('\n✓ Import complete!'));
+    console.log(chalk.gray('  Run "adf deploy <tool>" to deploy imported artifacts.\n'));
+
+  } catch (error) {
+    spinner.fail(`Import failed: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Find the latest session ID
+ * @param {string} cwd - Current working directory
+ * @returns {Promise<string|null>} - Latest session ID or null
+ */
+async function findLatestSession(cwd) {
+  const sessionsDir = path.join(cwd, '.adf', 'sessions');
+
+  if (!await fs.pathExists(sessionsDir)) {
+    return null;
+  }
+
+  const sessions = await fs.readdir(sessionsDir);
+  if (sessions.length === 0) {
+    return null;
+  }
+
+  // Sort by timestamp (descending)
+  sessions.sort().reverse();
+  return sessions[0];
+}
+
+/**
+ * Command handler
+ */
+async function importCommand(files, options) {
+  if (!files || files.length === 0) {
+    console.error(chalk.red('\n❌ Error: Please specify files to import.'));
+    console.log(chalk.yellow('Usage: adf import <files...> [options]'));
+    console.log(chalk.gray('\nExamples:'));
+    console.log(chalk.gray('  adf import ./docs/PRD.md'));
+    console.log(chalk.gray('  adf import ./docs/*.md --interactive'));
+    console.log(chalk.gray('  adf import ./design.md --type architecture\n'));
+    process.exit(1);
+  }
+
+  await importArtifacts(files, options);
+}
+
+module.exports = importCommand;
+module.exports.importArtifacts = importArtifacts;

package/lib/commands/init.js

@@ -159,10 +159,14 @@ async function init(options) {
     const interviewer = new Interviewer(existingSession.progress.framework || 'balanced', cwd, existingSession, aiConfig);
     const sessionPath = await interviewer.start();
 
-    console.log(chalk.green.bold('\n✨ Requirements gathering complete!\n'));
-    console.log(chalk.cyan(`📁 Session saved to: ${sessionPath}\n`));
-
-    return;
+    if (sessionPath === 'back') {
+      // User requested to go back to main menu
+      // Fall through to existing content check
+    } else {
+      console.log(chalk.green.bold('\n✨ Requirements gathering complete!\n'));
+      console.log(chalk.cyan(`📁 Session saved to: ${sessionPath}\n`));
+      return;
+    }
   }
 
   // Check if already initialized with actual content