@smartmemory/compose 0.1.0

package/lib/import.js

@@ -0,0 +1,244 @@
+/**
+ * import.js — Scan an existing project and generate a structured analysis.
+ *
+ * Produces docs/discovery/project-analysis.md which is automatically
+ * picked up by compose new/build as context for agents.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
+import { join, relative, extname, basename } from 'node:path';
+
+import { runAndNormalize } from './result-normalizer.js';
+import { ClaudeSDKConnector } from '../server/connectors/claude-sdk-connector.js';
+
+// ---------------------------------------------------------------------------
+// File tree scanner
+// ---------------------------------------------------------------------------
+
+const IGNORE_DIRS = new Set([
+  'node_modules', '.git', '.compose', 'dist', 'build', 'coverage',
+  '.next', '.nuxt', '__pycache__', '.venv', 'venv', 'target',
+  '.cache', '.parcel-cache', '.turbo',
+]);
+
+const IGNORE_FILES = new Set([
+  'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
+  '.DS_Store', 'Thumbs.db',
+]);
+
+function walkTree(dir, root, maxDepth = 4, depth = 0) {
+  const entries = [];
+  if (depth > maxDepth) return entries;
+
+  let items;
+  try { items = readdirSync(dir); } catch { return entries; }
+
+  for (const item of items) {
+    if (IGNORE_DIRS.has(item) || IGNORE_FILES.has(item)) continue;
+    if (item.startsWith('.') && depth === 0 && item !== '.env.example') continue;
+
+    const fullPath = join(dir, item);
+    const relPath = relative(root, fullPath);
+    let stat;
+    try { stat = statSync(fullPath); } catch { continue; }
+
+    if (stat.isDirectory()) {
+      entries.push({ path: relPath, type: 'dir' });
+      entries.push(...walkTree(fullPath, root, maxDepth, depth + 1));
+    } else {
+      entries.push({ path: relPath, type: 'file', size: stat.size });
+    }
+  }
+  return entries;
+}
+
+// ---------------------------------------------------------------------------
+// Key file reader
+// ---------------------------------------------------------------------------
+
+const KEY_FILES = [
+  'README.md', 'README', 'readme.md',
+  'package.json', 'pyproject.toml', 'Cargo.toml', 'go.mod', 'Gemfile',
+  'Makefile', 'Dockerfile', 'docker-compose.yml', 'docker-compose.yaml',
+  '.env.example',
+  'tsconfig.json', 'vite.config.js', 'vite.config.ts',
+  'CLAUDE.md', 'AGENTS.md',
+  'ROADMAP.md', 'CHANGELOG.md',
+];
+
+const KEY_DIRS = ['docs', 'src', 'lib', 'bin', 'test', 'tests', 'spec', 'api', 'scripts'];
+
+function readKeyFiles(cwd, maxContentSize = 8000) {
+  const files = {};
+
+  // Read known key files
+  for (const name of KEY_FILES) {
+    const p = join(cwd, name);
+    if (existsSync(p)) {
+      const content = readFileSync(p, 'utf-8');
+      files[name] = content.length > maxContentSize
+        ? content.slice(0, maxContentSize) + '\n...(truncated)'
+        : content;
+    }
+  }
+
+  // Read top-level files in key directories (just filenames + first lines)
+  for (const dir of KEY_DIRS) {
+    const dirPath = join(cwd, dir);
+    if (!existsSync(dirPath)) continue;
+    try {
+      const items = readdirSync(dirPath);
+      for (const item of items.slice(0, 30)) {
+        const p = join(dirPath, item);
+        let stat;
+        try { stat = statSync(p); } catch { continue; }
+        if (!stat.isFile()) continue;
+
+        const relPath = join(dir, item);
+        const content = readFileSync(p, 'utf-8');
+        // Include first 40 lines to give structure context
+        const preview = content.split('\n').slice(0, 40).join('\n');
+        files[relPath] = preview.length < content.length
+          ? preview + '\n...(truncated)'
+          : preview;
+      }
+    } catch { /* skip */ }
+  }
+
+  return files;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+/**
+ * Scan a project and generate a structured analysis.
+ *
+ * @param {object} opts
+ * @param {string}   [opts.cwd]              - Working directory
+ * @param {Function} [opts.connectorFactory] - Override connector (for testing)
+ */
+export async function runImport(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const getConnector = opts.connectorFactory ?? (() => new ClaudeSDKConnector({ cwd }));
+
+  console.log('Scanning project...\n');
+
+  // 1. Build file tree
+  const tree = walkTree(cwd, cwd);
+  const fileCount = tree.filter(e => e.type === 'file').length;
+  const dirCount = tree.filter(e => e.type === 'dir').length;
+  console.log(`  ${fileCount} files, ${dirCount} directories`);
+
+  // 2. Read key files
+  const keyFiles = readKeyFiles(cwd);
+  console.log(`  ${Object.keys(keyFiles).length} key files read`);
+
+  // 3. Build tree string
+  const treeStr = tree.map(e => {
+    if (e.type === 'dir') return `${e.path}/`;
+    const kb = (e.size / 1024).toFixed(1);
+    return `${e.path} (${kb}kb)`;
+  }).join('\n');
+
+  // 4. Build key file contents
+  const keyFileStr = Object.entries(keyFiles)
+    .map(([name, content]) => `--- ${name} ---\n${content}`)
+    .join('\n\n');
+
+  // 5. Dispatch to claude for analysis
+  console.log('\nAnalyzing...\n');
+
+  const prompt = `You are analyzing an existing software project to produce a structured analysis document.
+
+## Project file tree
+\`\`\`
+${treeStr}
+\`\`\`
+
+## Key file contents
+${keyFileStr}
+
+## Task
+
+Write a comprehensive project analysis to \`docs/discovery/project-analysis.md\` with these sections:
+
+### 1. Project Overview
+- What this project does (inferred from code, README, configs)
+- Primary language/framework/runtime
+- Current maturity (prototype, MVP, production)
+
+### 2. Architecture
+- High-level component map (what talks to what)
+- Key directories and what they contain
+- Entry points (CLI, server, library exports)
+- External dependencies and what they're used for
+
+### 3. Feature Inventory
+For each distinct feature/capability already built:
+- Feature name and suggested code (e.g., AUTH-1, API-2)
+- Status: working, partial, stub
+- Key files involved
+- Test coverage: tested, untested, partially tested
+
+### 4. Patterns & Conventions
+- Code style (ESM/CJS, naming, file organization)
+- Testing approach (framework, fixtures, mocks)
+- Build/deploy setup
+- Configuration approach
+
+### 5. Gaps & Opportunities
+- Missing tests
+- Missing docs
+- Incomplete features
+- Technical debt
+
+### 6. Suggested Roadmap
+Based on the analysis, suggest a phased roadmap with feature codes.
+Use the format:
+| # | Feature | Item | Status |
+|---|---------|------|--------|
+| 1 | CODE-1  | Description | COMPLETE/PARTIAL/PLANNED |
+
+Write the full analysis to \`docs/discovery/project-analysis.md\`.
+
+Return JSON: { "summary": string, "features": [{"code": string, "name": string, "status": string}], "artifact": "docs/discovery/project-analysis.md" }`;
+
+  const connector = getConnector();
+  const { result } = await runAndNormalize(connector, prompt, {
+    output_contract: 'AnalysisResult',
+    output_fields: [
+      { name: 'summary', type: 'string' },
+      { name: 'features', type: 'array' },
+      { name: 'artifact', type: 'string' },
+    ],
+  });
+
+  // 6. Verify the analysis was written
+  const analysisPath = join(cwd, 'docs', 'discovery', 'project-analysis.md');
+  if (!existsSync(analysisPath)) {
+    // Agent may not have written it — write a fallback from the result
+    mkdirSync(join(cwd, 'docs', 'discovery'), { recursive: true });
+    if (result?.summary) {
+      writeFileSync(analysisPath, `# Project Analysis\n\n${result.summary}\n`);
+      console.log(`Wrote fallback analysis to ${relative(cwd, analysisPath)}`);
+    }
+  } else {
+    console.log(`Analysis written to ${relative(cwd, analysisPath)}`);
+  }
+
+  // 7. Report features found
+  if (result?.features?.length) {
+    console.log(`\nFeatures identified:`);
+    for (const f of result.features) {
+      const status = f.status ?? 'unknown';
+      console.log(`  ${f.code.padEnd(10)} ${f.name} (${status})`);
+    }
+  }
+
+  console.log('\nNext steps:');
+  console.log('  compose new <name> "intent"     # kickoff with this context');
+  console.log('  compose feature <CODE> "desc"    # add a specific feature');
+  console.log('  compose build <CODE>             # build a feature');
+}

package/lib/migrate-roadmap.js

@@ -0,0 +1,94 @@
+/**
+ * migrate-roadmap.js — One-time migration from ROADMAP.md to feature.json files.
+ *
+ * Reads the existing ROADMAP.md, extracts feature entries using roadmap-parser,
+ * and creates feature.json files for each real (non-anonymous) feature.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { parseRoadmap } from './roadmap-parser.js';
+import { readFeature, writeFeature } from './feature-json.js';
+
+/**
+ * Migrate ROADMAP.md entries to feature.json files.
+ *
+ * @param {string} cwd - Project root
+ * @param {object} [opts]
+ * @param {string} [opts.featuresDir] - Relative features path
+ * @param {boolean} [opts.dryRun] - Print what would be created without writing
+ * @param {boolean} [opts.overwrite] - Overwrite existing feature.json files
+ * @returns {{ created: string[], skipped: string[], updated: string[] }}
+ */
+export function migrateRoadmap(cwd, opts = {}) {
+  const featuresDir = opts.featuresDir ?? 'docs/features';
+  const roadmapPath = join(cwd, 'ROADMAP.md');
+
+  if (!existsSync(roadmapPath)) {
+    throw new Error(`No ROADMAP.md found at ${roadmapPath}`);
+  }
+
+  const text = readFileSync(roadmapPath, 'utf-8');
+  const entries = parseRoadmap(text);
+
+  const created = [];
+  const skipped = [];
+  const updated = [];
+
+  for (const entry of entries) {
+    // Skip anonymous entries
+    if (entry.code.startsWith('_anon_')) continue;
+
+    const existing = readFeature(cwd, entry.code, featuresDir);
+
+    if (existing && !opts.overwrite) {
+      skipped.push(entry.code);
+      continue;
+    }
+
+    // Extract phase name (strip milestone nesting for clean grouping)
+    const phase = extractPhase(entry.phaseId);
+
+    const feature = {
+      code: entry.code,
+      description: entry.description,
+      status: entry.status,
+      phase,
+      position: entry.position,
+      ...(existing ?? {}),
+      // Always update status from ROADMAP (source of truth during migration)
+      status: entry.status,
+    };
+
+    // Set created date if new
+    if (!feature.created) {
+      feature.created = new Date().toISOString().slice(0, 10);
+    }
+
+    if (opts.dryRun) {
+      console.log(`${existing ? 'update' : 'create'}: ${featuresDir}/${entry.code}/feature.json`);
+    } else {
+      writeFeature(cwd, feature, featuresDir);
+    }
+
+    if (existing) {
+      updated.push(entry.code);
+    } else {
+      created.push(entry.code);
+    }
+  }
+
+  return { created, skipped, updated };
+}
+
+/**
+ * Clean up phase ID from the parser (strip milestone nesting).
+ * "STRAT-1: Stratum Process Engine + Compose MVP > Milestone 2: Headless Compose Runner"
+ *  → "STRAT-1: Stratum Process Engine + Compose MVP"
+ */
+function extractPhase(phaseId) {
+  if (!phaseId) return null;
+  // Use the top-level phase, not the milestone
+  const parts = phaseId.split(' > ');
+  return parts[0].trim();
+}

package/lib/model-pricing.js

@@ -0,0 +1,67 @@
+/**
+ * model-pricing.js — Token cost lookup and USD calculation.
+ *
+ * Prices are per-million tokens (MTok) as of 2025.
+ * Input price includes standard prompt tokens.
+ * Cache write tokens (cache_creation_input_tokens) are billed at 1.25x input rate.
+ * Cache read tokens (cache_read_input_tokens) are billed at 0.1x input rate.
+ */
+
+/**
+ * Pricing map: modelID → { inputPerMTok, outputPerMTok } in USD.
+ * Keys are matched by prefix so 'claude-sonnet-4-6' matches 'claude-sonnet-4-6-20250514' etc.
+ */
+export const MODEL_PRICING = {
+  'claude-opus-4-7':    { inputPerMTok: 5,   outputPerMTok: 25 },
+  'claude-opus-4-6':    { inputPerMTok: 5,   outputPerMTok: 25 },
+  'claude-sonnet-4-6':  { inputPerMTok: 3,   outputPerMTok: 15 },
+  'claude-haiku-4-5':   { inputPerMTok: 1,   outputPerMTok: 5  },
+};
+
+/**
+ * Look up pricing for a model ID.
+ * Tries exact match first, then prefix match (handles dated variants).
+ *
+ * @param {string} modelID
+ * @returns {{ inputPerMTok: number, outputPerMTok: number } | null}
+ */
+function lookupPricing(modelID) {
+  if (!modelID) return null;
+
+  // Exact match
+  if (MODEL_PRICING[modelID]) return MODEL_PRICING[modelID];
+
+  // Prefix match — handles e.g. 'claude-sonnet-4-6-20250514'
+  for (const [key, pricing] of Object.entries(MODEL_PRICING)) {
+    if (modelID.startsWith(key)) return pricing;
+  }
+
+  return null;
+}
+
+/**
+ * Calculate the USD cost for a single agent call.
+ *
+ * @param {string} modelID
+ * @param {number} inputTokens         Standard prompt tokens
+ * @param {number} outputTokens        Completion tokens
+ * @param {number} [cacheWriteTokens]  cache_creation_input_tokens (billed at 1.25x input)
+ * @param {number} [cacheReadTokens]   cache_read_input_tokens (billed at 0.1x input)
+ * @returns {number} USD cost (0 for unknown models or zero-token calls)
+ */
+export function calculateCost(modelID, inputTokens, outputTokens, cacheWriteTokens = 0, cacheReadTokens = 0) {
+  const pricing = lookupPricing(modelID);
+  if (!pricing) return 0;
+
+  const totalInput = (inputTokens ?? 0) + (cacheWriteTokens ?? 0) + (cacheReadTokens ?? 0);
+  const totalOutput = outputTokens ?? 0;
+
+  if (totalInput === 0 && totalOutput === 0) return 0;
+
+  const inputCost  = ((inputTokens ?? 0) / 1_000_000) * pricing.inputPerMTok;
+  const writeCost  = ((cacheWriteTokens ?? 0) / 1_000_000) * pricing.inputPerMTok * 1.25;
+  const readCost   = ((cacheReadTokens ?? 0) / 1_000_000) * pricing.inputPerMTok * 0.1;
+  const outputCost = ((outputTokens ?? 0) / 1_000_000) * pricing.outputPerMTok;
+
+  return inputCost + writeCost + readCost + outputCost;
+}