@fiodos/cli 0.1.0

package/src/ast.js

@@ -0,0 +1,263 @@
+/**
+ * Layer 1b — per-file AST extraction using the real TypeScript compiler
+ * (no regexes). For each source file we extract:
+ *
+ *  - handlers: function declarations / consts named handle* | on*
+ *  - navCalls: router.push / router.replace / router.navigate / router.back
+ *    with their literal or object destinations
+ *  - alerts: Alert.alert(title, message, buttons) + whether any button is
+ *    style:'destructive' and the texts involved
+ *  - storeActions: Zustand create()(…) — function-valued properties of the
+ *    store object (the store's action surface)
+ *  - buttons: JSX elements with a title/label prop and an onPress handler
+ *  - textInputs: JSX TextInput-ish elements (signals form/typed input)
+ *  - imports: module specifiers + named/default bindings
+ *  - linkingCalls: Linking.openURL targets (tel:, maps, web)
+ *
+ * Everything returned here has provenance "static".
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+// Reuse the monorepo's TypeScript — real parser, real AST.
+const ts = require(path.join(__dirname, '../../../node_modules/typescript'));
+
+function parseFile(filePath) {
+  const text = fs.readFileSync(filePath, 'utf8');
+  return ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+}
+
+function literalText(node) {
+  if (!node) return null;
+  if (ts.isStringLiteralLike(node)) return node.text;
+  if (ts.isTemplateExpression(node)) {
+    // `/exercise-detail?id=${x}` → '/exercise-detail?id=${…}'
+    let out = node.head.text;
+    for (const span of node.templateSpans) out += '${…}' + span.literal.text;
+    return out;
+  }
+  return null;
+}
+
+function nameOfFunctionLike(node) {
+  if (ts.isFunctionDeclaration(node) && node.name) return node.name.text;
+  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+    const init = node.initializer;
+    if (init && (ts.isArrowFunction(init) || ts.isFunctionExpression(init))) return node.name.text;
+    // useCallback(fn, deps)
+    if (init && ts.isCallExpression(init) && init.arguments.length > 0) {
+      const a0 = init.arguments[0];
+      if (ts.isArrowFunction(a0) || ts.isFunctionExpression(a0)) return node.name.text;
+    }
+  }
+  return null;
+}
+
+const HANDLER_RE = /^(handle|on)[A-Z]/;
+
+function extractFromFile(filePath, appRoot) {
+  const sf = parseFile(filePath);
+  const rel = path.relative(appRoot, filePath);
+
+  const out = {
+    file: rel,
+    handlers: [],
+    navCalls: [],
+    alerts: [],
+    storeActions: [],
+    storeStateKeys: [],
+    storeName: null,
+    buttons: [],
+    textInputs: [],
+    imports: [],
+    linkingCalls: [],
+    defaultExportName: null,
+  };
+
+  function jsxAttr(attrs, names) {
+    for (const attr of attrs.properties) {
+      if (ts.isJsxAttribute(attr) && names.includes(attr.name.getText())) {
+        if (attr.initializer && ts.isStringLiteral(attr.initializer)) return attr.initializer.text;
+        if (attr.initializer && ts.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+          const lit = literalText(attr.initializer.expression);
+          if (lit) return lit;
+          return attr.initializer.expression.getText().slice(0, 80);
+        }
+      }
+    }
+    return null;
+  }
+
+  function jsxAttrHandlerName(attrs, names) {
+    for (const attr of attrs.properties) {
+      if (ts.isJsxAttribute(attr) && names.includes(attr.name.getText())) {
+        const init = attr.initializer;
+        if (init && ts.isJsxExpression(init) && init.expression) {
+          const e = init.expression;
+          if (ts.isIdentifier(e)) return e.text;
+          if (ts.isArrowFunction(e) && ts.isCallExpression(e.body)) {
+            return e.body.expression.getText();
+          }
+          return e.getText().slice(0, 60);
+        }
+      }
+    }
+    return null;
+  }
+
+  function visit(node) {
+    // imports
+    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+      const names = [];
+      const clause = node.importClause;
+      if (clause) {
+        if (clause.name) names.push(clause.name.text);
+        if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+          for (const el of clause.namedBindings.elements) names.push(el.name.text);
+        }
+      }
+      out.imports.push({ from: node.moduleSpecifier.text, names });
+    }
+
+    // default export name (screen component)
+    if (ts.isExportAssignment(node) && ts.isIdentifier(node.expression)) {
+      out.defaultExportName = node.expression.text;
+    }
+    if (ts.isFunctionDeclaration(node) && node.name &&
+        node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
+        node.modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword)) {
+      out.defaultExportName = node.name.text;
+    }
+
+    // handler functions
+    const fnName = nameOfFunctionLike(node);
+    if (fnName && HANDLER_RE.test(fnName)) {
+      out.handlers.push({ name: fnName, file: rel });
+    }
+
+    // call expressions: router.*, Alert.alert, Linking.openURL, zustand create
+    if (ts.isCallExpression(node)) {
+      const exprText = node.expression.getText();
+
+      // router.push / replace / navigate / back  (covers `router.` and bare `push(` from useRouter destructuring is rare)
+      const navMatch = exprText.match(/^(router|navigation)\.(push|replace|navigate|back|goBack)$/);
+      if (navMatch) {
+        const verb = navMatch[2];
+        let target = null;
+        const a0 = node.arguments[0];
+        if (a0) {
+          target = literalText(a0);
+          if (!target && ts.isObjectLiteralExpression(a0)) {
+            for (const p of a0.properties) {
+              if (ts.isPropertyAssignment(p) && p.name.getText() === 'pathname') {
+                target = literalText(p.initializer) || p.initializer.getText();
+              }
+            }
+          }
+        }
+        out.navCalls.push({ verb, target, file: rel });
+      }
+
+      // Alert.alert(title, message?, buttons?)
+      if (exprText === 'Alert.alert') {
+        const title = literalText(node.arguments[0]) || '';
+        const message = literalText(node.arguments[1]) || '';
+        let destructive = false;
+        const buttonTexts = [];
+        const a2 = node.arguments[2];
+        if (a2 && ts.isArrayLiteralExpression(a2)) {
+          for (const el of a2.elements) {
+            if (!ts.isObjectLiteralExpression(el)) continue;
+            for (const p of el.properties) {
+              if (!ts.isPropertyAssignment(p)) continue;
+              const key = p.name.getText();
+              if (key === 'style' && literalText(p.initializer) === 'destructive') destructive = true;
+              if (key === 'text') {
+                const t = literalText(p.initializer);
+                if (t) buttonTexts.push(t);
+              }
+            }
+          }
+        }
+        out.alerts.push({ title, message, destructive, buttonTexts, file: rel });
+      }
+
+      // Linking.openURL(...)
+      if (/^Linking\.(openURL|canOpenURL)$/.test(exprText) && node.arguments[0]) {
+        const t = literalText(node.arguments[0]) || node.arguments[0].getText().slice(0, 60);
+        out.linkingCalls.push({ target: t, file: rel });
+      }
+
+      // Zustand: create<T>()(persist((set) => ({...}))) or create((set) => ({...}))
+      if (/^create(<.*>)?$/.test(exprText.split('(')[0]) && exprText.startsWith('create')) {
+        const storeObj = findStoreObject(node);
+        if (storeObj) {
+          for (const p of storeObj.properties) {
+            if (!ts.isPropertyAssignment(p) && !ts.isShorthandPropertyAssignment(p) && !ts.isMethodDeclaration(p)) continue;
+            const key = p.name?.getText();
+            if (!key) continue;
+            const val = ts.isPropertyAssignment(p) ? p.initializer : null;
+            const isFn = ts.isMethodDeclaration(p) ||
+              (val && (ts.isArrowFunction(val) || ts.isFunctionExpression(val)));
+            if (isFn) out.storeActions.push({ name: key, file: rel });
+            else out.storeStateKeys.push(key);
+          }
+        }
+      }
+    }
+
+    // exported const useXxxStore = create(...)
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) &&
+        /use[A-Z].*Store/.test(node.name.text)) {
+      out.storeName = node.name.text;
+    }
+
+    // JSX buttons + inputs
+    if (ts.isJsxSelfClosingElement(node) || ts.isJsxOpeningElement(node)) {
+      const tag = node.tagName.getText();
+      const attrs = node.attributes;
+      if (/Button/i.test(tag) || tag === 'TouchableOpacity' || tag === 'Pressable') {
+        const title = jsxAttr(attrs, ['title', 'label', 'accessibilityLabel']);
+        const handler = jsxAttrHandlerName(attrs, ['onPress']);
+        if (title || handler) out.buttons.push({ tag, title, handler, file: rel });
+      }
+      if (/TextInput|Input/.test(tag)) {
+        const placeholder = jsxAttr(attrs, ['placeholder']);
+        const onChange = jsxAttrHandlerName(attrs, ['onChangeText', 'onChange']);
+        out.textInputs.push({ tag, placeholder, onChange, file: rel });
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  // Finds the object literal returned by the store factory ((set) => ({...}))
+  // possibly wrapped in persist()/devtools().
+  function findStoreObject(callNode) {
+    let found = null;
+    function dig(n, depth) {
+      if (found || depth > 8) return;
+      if (ts.isArrowFunction(n)) {
+        let body = n.body;
+        if (ts.isParenthesizedExpression(body)) body = body.expression;
+        if (ts.isObjectLiteralExpression(body)) {
+          // Heuristic: the store object has at least one function property
+          const hasFn = body.properties.some(
+            (p) => ts.isPropertyAssignment(p) &&
+              (ts.isArrowFunction(p.initializer) || ts.isFunctionExpression(p.initializer)),
+          );
+          if (hasFn) { found = body; return; }
+        }
+      }
+      ts.forEachChild(n, (c) => dig(c, depth + 1));
+    }
+    dig(callNode, 0);
+    return found;
+  }
+
+  visit(sf);
+  return out;
+}
+
+module.exports = { extractFromFile };

package/src/collect.js

@@ -0,0 +1,115 @@
+/**
+ * Source collector for the AI-first engine.
+ *
+ * Cheap, rule-based file selection — NOT analysis. It cannot "fail to zero":
+ * every code file is included unless it is objectively irrelevant (deps,
+ * native projects, assets, tests, build configs). When the app exceeds the
+ * input budget, files are prioritized by tier (screens/state/services first,
+ * generic UI last) and the omitted ones are reported so the model can declare
+ * what it did not see.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Per-platform collection profile: which source extensions are code, and which
+ * directories to skip. Native (Phase 1) reuses the SAME budget + tiering + AI
+ * pipeline as web/mobile — only the file selection differs by language.
+ */
+const PROFILES = {
+  web: {
+    exts: ['.ts', '.tsx', '.js', '.jsx', '.vue', '.svelte'],
+    skipDirs: ['node_modules', 'assets', '.git', 'dist', 'build', '.expo', 'android', 'ios', 'coverage', '.next', 'web-build'],
+  },
+  mobile: {
+    exts: ['.ts', '.tsx', '.js', '.jsx'],
+    skipDirs: ['node_modules', 'assets', '.git', 'dist', 'build', '.expo', 'android', 'ios', 'coverage', '.next', 'web-build'],
+  },
+  // Flutter: analyze lib/ (Dart); skip the native host wrappers + build output.
+  flutter: {
+    exts: ['.dart'],
+    skipDirs: ['.git', '.dart_tool', 'build', 'android', 'ios', 'web', 'linux', 'macos', 'windows', 'test', 'integration_test'],
+  },
+  // iOS: analyze Swift sources; skip SwiftPM/Xcode build output.
+  ios: {
+    exts: ['.swift'],
+    skipDirs: ['.git', '.build', 'build', 'DerivedData', 'Pods', 'Carthage', 'Tests'],
+  },
+  // Android: analyze Kotlin sources; skip Gradle build output.
+  android: {
+    exts: ['.kt'],
+    skipDirs: ['.git', '.gradle', 'build', '.idea'],
+  },
+};
+
+const SKIP_FILES = /\.(d\.ts|test\.|spec\.)|babel\.config|metro\.config|tailwind\.config|postcss\.config|jest\.config|eslint/;
+const SKIP_NATIVE_FILES = /\.(g\.dart|freezed\.dart|gr\.dart|mocks\.dart)$|_test\.(dart|kt|swift)$|Test\.kt$|Tests\.swift$/;
+
+/** Rough chars→tokens for budgeting (code averages ~3.6 chars/token). */
+const CHARS_PER_TOKEN = 3.6;
+
+/** Lower tier = higher priority when the budget forces choices. Generalized so
+ *  it ranks screens/state/services first across web, RN AND native naming. */
+function tierFor(rel) {
+  const p = rel.replace(/\\/g, '/');
+  if (/^(src\/)?app\//.test(p)) return 0; // expo-router / Next screens
+  if (/(^|\/)(screens?|pages?|views?|routes?|activities|fragments)\//i.test(p)) return 0;
+  if (/(screen|page|view|activity|fragment)\.(dart|kt|swift)$/i.test(p)) return 0;
+  if (/(^|\/)(state|store|stores|context|contexts|redux|providers?|blocs?|cubits?|viewmodels?)\//i.test(p)) return 1;
+  if (/(viewmodel|notifier|bloc|cubit|store|controller)\.(dart|kt|swift)$/i.test(p)) return 1;
+  if (/(^|\/)(services?|api|db|data|domain|agent|handlers?|actions?|lib|utils|repositories|repository|usecases?)\//i.test(p)) return 1;
+  if (/(^|\/)(hooks)\//.test(p)) return 2;
+  return 3; // generic components / ui
+}
+
+function collectFiles(appRoot, { maxInputTokens = 150_000, platform = 'mobile' } = {}) {
+  const profile = PROFILES[platform] || PROFILES.mobile;
+  const codeExt = new Set(profile.exts);
+  const skipDirs = new Set(profile.skipDirs);
+  const isNative = platform === 'flutter' || platform === 'ios' || platform === 'android';
+
+  const files = [];
+  const walk = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (!skipDirs.has(entry.name)) walk(path.join(dir, entry.name));
+        continue;
+      }
+      const full = path.join(dir, entry.name);
+      const rel = path.relative(appRoot, full);
+      if (!codeExt.has(path.extname(entry.name))) continue;
+      if (SKIP_FILES.test(rel)) continue;
+      if (isNative && SKIP_NATIVE_FILES.test(rel)) continue;
+      const content = fs.readFileSync(full, 'utf8');
+      files.push({ rel, content, tier: tierFor(rel), chars: content.length });
+    }
+  };
+  walk(appRoot);
+
+  // Stable order: tier, then path (deterministic prompts → reproducible runs).
+  files.sort((a, b) => a.tier - b.tier || a.rel.localeCompare(b.rel));
+
+  const budgetChars = maxInputTokens * CHARS_PER_TOKEN;
+  const included = [];
+  const omitted = [];
+  let used = 0;
+  for (const f of files) {
+    if (used + f.chars <= budgetChars) {
+      included.push(f);
+      used += f.chars;
+    } else {
+      omitted.push({ rel: f.rel, chars: f.chars, tier: f.tier });
+    }
+  }
+
+  return {
+    included,
+    omitted,
+    totalChars: used,
+    estimatedTokens: Math.round(used / CHARS_PER_TOKEN),
+  };
+}
+
+module.exports = { collectFiles };

package/src/graph.js

@@ -0,0 +1,160 @@
+/**
+ * Layer 2 — dependency graph and state mapping.
+ *
+ * - Resolves imports between project files (including tsconfig-style '@/'
+ *   aliases) to know which modules each screen pulls in (transitively).
+ * - Maps stores (Zustand) to the screens that consume them.
+ * - Builds, per screen, the consolidated action surface: own handlers +
+ *   store actions reachable from it, plus the evidence (alerts, buttons,
+ *   nav calls) needed downstream.
+ *
+ * Everything here is still provenance "static".
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { extractFromFile } = require('./ast');
+
+const EXTS = ['.tsx', '.ts', '.jsx', '.js'];
+
+function resolveImport(fromFile, spec, appRoot, srcRoot) {
+  let base = null;
+  if (spec.startsWith('.')) base = path.resolve(path.dirname(fromFile), spec);
+  else if (spec.startsWith('@/')) base = path.join(srcRoot, spec.slice(2));
+  else return null; // node_modules — out of scope
+  for (const ext of ['', ...EXTS]) {
+    const p = base + ext;
+    if (fs.existsSync(p) && fs.statSync(p).isFile()) return p;
+  }
+  for (const ext of EXTS) {
+    const p = path.join(base, 'index' + ext);
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+function findSrcRoot(appRoot) {
+  const src = path.join(appRoot, 'src');
+  return fs.existsSync(src) ? src : appRoot;
+}
+
+/** Parses every project source file once; builds extraction map + import graph. */
+function buildGraph(appRoot) {
+  const srcRoot = findSrcRoot(appRoot);
+  const files = [];
+  (function walk(dir) {
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (e.name === 'node_modules' || e.name.startsWith('.')) continue;
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) walk(full);
+      else if (EXTS.includes(path.extname(e.name))) files.push(full);
+    }
+  })(srcRoot);
+
+  const extracted = new Map(); // absPath -> extraction
+  const edges = new Map(); // absPath -> Set(absPath)
+
+  for (const f of files) {
+    let ex;
+    try {
+      ex = extractFromFile(f, appRoot);
+    } catch (err) {
+      ex = { file: path.relative(appRoot, f), parseError: String(err), handlers: [], navCalls: [], alerts: [], storeActions: [], storeStateKeys: [], buttons: [], textInputs: [], imports: [], linkingCalls: [] };
+    }
+    extracted.set(f, ex);
+    const deps = new Set();
+    for (const imp of ex.imports || []) {
+      const resolved = resolveImport(f, imp.from, appRoot, srcRoot);
+      if (resolved) deps.add(resolved);
+    }
+    edges.set(f, deps);
+  }
+
+  return { files, extracted, edges, srcRoot };
+}
+
+/** Transitive dependency closure of a file (bounded). */
+function closure(file, edges, maxDepth = 4) {
+  const seen = new Set([file]);
+  let frontier = [file];
+  for (let d = 0; d < maxDepth; d++) {
+    const next = [];
+    for (const f of frontier) {
+      for (const dep of edges.get(f) || []) {
+        if (!seen.has(dep)) {
+          seen.add(dep);
+          next.push(dep);
+        }
+      }
+    }
+    frontier = next;
+  }
+  return seen;
+}
+
+/**
+ * For each screen (route file), aggregates the action surface visible from it.
+ */
+function mapScreens(routes, graph) {
+  const { extracted, edges } = graph;
+
+  // global store registry: file -> {storeName, actions, stateKeys}
+  const stores = [];
+  for (const [f, ex] of extracted) {
+    if (ex.storeActions && ex.storeActions.length > 0) {
+      stores.push({
+        file: ex.file,
+        absFile: f,
+        storeName: ex.storeName || path.basename(f).replace(/\..+$/, ''),
+        actions: ex.storeActions.map((a) => a.name),
+        stateKeys: ex.storeStateKeys,
+      });
+    }
+  }
+
+  const screens = routes.map((route) => {
+    const ex = extracted.get(route.filePath) || {};
+    const deps = closure(route.filePath, edges);
+
+    const usedStores = stores.filter((s) => deps.has(s.absFile));
+    const depHandlers = [];
+    const depAlerts = [];
+    const depButtons = [];
+    const depNavCalls = [];
+    const depLinking = [];
+    const depTextInputs = [];
+    for (const d of deps) {
+      if (d === route.filePath) continue;
+      const dex = extracted.get(d);
+      if (!dex) continue;
+      depHandlers.push(...(dex.handlers || []));
+      depAlerts.push(...(dex.alerts || []));
+      depButtons.push(...(dex.buttons || []));
+      depNavCalls.push(...(dex.navCalls || []));
+      depLinking.push(...(dex.linkingCalls || []));
+      depTextInputs.push(...(dex.textInputs || []));
+    }
+
+    return {
+      route,
+      ownHandlers: ex.handlers || [],
+      ownAlerts: ex.alerts || [],
+      ownButtons: ex.buttons || [],
+      ownNavCalls: ex.navCalls || [],
+      ownTextInputs: (ex.textInputs || []).concat(depTextInputs),
+      ownLinking: ex.linkingCalls || [],
+      depHandlers,
+      depAlerts,
+      depButtons,
+      depNavCalls,
+      depLinking,
+      usedStores: usedStores.map((s) => ({ storeName: s.storeName, file: s.file, actions: s.actions })),
+      defaultExportName: ex.defaultExportName || null,
+    };
+  });
+
+  return { screens, stores };
+}
+
+module.exports = { buildGraph, mapScreens };