@iservu-inc/adf-cli 0.14.6 → 0.17.0

package/README.md

@@ -186,13 +186,10 @@ ANTHROPIC_API_KEY=sk-ant-api03-...
 
 The AI provider enhances your workflow by:
 
-- **Smart Question Filtering** - Automatically analyzes your project and skips irrelevant questions (e.g., UI questions for CLI tools)
-- **Learning System** - Learns from your skip behavior to improve filtering over time:
-  - Automatically detects patterns in skipped questions across sessions
-  - Generates learned rules from high-confidence patterns (75%+)
-  - Applies your preferences in future interviews with your approval
-  - Privacy-first design: all data stored locally in `.adf/learning/`
-  - Manage via `adf config` → Learning System
+- **Smart Filtering** - AI-powered question filtering based on context
+- **Learning System** - Adapts to your preferences over time with pattern decay
+- **Analytics Dashboard** - Comprehensive insights into time saved and learning health
+- **Session Resume** - Pause and resume interviews anytime
 - **Real-Time Answer Quality Analysis** - Scores your answers 0-100
 - **Intelligent Follow-Up Questions** - Automatically generated based on your responses
 - **Context-Aware Guidance** - Tailored suggestions for your project type

package/bin/adf.js

@@ -22,6 +22,7 @@ const updateCommand = require('../lib/commands/update');
 const configCommand = require('../lib/commands/config');
 const guideCommand = require('../lib/commands/guide');
 const toolsCommand = require('../lib/commands/tools');
+const importCommand = require('../lib/commands/import');
 
 const program = new Command();
 
@@ -71,6 +72,9 @@ ${chalk.cyan.bold('Getting Help:')}
   $ adf update --help
   $ adf tools audit --help
 
+  ${chalk.gray('# Import existing documentation')}
+  $ adf import ./docs/PRD.md
+
   ${chalk.gray('# Get tool-specific setup guides')}
   $ adf guide windsurf
   $ adf guide claude-code
@@ -146,6 +150,15 @@ ${chalk.cyan.bold('Examples:')}
   ${chalk.gray('# Comprehensive workflow for enterprise project')}
   $ adf init --comprehensive
 
+${chalk.cyan.bold('Existing Projects:')}
+  Running ${chalk.white('adf init')} in a directory with existing content:
+  • ${chalk.yellow('Synthesize & Augment')} - Detects other frameworks (BMAD/OpenSpec)
+                       and merges them into a unified ADF session.
+  • ${chalk.yellow('Resume Session')}     - Detects interrupted interviews and lets you
+                       continue exactly where you left off.
+  • ${chalk.yellow('Continue Project')}   - Start a new session while preserving
+                       existing project history and learning data.
+
 ${chalk.cyan.bold('Features:')}
   • AI-powered question filtering based on project context
   • Answer quality analysis and suggestions
@@ -394,6 +407,73 @@ ${chalk.cyan.bold('What\'s in a Guide:')}
 `)
   .action(guideCommand);
 
+// adf import
+program
+  .command('import <files...>')
+  .description('Import existing markdown documentation into ADF')
+  .option('-t, --type <type>', 'Artifact type (prd, architecture, stories, tasks, spec, constitution, plan, prp, custom)')
+  .option('-n, --name <name>', 'Custom artifact name (used with --type custom)')
+  .option('-s, --session <id>', 'Merge into existing session (use "latest" for most recent)')
+  .option('-i, --interactive', 'Prompt for type of each file')
+  .option('--no-normalize', 'Skip content normalization')
+  .option('--dry-run', 'Show what would be imported without creating session')
+  .addHelpText('after', `
+${chalk.cyan.bold('Description:')}
+  Import existing markdown documentation (PRDs, design docs, specifications)
+  into ADF for deployment to AI coding assistants. Useful for projects that
+  already have formal artifacts from other tools or processes.
+
+${chalk.cyan.bold('Supported Artifact Types:')}
+  ${chalk.yellow('prd')}            - Product Requirements Document
+  ${chalk.yellow('architecture')}   - System/Technical Architecture
+  ${chalk.yellow('stories')}        - User Stories / Backlog
+  ${chalk.yellow('tasks')}          - Implementation Tasks
+  ${chalk.yellow('specification')}  - Feature Specification (alias: spec)
+  ${chalk.yellow('constitution')}   - Quality Standards/Guidelines
+  ${chalk.yellow('plan')}           - Technical/Project Plan
+  ${chalk.yellow('prp')}            - Agent-Native PRP Document
+  ${chalk.yellow('custom')}         - Custom artifact (requires --name)
+
+${chalk.cyan.bold('Auto-Detection:')}
+  ADF automatically detects artifact types based on:
+  - Filename patterns (e.g., "PRD.md" -> prd)
+  - Frontmatter metadata (type: prd)
+  - Content analysis (headers, keywords)
+
+${chalk.cyan.bold('Examples:')}
+  ${chalk.gray('# Import single file (auto-detect type)')}
+  $ adf import ./docs/PRD.md
+
+  ${chalk.gray('# Import multiple files')}
+  $ adf import ./docs/PRD.md ./docs/architecture.md
+
+  ${chalk.gray('# Import entire directory')}
+  $ adf import ./docs/
+
+  ${chalk.gray('# Specify type explicitly')}
+  $ adf import ./design.md --type architecture
+
+  ${chalk.gray('# Import custom artifact')}
+  $ adf import ./compliance.md --type custom --name "Compliance Requirements"
+
+  ${chalk.gray('# Interactive mode (choose type for each file)')}
+  $ adf import ./docs/*.md --interactive
+
+  ${chalk.gray('# Merge into existing session')}
+  $ adf import ./extra-docs.md --session latest
+
+  ${chalk.gray('# Preview what would be imported')}
+  $ adf import ./docs/*.md --dry-run
+
+${chalk.cyan.bold('Output:')}
+  Creates a session at: ${chalk.white('.adf/sessions/{timestamp}_imported/')}
+
+${chalk.cyan.bold('After Import:')}
+  Run ${chalk.white('adf deploy <tool>')} to deploy imported artifacts
+  to your AI coding assistant (Windsurf, Cursor, etc.)
+`)
+  .action(importCommand);
+
 // adf config
 program
   .command('config')

package/conductor/tracks/session_resume_review_20260113/plan.md

@@ -0,0 +1,18 @@
+# Track: Session Resume Context Review
+
+## Objective
+Implement a feature to allow users to review previous Question/Answer pairs when resuming an ADF session. The review interface should support pagination for large histories and provide options to continue, skip, or exit the review process at any time.
+
+## Tasks
+- [x] Implement `reviewProgress()` method in `Interviewer` class with pagination support.
+- [x] Integrate `reviewProgress()` into `start()` method for resume flow.
+- [x] Handle 'back' signal in `init` command to allow returning to main menu.
+- [x] Verify implementation with tests (implicit verification via `npm test` passing existing tests and manual flow logic check).
+- [x] Add 'Processing reply...' spinner to Interviewer to indicate background AI activity.
+- [x] Fix Google Gemini follow-up truncation by optimizing prompt and lowering temperature.
+- [x] Add minimum delay to spinner to prevent 'flicker' and improve UX.
+- [x] Implement answer editing functionality during context review.
+- [x] Add `updateAnswer` method to `ProgressTracker` with unit tests.
+
+## Context
+Users resuming a session often need context on what they answered previously. Dumping all answers at once can overwhelm the terminal. A paginated review process improves UX and allows users to re-orient themselves before continuing.

package/conductor/tracks.md

@@ -7,3 +7,7 @@ This file tracks all major tracks for the project. Each track has its own detail
 ## [x] Track: Bootstrap Agent-Native Documentation
 *Link: [./conductor/tracks/bootstrap_agents_20260111/](./conductor/tracks/bootstrap_agents_20260111/)*
 
+## [x] Track: Session Resume Context Review
+*Link: [./conductor/tracks/session_resume_review_20260113/](./conductor/tracks/session_resume_review_20260113/)*
+
+

package/gemini.md

@@ -0,0 +1,3 @@
+# Gemini Global Rules
+
+- Do not engage in the execution of multiple tasks at once, make sure you stay focused, use context and work through each task one-at-a-time from beginning (problem definition or task goal) to conclusion (meet goal through iterative unit test or code validation, ensuring accurate representation of successful completion). It is imperative that you perform better today than you did yesterday by paying more attention to detail and ensuring that if you offer confirmation of completion for any task, that statement has the highest probability of being 100% true (to the best of your ability)

package/lib/ai/ai-client.js

@@ -403,21 +403,21 @@ Respond with ONLY a JSON object in this exact format:
    * Generate follow-up question based on answer quality
    */
   async generateFollowUp(originalQuestion, answer, issues) {
-    const prompt = `You are an expert software requirements analyst. Based on the user's answer, generate a helpful follow-up question.
+    const prompt = `You are a helpful software requirements analyst.
+The user provided an answer that is a bit vague.
+Your task is to ask a polite follow-up question to get more specific details.
 
 Original Question: ${originalQuestion}
-
 User's Answer: ${answer}
+Missing Information: ${issues.join(', ')}
 
-Issues Identified: ${issues.join(', ')}
-
-Generate ONE concise follow-up question (max 20 words) to help the user provide more specific information. Focus on the most critical missing element.
-
-Respond with ONLY the follow-up question, no explanation.`;
+Please generate one single follow-up question.
+Example: "Could you specify which database you plan to use?"
+Question:`;
 
     const response = await this.sendMessage(prompt, {
-      maxTokens: 100,
-      temperature: 0.7
+      maxTokens: 300,
+      temperature: 0.4
     });
 
     return response.content.trim().replace(/^["']|["']$/g, ''); // Remove quotes if present

package/lib/commands/deploy.js

@@ -159,6 +159,20 @@ async function deployToTool(tool, options = {}) {
       console.warn(chalk.yellow(`\n⚠️  Warning: Could not generate AGENTS.md: ${error.message}`));
     }
 
+    // Generate A2A agent cards (if not already present)
+    const a2aDir = path.join(cwd, '.a2a');
+    if (!await fs.pathExists(a2aDir)) {
+      try {
+        const { generateA2A } = require('../generators');
+        await generateA2A(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated A2A agent cards'));
+        }
+      } catch (error) {
+        console.warn(chalk.yellow(`⚠ Could not generate A2A cards: ${error.message}`));
+      }
+    }
+
     // Generate tool-specific configurations
     if (spinner) spinner.text = `Generating ${TOOLS[tool]?.name || tool} configurations...`;
 

package/lib/commands/guide.js

@@ -295,6 +295,38 @@ const TOOL_GUIDES = {
     ]
   },
 
+  'a2a': {
+    name: 'A2A (Agent-to-Agent) Protocol',
+    files: [
+      { path: '.a2a/agent-card.json', desc: 'Combined discovery card with all agent skills' },
+      { path: '.a2a/agents/*.json', desc: 'Individual agent cards (dev, qa, pm, etc.)' },
+      { path: 'AGENTS.md', desc: 'Universal agent manifest' }
+    ],
+    setup: [
+      '1. A2A cards are auto-generated during `adf init`',
+      '2. Cards are also created as fallback during `adf deploy <tool>`',
+      '3. No additional setup required — cards follow the A2A protocol spec',
+      '4. Individual agent cards are in .a2a/agents/',
+      '5. Combined discovery card at .a2a/agent-card.json'
+    ],
+    usage: [
+      '• A2A cards enable interoperability with any A2A-compatible tool',
+      '• Combined card (.a2a/agent-card.json) lists all agents and skills',
+      '• Individual cards (.a2a/agents/<name>.json) per agent role',
+      '• Skills are derived from agent markdown frontmatter',
+      '• Cards include MCP tool references from agent definitions',
+      '• Protocol version: 0.3 (JSONRPC binding)',
+      '• Spec: https://google.github.io/A2A/'
+    ],
+    mcpServers: [],
+    troubleshooting: [
+      '• Cards not generated? Run `adf init` or `adf deploy <tool>`',
+      '• Missing agents? Check workflow level (rapid=2, balanced=4, comprehensive=6)',
+      '• Regenerate by deleting .a2a/ directory and running deploy again',
+      '• Validate JSON: cat .a2a/agent-card.json | python -m json.tool'
+    ]
+  },
+
   'deepagent': {
     name: 'Abacus.ai DeepAgent',
     files: [

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;