nativeapptemplate-agent 0.1.0

package/dist/validation/visual-judge.js

@@ -0,0 +1,89 @@
+import { setTimeout as sleep } from "node:timers/promises";
+import { runLayer3 } from "./layer3.js";
+import { captureScreenshot } from "./capture.js";
+import { installAndLaunch } from "./launch.js";
+const DEFAULT_RENDER_WAIT_MS = 3_000;
+// End-to-end Stage 1 visual judge for one platform:
+//   1. install + launch the built app on the booted sim/emulator
+//   2. wait for render
+//   3. capture the home screen as PNG
+//   4. send PNG + rubric to the Opus 4.7 vision judge (median-of-3 per criterion)
+//
+// Fail-fast: any step's failure short-circuits and surfaces in the result.
+// Caller is responsible for: building the artifact (Layer 2 build mode),
+// resolving artifactPath / bundleId / packageName from the slug, and ensuring
+// a sim/emulator is booted.
+export async function runVisualJudge(input) {
+    const launch = await installAndLaunch(input.platform === "ios"
+        ? {
+            platform: "ios",
+            appPath: input.artifactPath,
+            bundleId: requireField(input.bundleId, "bundleId is required for platform=ios"),
+        }
+        : {
+            platform: "android",
+            apkPath: input.artifactPath,
+            packageName: requireField(input.packageName, "packageName is required for platform=android"),
+        });
+    if (!launch.ok) {
+        return {
+            ok: false,
+            launch,
+            error: `install/launch failed: ${launch.error ?? "unknown"}`,
+        };
+    }
+    await sleep(input.renderWaitMs ?? DEFAULT_RENDER_WAIT_MS);
+    const capture = await captureScreenshot({
+        platform: input.platform,
+        outPath: input.screenshotPath,
+    });
+    if (!capture.ok) {
+        return {
+            ok: false,
+            launch,
+            error: `screenshot capture failed: ${capture.error ?? "unknown"}`,
+        };
+    }
+    const layer3 = await runLayer3({
+        screenshotPath: capture.path,
+        rubric: input.rubric,
+        spec: input.spec,
+        ...(input.samplesPerCriterion !== undefined ? { samplesPerCriterion: input.samplesPerCriterion } : {}),
+        ...(input.model !== undefined ? { model: input.model } : {}),
+    });
+    return {
+        ok: layer3.pass,
+        launch,
+        screenshotPath: capture.path,
+        layer3,
+    };
+}
+// Default Stage 1 rubric — two Yes/No criteria covering substrate-leak
+// detection and basic render sanity. Phrased so pass=true is the desired
+// state on every criterion.
+//
+// Per docs/SPEC.md, Stage 1 captures the post-launch screen and is scoped
+// to "catch egregious rename failures" — substrate-leak detection plus
+// 'does anything render at all'. Domain-semantic matching (e.g. "does this
+// read as a clinic queue?") requires reaching the actual domain UI past
+// onboarding/login and lives in Stage 2 (mobile-mcp navigation), where
+// the agent can drive the app to a list/detail/form screen before
+// judging. Adding a domain-match criterion here would false-fail any
+// substrate that ships with onboarding-before-domain-UI — which is the
+// substrate's intentional design.
+export const DEFAULT_STAGE1_RUBRIC = [
+    {
+        id: "no-substrate-leak",
+        question: "Is the screen free of substrate-original tokens like 'Shop', 'Shopkeeper', 'ItemTag', 'NativeAppTemplate', or 'Number Tag'?",
+    },
+    {
+        id: "renders-cleanly",
+        question: "Does the screen render without an actual rendering failure — that is, no crash dialog, no broken-image-icon glyphs, no text overlapping other text, no content cut off the side of the screen? A welcome / launch / onboarding screen with decorative graphics counts as PASS as long as nothing is technically broken; do not judge whether the screen looks 'finished' or shows the app's domain content.",
+    },
+];
+function requireField(value, message) {
+    if (value === undefined)
+        throw new Error(message);
+    return value;
+}
+//# sourceMappingURL=visual-judge.js.map

package/dist/validation/visual-judge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visual-judge.js","sourceRoot":"","sources":["../../src/validation/visual-judge.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "nativeapptemplate-agent",
+  "version": "0.1.0",
+  "description": "A Claude Code agent that turns a natural-language SaaS spec into a working three-platform implementation (Rails API + SwiftUI iOS + Jetpack Compose Android).",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "nativeapptemplate-agent": "dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "scripts/ruby/",
+    "README.md",
+    "LICENSE",
+    "CLAUDE.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "directories": {
+    "doc": "docs"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "typecheck:tests": "tsc --noEmit -p tsconfig.test.json",
+    "test": "NATIVEAPPTEMPLATE_STUB_ALL=1 node --import tsx --test tests/smoke.test.ts",
+    "ci": "npm run build && npm run typecheck:tests && npm test",
+    "cost": "bash scripts/cost.sh",
+    "prepublishOnly": "npm run ci"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nativeapptemplate/nativeapptemplate-agent.git"
+  },
+  "homepage": "https://github.com/nativeapptemplate/nativeapptemplate-agent#readme",
+  "bugs": {
+    "url": "https://github.com/nativeapptemplate/nativeapptemplate-agent/issues"
+  },
+  "keywords": [
+    "claude",
+    "agent",
+    "code-generation",
+    "saas",
+    "ios",
+    "android",
+    "rails",
+    "swift",
+    "kotlin",
+    "boilerplate",
+    "generator",
+    "anthropic",
+    "claude-agent-sdk",
+    "mcp"
+  ],
+  "author": "Daisuke Adachi",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.114",
+    "@anthropic-ai/sdk": "^0.90.0",
+    "yaml": "^2.8.4"
+  }
+}

package/scripts/ruby/rename.rb

@@ -0,0 +1,221 @@
+#!/usr/bin/env ruby
+#
+# Apply a rename plan to a Rails project tree.
+# Stdin:  { "renamePlan": [{"from":"Shop","to":"Clinic"}, ...], "root": "/abs/path" }
+# Stdout: { "files_scanned": N, "files_changed": N, "substitutions": N, "files_renamed": N }
+#
+# Rewrites file content AND renames files/directories for every
+# PascalCase / snake_case / plural variant of each rename pair.
+# Word-boundary matching via Regexp; crude-but-sufficient English
+# pluralization. Skips .git, node_modules, tmp/, log/, vendor/bundle/.
+
+require "json"
+
+input = JSON.parse($stdin.read)
+plan  = input.fetch("renamePlan")
+root  = input.fetch("root")
+
+stats = { files_scanned: 0, files_changed: 0, substitutions: 0, files_renamed: 0 }
+
+SKIP_DIR_SEGMENTS = %w[.git node_modules tmp log DerivedData Pods Carthage xcuserdata .build build .gradle .idea .kotlin captures].freeze
+SKIP_SUBPATHS     = %w[vendor/bundle].freeze
+TEXT_EXTS         = %w[
+  .rb .erb .yml .yaml .json .md .gemspec .rake .ru .txt .sample .example .conf
+  .html .css .scss .js .mjs .tt .lock
+  .swift .plist .strings .xcconfig .entitlements .pbxproj .xcworkspacedata .modulemap .xcscheme
+  .kt .kts .xml .gradle .pro .toml .properties .cfg
+  .proto
+].freeze
+TEXT_BASENAMES    = %w[
+  Gemfile Gemfile.lock Rakefile Procfile Procfile.dev
+  .gitignore .env.sample .ruby-version .node-version
+  config.ru Dockerfile
+  Podfile Podfile.lock Package.swift Cartfile Makefile
+  gradlew gradlew.bat gradle.properties local.properties
+  brakeman.ignore
+].freeze
+
+def pluralize(word)
+  if word.end_with?("y") && word.length > 1 && !%w[a e i o u].include?(word[-2])
+    word[0..-2] + "ies"
+  elsif word.end_with?("s", "sh", "ch", "x", "z")
+    word + "es"
+  else
+    word + "s"
+  end
+end
+
+def snake_case(pascal)
+  pascal.gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .downcase
+end
+
+def camel_case(pascal)
+  return pascal if pascal.empty?
+  pascal[0].downcase + pascal[1..]
+end
+
+def humanize_lower(pascal)
+  snake_case(pascal).tr("_", " ")
+end
+
+def humanize_title(pascal)
+  humanize_lower(pascal).split(" ").map(&:capitalize).join(" ")
+end
+
+def first_char_up(s)
+  s.empty? ? s : s[0].upcase + s[1..]
+end
+
+def build_patterns(from, to)
+  from_snake    = snake_case(from)
+  to_snake      = snake_case(to)
+  from_snake_pl = pluralize(from_snake)
+  to_snake_pl   = pluralize(to_snake)
+  from_pl       = pluralize(from)
+  to_pl         = pluralize(to)
+  from_flat     = from.downcase
+  to_flat       = to.downcase
+  from_flat_pl  = from_flat + "s"
+  to_flat_pl    = to_flat + "s"
+  from_camel    = camel_case(from)
+  to_camel      = camel_case(to)
+  from_camel_pl = pluralize(from_camel)
+  to_camel_pl   = pluralize(to_camel)
+  from_human_lo    = humanize_lower(from)
+  to_human_lo      = humanize_lower(to)
+  from_human_ti    = humanize_title(from)
+  to_human_ti      = humanize_title(to)
+  from_human_se    = first_char_up(from_human_lo)
+  to_human_se      = first_char_up(to_human_lo)
+  from_human_lo_pl = from_snake_pl.tr("_", " ")
+  to_human_lo_pl   = to_snake_pl.tr("_", " ")
+  from_human_ti_pl = from_human_lo_pl.split(" ").map(&:capitalize).join(" ")
+  to_human_ti_pl   = to_human_lo_pl.split(" ").map(&:capitalize).join(" ")
+  from_human_se_pl = first_char_up(from_human_lo_pl)
+  to_human_se_pl   = first_char_up(to_human_lo_pl)
+
+  # Ruby's \b treats `_` as a word char, so \bshop\b doesn't fire
+  # inside `shop_id` or `accounts_shopkeeper`. Hand-rolled boundaries:
+  #   - PascalCase token: preceded by non-letter OR lowercase letter
+  #     (PascalCase compound like `LoggedInShopkeeper`); followed by
+  #     non-letter OR uppercase (next PascalCase word).
+  #   - snake_case / lowercase token: preceded by non-letter;
+  #     followed by non-letter OR uppercase (camelCase compound
+  #     like `shopId`).
+  #
+  # Order matters: plural forms first so "Shops" isn't partially-
+  # matched as "Shop" + residual "s".
+  pascal_l = "(?:(?<![A-Za-z])|(?<=[a-z]))"
+  pascal_r = "(?:(?![A-Za-z])|(?=[A-Z]))"
+  snake_l  = "(?<![A-Za-z])"
+  snake_r  = "(?:(?![A-Za-z])|(?=[A-Z]))"
+
+  patterns = [
+    [/#{pascal_l}#{Regexp.escape(from_pl)}#{pascal_r}/,     to_pl],
+    [/#{pascal_l}#{Regexp.escape(from)}#{pascal_r}/,        to],
+    [/#{snake_l}#{Regexp.escape(from_snake_pl)}#{snake_r}/, to_snake_pl],
+    [/#{snake_l}#{Regexp.escape(from_snake)}#{snake_r}/,    to_snake],
+    # flat-lowercase (runs AFTER snake so single-word rename pairs
+    # where flat == snake can't win over snake's replacement; catches
+    # multi-word compounds collapsed in URLs / package names /
+    # email addresses, e.g. `nativeapptemplate.com`).
+    [/#{snake_l}#{Regexp.escape(from_flat_pl)}#{snake_r}/,  to_flat_pl],
+    [/#{snake_l}#{Regexp.escape(from_flat)}#{snake_r}/,     to_flat],
+    # camelCase — first char lowercased, rest PascalCase. Catches
+    # the common Kotlin/Swift field-accessor form like `itemTag`
+    # (from `ItemTag`) or `itemTagInfoFromNdefMessage`.
+    [/#{snake_l}#{Regexp.escape(from_camel_pl)}#{snake_r}/, to_camel_pl],
+    [/#{snake_l}#{Regexp.escape(from_camel)}#{snake_r}/,    to_camel],
+    [/#{snake_l}#{Regexp.escape(from_pl.upcase)}(?![A-Za-z])/, to_pl.upcase],
+    [/#{snake_l}#{Regexp.escape(from.upcase)}(?![A-Za-z])/,    to.upcase],
+  ]
+
+  # Humanized display forms — three case shapes per number:
+  #   lower    "item tag"  / "item tags"  (UI body text, prose)
+  #   title    "Item Tag"  / "Item Tags"  (headings, button labels)
+  #   sentence "Item tag"  / "Item tags"  (sentence start, error messages,
+  #                                        OpenAPI descriptions)
+  # Only meaningful when the PascalCase token is multi-word; for single
+  # words all three humanized forms collapse to the flat / Pascal forms
+  # already handled above. Plural patterns come first so "item tags"
+  # isn't partially matched as "item tag" + residual "s".
+  if from_human_lo.include?(" ")
+    boundary = "(?<![A-Za-z])"
+    boundary_r = "(?![A-Za-z])"
+    human_patterns = [
+      [/#{boundary}#{Regexp.escape(from_human_ti_pl)}#{boundary_r}/, to_human_ti_pl],
+      [/#{boundary}#{Regexp.escape(from_human_ti)}#{boundary_r}/,    to_human_ti],
+      [/#{boundary}#{Regexp.escape(from_human_se_pl)}#{boundary_r}/, to_human_se_pl],
+      [/#{boundary}#{Regexp.escape(from_human_se)}#{boundary_r}/,    to_human_se],
+      [/#{boundary}#{Regexp.escape(from_human_lo_pl)}#{boundary_r}/, to_human_lo_pl],
+      [/#{boundary}#{Regexp.escape(from_human_lo)}#{boundary_r}/,    to_human_lo],
+    ]
+    patterns = human_patterns + patterns
+  end
+
+  patterns
+end
+
+all_patterns = plan.flat_map { |p| build_patterns(p.fetch("from"), p.fetch("to")) }
+
+def skip?(path)
+  return true if SKIP_DIR_SEGMENTS.any? { |d| path.include?("/#{d}/") || path.end_with?("/#{d}") }
+  return true if SKIP_SUBPATHS.any? { |sp| path.include?("/#{sp}") }
+  false
+end
+
+def text_file?(path)
+  basename = File.basename(path)
+  return true if TEXT_BASENAMES.include?(basename)
+  return true if TEXT_EXTS.include?(File.extname(path))
+  false
+end
+
+# Pass 1 — rewrite file contents.
+Dir.glob("#{root}/**/*", File::FNM_DOTMATCH).each do |path|
+  next unless File.file?(path)
+  next if skip?(path)
+  next unless text_file?(path)
+
+  stats[:files_scanned] += 1
+
+  begin
+    content = File.read(path, encoding: "UTF-8")
+  rescue StandardError
+    next
+  end
+
+  original = content.dup
+  local_subst = 0
+  all_patterns.each do |regex, replacement|
+    content = content.gsub(regex) { local_subst += 1; replacement }
+  end
+
+  next if content == original
+
+  File.write(path, content)
+  stats[:files_changed] += 1
+  stats[:substitutions] += local_subst
+end
+
+# Pass 2 — rename paths. Deepest-first so renaming a parent directory
+# doesn't invalidate paths we haven't visited yet.
+Dir.glob("#{root}/**/*", File::FNM_DOTMATCH).sort_by { |p| -p.length }.each do |path|
+  next if skip?(path)
+  next unless File.exist?(path)
+
+  old_name = File.basename(path)
+  new_name = old_name.dup
+  all_patterns.each { |regex, replacement| new_name = new_name.gsub(regex, replacement) }
+  next if new_name == old_name
+
+  new_path = File.join(File.dirname(path), new_name)
+  next if File.exist?(new_path)
+
+  File.rename(path, new_path)
+  stats[:files_renamed] += 1
+end
+
+puts JSON.generate(stats)