universal-agent-memory 0.5.0 → 0.5.1

package/README.md

@@ -3,404 +3,221 @@
 [![npm version](https://img.shields.io/npm/v/universal-agent-memory.svg)](https://www.npmjs.com/package/universal-agent-memory)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-A complete autonomous agent operating system for AI coding assistants. Provides memory, task management, agent coordination, and workflow automation for Claude Code, Factory.AI, VSCode, OpenCode, and web-based LLMs.
+**Give your AI coding assistant persistent memory and autonomous workflows.**
 
-## What It Does
+UAM transforms AI coding assistants (Claude Code, Factory.AI, etc.) into autonomous agents that remember context across sessions, coordinate with other agents, and follow consistent workflows.
 
-UAM transforms AI coding assistants into autonomous agents with:
+## How It Works
 
-- **4-Layer Memory System** - Working, session, semantic, and knowledge graph memory
-- **Task Management** - Git-backed issue tracking with dependency DAG (superior to Beads)
-- **Agent Coordination** - Multi-agent overlap detection and merge conflict prevention
-- **Deploy Batching** - Batch commits/pushes to save CI minutes
-- **Git Worktree Automation** - Isolated development branches with PR workflows
-- **CLAUDE.md Generation** - Auto-generated project context files
+1. **Install UAM** in your project
+2. **Generate CLAUDE.md** - a context file your AI reads automatically
+3. **The AI handles everything** - memory, tasks, worktrees, coordination
 
-## Installation
+**You don't manage memory manually.** The AI agent reads CLAUDE.md and autonomously uses the memory system, creates worktrees, tracks tasks, and coordinates with other agents.
 
-### Quick Install (Recommended)
+## Quick Start
 
 ```bash
-# Install globally
+# Install
 npm install -g universal-agent-memory
 
 # Initialize in your project
 cd your-project
-uam init --interactive
-```
-
-### One-Line Installers
-
-```bash
-# Desktop (with Docker for Qdrant)
-bash <(curl -fsSL https://raw.githubusercontent.com/DammianMiller/universal-agent-memory/main/scripts/install-desktop.sh)
-
-# Web browsers (claude.ai, factory.ai)
-bash <(curl -fsSL https://raw.githubusercontent.com/DammianMiller/universal-agent-memory/main/scripts/install-web.sh)
-```
-
-### Using npx (No Install)
-
-```bash
-npx universal-agent-memory init --interactive
-```
-
-## Quick Start
-
-```bash
-# 1. Initialize project
 uam init --with-memory --with-worktrees
 
-# 2. Start memory services (requires Docker)
+# Start memory services (optional, for persistent semantic memory)
 uam memory start
 
-# 3. Generate CLAUDE.md
+# Generate the CLAUDE.md context file
 uam generate
-
-# 4. Create your first task
-uam task create --title "My first task" --type task
-
-# 5. Start working
-uam task claim <task-id>
-uam worktree create my-feature
 ```
 
-## Core Features
+That's it! Your AI assistant now has:
+- **Persistent memory** across sessions
+- **Task tracking** with dependencies
+- **Git worktree workflows** (never commits to main)
+- **Multi-agent coordination** (prevents merge conflicts)
 
-### Task Management
+## Example: Working With an AI Agent
 
-A complete task tracking system integrated with memory and coordination.
+After setup, just talk to your AI assistant normally:
 
-```bash
-# Create tasks
-uam task create --title "Fix auth bug" --type bug --priority 0
-uam task create --title "Add dark mode" --type feature --priority 2
-
-# View tasks
-uam task list                              # All open tasks
-uam task ready                             # Tasks with no blockers
-uam task blocked                           # Blocked tasks
-uam task stats                             # Statistics
-
-# Work on tasks
-uam task claim <id>                        # Claim task (announces to other agents)
-uam task show <id>                         # View details
-uam task release <id> --reason "Fixed"     # Complete task
-
-# Dependencies
-uam task dep --from <child> --to <parent>  # Add blocker
-uam task undep --from <child> --to <parent># Remove blocker
-
-# Git sync (version control your tasks)
-uam task sync                              # Export to JSONL
-uam task compact --days 90                 # Archive old tasks
 ```
-
-**Task Types**: `task`, `bug`, `feature`, `chore`, `epic`, `story`
-
-**Priority Levels**: P0 (critical) → P4 (backlog)
-
-### Memory System
-
-4-layer architecture for complete context retention.
-
-```bash
-# Start services
-uam memory start                           # Start Qdrant (Docker)
-uam memory status                          # Check status
-uam memory stop                            # Stop services
-
-# Query memories
-uam memory query "authentication JWT"      # Semantic search
-
-# Store learnings
-uam memory store "lesson learned" --tags "auth,security" --importance 8
+You: "Fix the authentication bug in the login handler"
+
+AI: *Automatically:*
+  1. Checks memory for past context on auth/login
+  2. Creates task: "Fix auth bug in login handler"
+  3. Creates worktree: feature/fix-auth-bug
+  4. Makes changes, runs tests
+  5. Creates PR
+  6. Stores learnings in memory for next time
 ```
 
-**Layers:**
-
-| Layer | Storage | Purpose | Speed |
-|-------|---------|---------|-------|
-| L1: Working | SQLite | Recent actions (last 50) | ~0.15ms |
-| L2: Session | SQLite | Session decisions | ~0.2ms |
-| L3: Semantic | Qdrant | Reusable learnings | ~1-2ms |
-| L4: Knowledge Graph | SQLite | Entity relationships | ~0.17ms |
-
-### Agent Coordination
+The AI follows the workflow defined in CLAUDE.md without you managing any of it.
 
-Multi-agent support with overlap detection and messaging.
+## What Gets Generated
 
-```bash
-# Register agent
-uam agent register --name "feature-agent" --capabilities "coding,review"
-
-# Announce work (enables overlap detection)
-uam agent announce --id <agent-id> --resource "src/auth/" --intent editing
-
-# Check for conflicts
-uam agent overlaps --resource "src/auth/"
+`uam generate` creates a `CLAUDE.md` file that includes:
 
-# Complete work
-uam agent complete --id <agent-id> --resource "src/auth/"
+- **Project structure** auto-detected from your codebase
+- **Memory system** configuration (SQLite + Qdrant)
+- **Workflow rules** (worktrees, testing, PR creation)
+- **Agent coordination** protocols
+- **Troubleshooting** from git history
 
-# Status
-uam agent status                           # View all agents
-uam coord status                           # Coordination overview
-```
-
-**Conflict Risk Levels**: `none`, `low`, `medium`, `high`, `critical`
+The AI reads this file and follows the instructions autonomously.
 
-### Deploy Batching
+## Installation Options
 
-Batch multiple commits/pushes to reduce CI runs.
+### npm (Recommended)
 
 ```bash
-# Queue commits
-uam deploy queue --agent-id <id> --action-type commit \
-  --message "feat: add feature" --files "src/feature.ts"
-
-# View queue
-uam deploy status
-
-# Execute batched deploys
-uam deploy flush                           # Squashes commits, single push
+npm install -g universal-agent-memory
 ```
 
-### Git Worktrees
-
-Isolated development branches with automated PR workflow.
+### One-Line Installers
 
 ```bash
-# Create worktree
-uam worktree create my-feature             # Creates feature/NNN-my-feature
-
-# List worktrees
-uam worktree list
-
-# Create PR
-uam worktree pr <id>                       # Push + create PR
+# Desktop (includes Docker for Qdrant)
+bash <(curl -fsSL https://raw.githubusercontent.com/DammianMiller/universal-agent-memory/main/scripts/install-desktop.sh)
 
-# Cleanup
-uam worktree cleanup <id>                  # Remove worktree + delete branch
+# Web browsers (claude.ai, factory.ai)
+bash <(curl -fsSL https://raw.githubusercontent.com/DammianMiller/universal-agent-memory/main/scripts/install-web.sh)
 ```
 
-### CLAUDE.md Generation
-
-Auto-generate context files for AI assistants.
+### npx (No Install)
 
 ```bash
-# Analyze project
-uam analyze --output json
-
-# Generate CLAUDE.md
-uam generate                               # Interactive merge with existing
-uam generate --force                       # Overwrite
-uam generate --dry-run                     # Preview only
+npx universal-agent-memory init --interactive
 ```
 
-## Command Reference
+## Commands
 
-### Core Commands
+### Essential Commands
 
 | Command | Description |
 |---------|-------------|
 | `uam init` | Initialize UAM in a project |
-| `uam analyze` | Analyze project structure |
-| `uam generate` | Generate CLAUDE.md |
-| `uam sync` | Sync between platforms |
+| `uam generate` | Generate/update CLAUDE.md |
+| `uam memory start` | Start Qdrant (for semantic memory) |
+| `uam memory status` | Check if services are running |
 
-### Task Commands
+### Task Commands (Used by AI)
 
 | Command | Description |
 |---------|-------------|
 | `uam task create` | Create a new task |
-| `uam task list` | List tasks (with filters) |
-| `uam task show <id>` | Show task details |
-| `uam task claim <id>` | Claim task for work |
-| `uam task release <id>` | Complete and release task |
-| `uam task ready` | Show unblocked tasks |
-| `uam task blocked` | Show blocked tasks |
-| `uam task dep` | Add dependency |
-| `uam task stats` | Show statistics |
-| `uam task sync` | Sync with JSONL |
-
-### Memory Commands
-
-| Command | Description |
-|---------|-------------|
-| `uam memory start` | Start Qdrant (Docker) |
-| `uam memory stop` | Stop memory services |
-| `uam memory status` | Check service status |
-| `uam memory query` | Semantic search |
-| `uam memory store` | Store a learning |
-
-### Agent Commands
+| `uam task list` | List all tasks |
+| `uam task ready` | Show tasks with no blockers |
+| `uam task claim <id>` | Claim a task for work |
 
-| Command | Description |
-|---------|-------------|
-| `uam agent register` | Register new agent |
-| `uam agent announce` | Announce work on resource |
-| `uam agent overlaps` | Check for conflicts |
-| `uam agent complete` | Mark work complete |
-| `uam agent status` | Show agent status |
-| `uam agent broadcast` | Send to all agents |
-| `uam agent send` | Direct message |
-| `uam agent receive` | Get pending messages |
-
-### Coordination Commands
+### Worktree Commands (Used by AI)
 
 | Command | Description |
 |---------|-------------|
-| `uam coord status` | Overview of coordination |
-| `uam coord flush` | Execute pending deploys |
-| `uam coord cleanup` | Clean stale data |
+| `uam worktree create <name>` | Create isolated branch |
+| `uam worktree pr <id>` | Create PR from worktree |
+| `uam worktree cleanup <id>` | Remove worktree |
 
-### Deploy Commands
+### Agent Coordination (Used by AI)
 
 | Command | Description |
 |---------|-------------|
-| `uam deploy queue` | Queue a deploy action |
-| `uam deploy status` | View deploy queue |
-| `uam deploy batch` | Create batch from queue |
-| `uam deploy execute` | Execute a batch |
-| `uam deploy flush` | Batch and execute all |
+| `uam agent overlaps` | Check for file conflicts |
+| `uam agent announce` | Announce work on files |
+| `uam agent status` | View active agents |
 
-### Worktree Commands
+## Memory Architecture
 
-| Command | Description |
-|---------|-------------|
-| `uam worktree create` | Create feature worktree |
-| `uam worktree list` | List all worktrees |
-| `uam worktree pr` | Create PR from worktree |
-| `uam worktree cleanup` | Remove worktree |
+UAM uses a 4-layer memory system, all managed automatically by the AI:
 
-### Droids Commands
+| Layer | Purpose | Storage |
+|-------|---------|---------|
+| Working | Recent actions (last 50) | SQLite |
+| Session | Current session context | SQLite |
+| Semantic | Reusable learnings | Qdrant |
+| Knowledge Graph | Entity relationships | SQLite |
 
-| Command | Description |
-|---------|-------------|
-| `uam droids list` | List available droids |
-| `uam droids add` | Add a new droid |
-| `uam droids import` | Import from path |
+**You don't need to understand this** - the AI handles memory storage and retrieval automatically based on the CLAUDE.md instructions.
 
 ## Configuration
 
-Configuration is stored in `.uam.json`:
+After `uam init`, configuration is in `.uam.json`:
 
 ```json
 {
-  "version": "1.0.0",
   "project": {
     "name": "my-project",
     "defaultBranch": "main"
   },
   "memory": {
-    "shortTerm": {
-      "enabled": true,
-      "path": "./agents/data/memory/short_term.db",
-      "maxEntries": 50
-    },
-    "longTerm": {
-      "enabled": true,
-      "provider": "qdrant",
-      "endpoint": "localhost:6333",
-      "collection": "agent_memory"
-    }
+    "shortTerm": { "enabled": true },
+    "longTerm": { "enabled": true, "provider": "qdrant" }
   },
   "worktrees": {
     "enabled": true,
-    "directory": ".worktrees",
-    "branchPrefix": "feature/"
+    "directory": ".worktrees"
   }
 }
 ```
 
 ## Platform Support
 
-| Platform | Environment | Context File | Agents/Droids |
-|----------|-------------|--------------|---------------|
-| Claude Code | Desktop | `CLAUDE.md` | `.claude/agents/` |
-| claude.ai | Web | `CLAUDE.md` | Project context |
-| Factory.AI | Desktop | `CLAUDE.md` | `.factory/droids/` |
-| factory.ai | Web | `CLAUDE.md` | Project context |
-| VSCode | Desktop | `CLAUDE.md` | Extension-based |
-| OpenCode | Desktop | `opencode.json` | `.opencode/agent/` |
-
-## Workflow Engine
-
-UAM enforces a 5-phase workflow for every agent action:
-
-```
-START → TASK → CONTEXT → WORK → COMPLETE
-```
+| Platform | Context File | Works With |
+|----------|--------------|------------|
+| Claude Code | `CLAUDE.md` | Desktop app |
+| Factory.AI | `CLAUDE.md` | Desktop/web |
+| claude.ai | `CLAUDE.md` | Web browser |
+| VSCode + Extensions | `CLAUDE.md` | Desktop |
 
-1. **START**: Check existing tasks, read memory
-2. **TASK**: Create/claim task before any work
-3. **CONTEXT**: Query memory, check skills
-4. **WORK**: Create worktree, make changes, test, PR
-5. **COMPLETE**: Update memory, release task
+## Built-in Droids
 
-Each phase has **gates** that must pass before proceeding.
+Quality review agents that run automatically before PRs:
 
-## Memory Backends
+| Droid | Purpose |
+|-------|---------|
+| `code-quality-guardian` | Code review, SOLID principles |
+| `security-auditor` | OWASP, secrets detection |
+| `performance-optimizer` | Algorithm efficiency |
+| `documentation-expert` | Docs completeness |
 
-### Desktop
+## Requirements
 
-- **Short-term**: SQLite (local file)
-- **Long-term**: Qdrant (Docker) or Qdrant Cloud
+- Node.js 18+
+- Docker (optional, for persistent semantic memory)
+- Git
 
-### Web (claude.ai, factory.ai)
+## FAQ
 
-- **Short-term**: IndexedDB (browser)
-- **Long-term**: GitHub or Qdrant Cloud
+**Q: Do I need to run memory commands manually?**  
+A: No. The AI reads CLAUDE.md and manages memory automatically.
 
-```bash
-# Cloud backends (optional)
-export QDRANT_API_KEY=your_key
-export QDRANT_URL=https://xxx.aws.cloud.qdrant.io:6333
-export GITHUB_TOKEN=your_token
-```
+**Q: What if I don't have Docker?**  
+A: UAM works without Docker. You lose semantic (long-term) memory, but short-term and session memory still work via SQLite.
 
-## Built-in Droids
+**Q: Can multiple AI agents work on the same project?**  
+A: Yes. UAM includes coordination protocols to prevent merge conflicts.
 
-| Droid | Purpose |
-|-------|---------|
-| `code-quality-guardian` | Code review, complexity, SOLID |
-| `security-auditor` | OWASP, secrets, injection |
-| `performance-optimizer` | Algorithms, memory, caching |
-| `documentation-expert` | JSDoc, README, accuracy |
+**Q: How do I update CLAUDE.md after project changes?**  
+A: Run `uam generate` again. It will intelligently merge with your existing file.
 
 ## Development
 
 ```bash
-# Clone
 git clone https://github.com/DammianMiller/universal-agent-memory.git
 cd universal-agent-memory
-
-# Install
 npm install
-
-# Build
 npm run build
-
-# Test
 npm test
-
-# Run locally
-npm start -- init --interactive
 ```
 
-## Requirements
-
-- Node.js 18+
-- Docker (for local Qdrant)
-- Git
-
 ## License
 
 MIT
 
 ## Links
 
-- [GitHub Repository](https://github.com/DammianMiller/universal-agent-memory)
-- [npm Package](https://www.npmjs.com/package/universal-agent-memory)
-- [Issue Tracker](https://github.com/DammianMiller/universal-agent-memory/issues)
+- [GitHub](https://github.com/DammianMiller/universal-agent-memory)
+- [npm](https://www.npmjs.com/package/universal-agent-memory)
+- [Issues](https://github.com/DammianMiller/universal-agent-memory/issues)

package/dist/cli/generate.d.ts

@@ -4,6 +4,13 @@ interface GenerateOptions {
     platform?: string;
     web?: boolean;
 }
+interface DependencyStatus {
+    git: boolean;
+    docker: boolean;
+    node: boolean;
+    qdrant: boolean;
+}
+export declare function printDependencyHelp(deps: DependencyStatus): void;
 export declare function generateCommand(options: GenerateOptions): Promise<void>;
 export {};
 //# sourceMappingURL=generate.d.ts.map

package/dist/cli/generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/cli/generate.ts"],"names":[],"mappings":"AAWA,UAAU,eAAe;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CA4K7E"}
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/cli/generate.ts"],"names":[],"mappings":"AAYA,UAAU,eAAe;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,UAAU,gBAAgB;IACxB,GAAG,EAAE,OAAO,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;CACjB;AAoCD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAqBhE;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAoN7E"}

package/dist/cli/generate.js

@@ -3,13 +3,72 @@ import ora from 'ora';
 import inquirer from 'inquirer';
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
+import { execSync } from 'child_process';
 import { analyzeProject } from '../analyzers/index.js';
 import { generateClaudeMd } from '../generators/claude-md.js';
 import { AgentContextConfigSchema } from '../types/index.js';
-import { mergeClaudeMd } from '../utils/merge-claude-md.js';
+import { mergeClaudeMd, validateMerge } from '../utils/merge-claude-md.js';
+function checkDependencies() {
+    const status = {
+        git: false,
+        docker: false,
+        node: true, // We're running, so Node exists
+        qdrant: false,
+    };
+    try {
+        execSync('git --version', { stdio: 'pipe' });
+        status.git = true;
+    }
+    catch {
+        // git not found
+    }
+    try {
+        execSync('docker --version', { stdio: 'pipe' });
+        status.docker = true;
+        // Check if Qdrant container is running
+        try {
+            const output = execSync('docker ps --filter "name=qdrant" --format "{{.Names}}"', { stdio: 'pipe' }).toString();
+            status.qdrant = output.includes('qdrant');
+        }
+        catch {
+            // docker ps failed
+        }
+    }
+    catch {
+        // docker not found
+    }
+    return status;
+}
+// Print dependency status - used when verbose flag is enabled
+export function printDependencyHelp(deps) {
+    console.log(chalk.bold('\n📦 Dependency Status:\n'));
+    console.log(`  ${deps.git ? '✅' : '❌'} Git: ${deps.git ? 'Available' : 'Not found'}`);
+    if (!deps.git) {
+        console.log(chalk.dim('     Install: https://git-scm.com/downloads'));
+    }
+    console.log(`  ${deps.docker ? '✅' : '⚠️ '} Docker: ${deps.docker ? 'Available' : 'Not found (optional)'}`);
+    if (!deps.docker) {
+        console.log(chalk.dim('     Install for semantic memory: https://docs.docker.com/get-docker/'));
+    }
+    console.log(`  ${deps.qdrant ? '✅' : '⚠️ '} Qdrant: ${deps.qdrant ? 'Running' : 'Not running (optional)'}`);
+    if (deps.docker && !deps.qdrant) {
+        console.log(chalk.dim('     Start with: uam memory start'));
+    }
+    else if (!deps.docker) {
+        console.log(chalk.dim('     Requires Docker - UAM works without it (no semantic memory)'));
+    }
+    console.log('');
+}
 export async function generateCommand(options) {
     const cwd = process.cwd();
     const configPath = join(cwd, '.uam.json');
+    // Check dependencies
+    const deps = checkDependencies();
+    if (!deps.git) {
+        console.error(chalk.red('\n❌ Git is required but not found.'));
+        console.log(chalk.dim('  Install Git: https://git-scm.com/downloads\n'));
+        process.exit(1);
+    }
     console.log(chalk.bold('\n📝 Generate Agent Context Files\n'));
     // Load config if exists
     let config;
@@ -129,6 +188,18 @@ export async function generateCommand(options) {
     try {
         const newClaudeMd = await generateClaudeMd(analysis, effectiveConfig);
         const claudeMd = existingContent ? mergeClaudeMd(existingContent, newClaudeMd) : newClaudeMd;
+        // Validate merge if we merged existing content
+        if (existingContent) {
+            const validation = validateMerge(existingContent, claudeMd);
+            if (!validation.valid) {
+                genSpinner.warn(`Merged with warnings`);
+                console.log(chalk.yellow('\n  Merge validation warnings:'));
+                for (const warning of validation.warnings) {
+                    console.log(chalk.dim(`    - ${warning}`));
+                }
+                console.log('');
+            }
+        }
         if (options.dryRun) {
             genSpinner.succeed(`${existingContent ? 'Merged' : 'Generated'} (dry run)`);
             console.log(chalk.dim(`\n--- ${targetFileName} Preview ---\n`));
@@ -139,7 +210,7 @@ export async function generateCommand(options) {
             writeFileSync(targetPath, claudeMd);
             genSpinner.succeed(`${existingContent ? 'Merged and updated' : 'Generated'} ${targetFileName}`);
             if (existingContent) {
-                console.log(chalk.dim('  Preserved custom sections from existing file'));
+                console.log(chalk.dim('  Preserved custom sections and extracted valuable content from existing file'));
             }
         }
     }
@@ -169,6 +240,22 @@ export async function generateCommand(options) {
     }
     if (!options.dryRun) {
         console.log(chalk.green('\n✅ Generation complete!\n'));
+        // Print helpful next steps
+        console.log(chalk.bold('Next Steps:\n'));
+        console.log('  1. Your AI assistant will now read CLAUDE.md automatically');
+        console.log('  2. The AI handles memory, tasks, and workflows autonomously');
+        console.log('  3. Just talk to your AI naturally - it follows the CLAUDE.md instructions\n');
+        // Show optional enhancements
+        if (!deps.docker || !deps.qdrant) {
+            console.log(chalk.dim('Optional: For persistent semantic memory across sessions:'));
+            if (!deps.docker) {
+                console.log(chalk.dim('  - Install Docker: https://docs.docker.com/get-docker/'));
+            }
+            if (deps.docker && !deps.qdrant) {
+                console.log(chalk.dim('  - Start Qdrant: uam memory start'));
+            }
+            console.log('');
+        }
     }
 }
 async function generatePlatformFiles(_cwd, platform, _analysis, _config, dryRun) {