popilot 0.6.0 → 0.7.0

package/bin/cli.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { resolve, basename } from 'node:path';
+import { readFileSync, existsSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { copyScaffold, appendToFile, detectExisting } from '../lib/scaffold.mjs';
 import { runSetupWizard } from '../lib/setup-wizard.mjs';
@@ -15,6 +16,8 @@ const USAGE = `
     init [dir]      Scaffold + interactive setup + hydration (default)
     hydrate [dir]   Sync latest scaffold templates + re-hydrate from project.yaml
     doctor [dir]    Check installation health
+    deploy [dir]    Deploy pm-api to Cloudflare Workers (Tier 2)
+    migrate [dir]   Run SQL schema migrations on pm-api database (Tier 2)
     help            Show this help
 
   Options:
@@ -28,10 +31,12 @@ const USAGE = `
     npx popilot hydrate
     npx popilot hydrate --force
     npx popilot doctor
+    npx popilot deploy
+    npx popilot migrate
     npx popilot my-project          # same as: popilot init my-project
 `;
 
-const SUBCOMMANDS = new Set(['init', 'hydrate', 'doctor', 'help']);
+const SUBCOMMANDS = new Set(['init', 'hydrate', 'doctor', 'deploy', 'migrate', 'help']);
 
 async function main() {
   const args = process.argv.slice(2);
@@ -71,6 +76,12 @@ async function main() {
     case 'doctor':
       await cmdDoctor(targetDir, { skipSpecSite, platform });
       break;
+    case 'deploy':
+      await cmdDeploy(targetDir);
+      break;
+    case 'migrate':
+      await cmdMigrate(targetDir);
+      break;
   }
 }
 
@@ -133,7 +144,34 @@ async function cmdInit(targetDir, { skipSpecSite, force, platform }) {
     console.log(`     ${f} ✅ (domain)`);
   }
 
-  // 4. Install spec-site dependencies
+  // 4a. Install pm-api dependencies (Tier 2)
+  const pmApiDir = resolve(targetDir, 'pm-api');
+  try {
+    const { access: fsAccess } = await import('node:fs/promises');
+    await fsAccess(resolve(pmApiDir, 'package.json'));
+    console.log();
+    console.log('  📦 Installing pm-api dependencies...');
+    try {
+      execSync('npm install', { cwd: pmApiDir, stdio: 'pipe' });
+      console.log('     ✅ Done');
+    } catch {
+      console.log('     ⚠️  npm install failed. Run manually: cd pm-api && npm install');
+    }
+
+    // Also install mcp-pm
+    const mcpPmDir = resolve(targetDir, 'mcp-pm');
+    console.log('  📦 Installing mcp-pm dependencies...');
+    try {
+      execSync('npm install', { cwd: mcpPmDir, stdio: 'pipe' });
+      console.log('     ✅ Done');
+    } catch {
+      console.log('     ⚠️  npm install failed. Run manually: cd mcp-pm && npm install');
+    }
+  } catch {
+    // pm-api not present (Tier 0/1) — skip
+  }
+
+  // 4b. Install spec-site dependencies
   if (!skipSpecSite) {
     const specSiteDir = resolve(targetDir, 'spec-site');
     console.log();
@@ -241,6 +279,170 @@ async function cmdDoctor(targetDir, { skipSpecSite, platform }) {
   process.exit(failed.length > 0 ? 1 : 0);
 }
 
+// ── deploy ───────────────────────────────────────────────
+
+async function cmdDeploy(targetDir) {
+  console.log();
+  console.log('  🚀 Popilot — Deploy pm-api');
+  console.log('  ══════════════════════════════════════');
+  console.log();
+
+  const pmApiDir = resolve(targetDir, 'pm-api');
+
+  if (!existsSync(pmApiDir)) {
+    console.log('  ❌ pm-api directory not found.');
+    console.log(`     Expected at: ${pmApiDir}`);
+    console.log('     Deploy is only available for Tier 2 (interactive spec-site with backend).');
+    console.log();
+    process.exit(1);
+  }
+
+  const wranglerToml = resolve(pmApiDir, 'wrangler.toml');
+  if (!existsSync(wranglerToml)) {
+    console.log('  ❌ wrangler.toml not found in pm-api.');
+    console.log('     Found wrangler.toml.hbs — run `popilot hydrate` first to generate wrangler.toml.');
+    console.log();
+    process.exit(1);
+  }
+
+  console.log(`  📂 Deploying from: ${pmApiDir}`);
+  console.log();
+
+  try {
+    execSync('npx wrangler deploy', { cwd: pmApiDir, stdio: 'inherit' });
+    console.log();
+    console.log('  ✅ pm-api deployed successfully.');
+    console.log();
+  } catch {
+    console.log();
+    console.log('  ❌ Deploy failed. Check the wrangler output above for details.');
+    console.log();
+    process.exit(1);
+  }
+}
+
+// ── migrate ──────────────────────────────────────────────
+
+async function cmdMigrate(targetDir) {
+  console.log();
+  console.log('  🗄️  Popilot — Run SQL Migrations');
+  console.log('  ══════════════════════════════════════');
+  console.log();
+
+  const pmApiDir = resolve(targetDir, 'pm-api');
+
+  if (!existsSync(pmApiDir)) {
+    console.log('  ❌ pm-api directory not found.');
+    console.log(`     Expected at: ${pmApiDir}`);
+    console.log('     Migrate is only available for Tier 2 (interactive spec-site with backend).');
+    console.log();
+    process.exit(1);
+  }
+
+  const sqlDir = resolve(pmApiDir, 'sql');
+  if (!existsSync(sqlDir)) {
+    console.log('  ❌ pm-api/sql/ directory not found.');
+    console.log('     No migration files available.');
+    console.log();
+    process.exit(1);
+  }
+
+  // Read D1 database name from wrangler.toml
+  const wranglerToml = resolve(pmApiDir, 'wrangler.toml');
+  if (!existsSync(wranglerToml)) {
+    console.log('  ❌ wrangler.toml not found in pm-api.');
+    console.log('     Run `popilot hydrate` first to generate wrangler.toml.');
+    console.log();
+    process.exit(1);
+  }
+
+  const wranglerContent = readFileSync(wranglerToml, 'utf-8');
+  const dbNameMatch = wranglerContent.match(/database_name\s*=\s*"([^"]+)"/);
+  const dbName = dbNameMatch ? dbNameMatch[1] : null;
+
+  if (!dbName) {
+    console.log('  ❌ Could not find D1 database_name in wrangler.toml.');
+    console.log('     Ensure [[d1_databases]] is configured with a database_name.');
+    console.log();
+    process.exit(1);
+  }
+
+  console.log(`  📂 SQL directory: ${sqlDir}`);
+  console.log(`  🗃️  D1 database:  ${dbName}`);
+  console.log();
+
+  // Read project.yaml to determine enabled features
+  const projectYaml = resolve(targetDir, '.context', 'project.yaml');
+  let features = { rewards: false, meetings: true, docs: true };
+
+  if (existsSync(projectYaml)) {
+    try {
+      const yamlContent = readFileSync(projectYaml, 'utf-8');
+      // Parse feature flags from YAML (simple regex — avoids adding a YAML dep)
+      const rewardsMatch = yamlContent.match(/features:[\s\S]*?rewards:\s*(true|false)/);
+      const meetingsMatch = yamlContent.match(/features:[\s\S]*?meetings:\s*(true|false)/);
+      const docsMatch = yamlContent.match(/features:[\s\S]*?docs:\s*(true|false)/);
+
+      if (rewardsMatch) features.rewards = rewardsMatch[1] === 'true';
+      if (meetingsMatch) features.meetings = meetingsMatch[1] === 'true';
+      if (docsMatch) features.docs = docsMatch[1] === 'true';
+    } catch {
+      console.log('  ⚠️  Could not read project.yaml — using default feature flags.');
+    }
+  }
+
+  // Build list of schemas to apply
+  const schemas = [{ file: 'schema-core.sql', label: 'core (always)' }];
+
+  if (features.rewards) {
+    schemas.push({ file: 'schema-rewards.sql', label: 'rewards' });
+  }
+  if (features.meetings) {
+    schemas.push({ file: 'schema-meetings.sql', label: 'meetings' });
+  }
+  if (features.docs) {
+    schemas.push({ file: 'schema-docs.sql', label: 'docs' });
+  }
+
+  console.log('  📋 Schemas to apply:');
+  for (const s of schemas) {
+    console.log(`     - ${s.file} (${s.label})`);
+  }
+  console.log();
+
+  // Execute each schema
+  let applied = 0;
+  let failed = 0;
+
+  for (const s of schemas) {
+    const sqlFile = resolve(sqlDir, s.file);
+    if (!existsSync(sqlFile)) {
+      console.log(`  ⚠️  ${s.file} not found — skipped`);
+      continue;
+    }
+
+    try {
+      execSync(
+        `npx wrangler d1 execute ${dbName} --file=sql/${s.file} --remote`,
+        { cwd: pmApiDir, stdio: 'pipe' }
+      );
+      console.log(`  ✅ ${s.file} applied`);
+      applied++;
+    } catch (err) {
+      console.log(`  ❌ ${s.file} failed: ${err.message}`);
+      failed++;
+    }
+  }
+
+  console.log();
+  if (failed === 0) {
+    console.log(`  ✅ Migration complete — ${applied} schema(s) applied.`);
+  } else {
+    console.log(`  ⚠️  Migration finished with errors — ${applied} applied, ${failed} failed.`);
+  }
+  console.log();
+}
+
 // ── Run ─────────────────────────────────────────────────
 
 main().catch(err => {

package/lib/doctor.mjs

@@ -97,7 +97,44 @@ export async function runDoctor(targetDir, opts = {}) {
     }, passed, failed, warnings);
   }
 
-  // 7. .gitignore entries
+  // 7. Tier 2 checks (pm-api + mcp-pm)
+  const pmApiDir = join(targetDir, 'pm-api');
+  let hasPmApi = false;
+  try { await access(pmApiDir); hasPmApi = true; } catch {}
+
+  if (hasPmApi) {
+    await check('pm-api/package.json exists', async () => {
+      await access(join(pmApiDir, 'package.json'));
+    }, passed, failed);
+
+    await check('pm-api/wrangler.toml exists (hydrated)', async () => {
+      await access(join(pmApiDir, 'wrangler.toml'));
+      try {
+        await access(join(pmApiDir, 'wrangler.toml.hbs'));
+        throw new Error('wrangler.toml.hbs still exists — hydration incomplete');
+      } catch (e) {
+        if (e.message.includes('hydration')) throw e;
+      }
+    }, passed, failed);
+
+    await check('pm-api/sql/schema-core.sql exists', async () => {
+      await access(join(pmApiDir, 'sql', 'schema-core.sql'));
+    }, passed, failed);
+
+    await check('mcp-pm/package.json exists', async () => {
+      await access(join(targetDir, 'mcp-pm', 'package.json'));
+    }, passed, failed);
+
+    await check('pm-api/node_modules exists', async () => {
+      await access(join(pmApiDir, 'node_modules'));
+    }, passed, failed, warnings);
+
+    await check('mcp-pm/node_modules exists', async () => {
+      await access(join(targetDir, 'mcp-pm', 'node_modules'));
+    }, passed, failed, warnings);
+  }
+
+  // 8. .gitignore entries
   await check('.gitignore includes user-context.yaml', async () => {
     const content = await readFile(join(targetDir, '.gitignore'), 'utf-8');
     if (!content.includes('user-context.yaml')) {

package/lib/hydrate.mjs

@@ -145,6 +145,21 @@ export async function hydrate(targetDir, opts = {}) {
     if (result) hydrated.push(relative(targetDir, result));
   }
 
+  // pm-api wrangler.toml.hbs hydration (Tier 2)
+  const pmApiWranglerPath = join(targetDir, 'pm-api', 'wrangler.toml.hbs');
+  try {
+    const wranglerResult = await hydrateFile(pmApiWranglerPath, {
+      ctx,
+      registry,
+      enabledProviders,
+      targetType: 'system',
+      targetName: 'wrangler.toml',
+    });
+    if (wranglerResult) hydrated.push(relative(targetDir, wranglerResult));
+  } catch {
+    // pm-api not present (Tier 0/1) — skip
+  }
+
   // Domain command generation
   const domains = projectYaml.operations?.domains || [];
   const domainResults = [];

package/lib/scaffold.mjs

@@ -57,6 +57,11 @@ async function walk(srcDir, destDir, targetDir, options, copied, overwritten, sk
       continue;
     }
 
+    // Skip pm-api and mcp-pm if not Tier 2
+    if (options.skipPmApi && (relPath.startsWith('pm-api') || relPath.startsWith('mcp-pm'))) {
+      continue;
+    }
+
     // Skip manifest.yaml (adapter metadata, not a project file)
     if (entry.name === 'manifest.yaml') {
       continue;

package/lib/setup-wizard.mjs

@@ -130,6 +130,38 @@ export async function runSetupWizard(targetDir, opts = {}) {
       specSiteConfig.mode = specSiteTier;
     }
 
+    // ── Phase 6: Backend Setup (Tier 2) ──────────────
+    let pmApiConfig = { enabled: false, url: '', features: { rewards: false, meetings: true, docs: true, initiatives: true }, blockchain: { enabled: false, provider: '', token_name: '', contract_address: '', token_decimals: 8 } };
+
+    if (specSiteTier === 'interactive') {
+      console.log();
+      console.log('  ──────────────────────────────────────');
+      console.log('  🖥️  Backend Setup (Tier 2)');
+      console.log('  ──────────────────────────────────────');
+      console.log();
+
+      pmApiConfig.enabled = true;
+      pmApiConfig.url = await ask(rl, 'PM API URL (leave empty to configure later)');
+
+      console.log();
+      console.log('  Feature modules:');
+      pmApiConfig.features.rewards = await confirm(rl, 'Enable rewards/penalties module?', false);
+      pmApiConfig.features.meetings = await confirm(rl, 'Enable meetings module?', true);
+      pmApiConfig.features.docs = await confirm(rl, 'Enable docs module?', true);
+      pmApiConfig.features.initiatives = await confirm(rl, 'Enable initiatives module?', true);
+
+      console.log();
+      const enableBlockchain = await confirm(rl, 'Enable blockchain integration?', false);
+      if (enableBlockchain) {
+        pmApiConfig.blockchain.enabled = true;
+        pmApiConfig.blockchain.provider = await select(rl, 'Blockchain provider:', [
+          { label: 'TRON', value: 'tron' },
+        ], 0);
+        pmApiConfig.blockchain.token_name = await ask(rl, 'Token name');
+        pmApiConfig.blockchain.contract_address = await ask(rl, 'Contract address');
+      }
+    }
+
     console.log();
 
     // ── Phase 5: Integrations ────────────────────────
@@ -141,7 +173,7 @@ export async function runSetupWizard(targetDir, opts = {}) {
     // project.yaml
     const projectYaml = buildProjectYaml({
       projectName, tagline, projectType,
-      domains, devScope, integrations, specSiteConfig,
+      domains, devScope, integrations, specSiteConfig, pmApiConfig,
       platform: opts.platform || null,
       industryPreset,
     });
@@ -356,7 +388,7 @@ export const ALL_INTEGRATION_PROVIDERS = [
   'sqlite_lambda',
 ];
 
-function buildProjectYaml({ projectName, tagline, projectType, domains, devScope, integrations, specSiteConfig, platform, industryPreset }) {
+function buildProjectYaml({ projectName, tagline, projectType, domains, devScope, integrations, specSiteConfig, pmApiConfig, platform, industryPreset }) {
   // Build the full integrations block with all known providers
   const integrationsBlock = {};
 
@@ -418,6 +450,7 @@ function buildProjectYaml({ projectName, tagline, projectType, domains, devScope
         deploy_url: '',
         backend: specSiteConfig.backend,
       },
+      pm_api: pmApiConfig || { enabled: false },
     },
     _meta: {
       created_at: new Date().toISOString(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "popilot",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Multi-agent PO/PM system scaffold for Claude Code",
   "type": "module",
   "bin": {

package/scaffold/.context/project.yaml.example

@@ -103,8 +103,27 @@ operations:
     service_repo: ""           # {{dev_scope.service_repo}}
 
   spec_site:
+    enabled: false
+    mode: "static"             # static | interactive
     title: ""                  # {{spec_site.title}}
     deploy_url: ""             # {{spec_site.deploy_url}}
+    backend: ""
+
+  # PM API Backend (Tier 2 — Full interactive mode)
+  pm_api:
+    enabled: false
+    url: ""                    # PM API URL (e.g. https://pm-api.your-domain.workers.dev)
+    features:
+      rewards: false
+      meetings: true
+      docs: true
+      initiatives: true
+    blockchain:
+      enabled: false
+      provider: ""             # tron | (future: eth, solana)
+      token_name: ""
+      contract_address: ""
+      token_decimals: 8
 
 # ============================================================
 # Metadata

package/scaffold/mcp-pm/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "mcp-pm",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0"
+  }
+}

package/scaffold/mcp-pm/src/api-client.ts

@@ -0,0 +1,69 @@
+// PM API HTTP client
+// All MCP tools use this client to communicate with the PM API server.
+// Required env vars: PM_API_URL, PM_TOKEN
+
+const PM_API_URL = process.env.PM_API_URL ?? ''
+const PM_TOKEN = process.env.PM_TOKEN ?? ''
+
+interface ApiResult<T> {
+  data: T | null
+  error?: string
+}
+
+async function request<T>(method: string, path: string, body?: unknown): Promise<ApiResult<T>> {
+  if (!PM_API_URL || !PM_TOKEN) {
+    return { data: null, error: 'Missing PM_API_URL or PM_TOKEN' }
+  }
+
+  try {
+    const resp = await fetch(`${PM_API_URL}${path}`, {
+      method,
+      headers: {
+        Authorization: `Bearer ${PM_TOKEN}`,
+        'Content-Type': 'application/json',
+      },
+      body: body ? JSON.stringify(body) : undefined,
+      signal: AbortSignal.timeout(15000),
+    })
+
+    const data = await resp.json()
+
+    if (!resp.ok) {
+      return { data: null, error: data.error ?? `HTTP ${resp.status}` }
+    }
+
+    return { data: data as T }
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : 'Unknown error'
+    return { data: null, error: message }
+  }
+}
+
+export function apiGet<T>(path: string, params?: Record<string, string>): Promise<ApiResult<T>> {
+  let url = path
+  if (params) {
+    const search = new URLSearchParams()
+    for (const [k, v] of Object.entries(params)) {
+      if (v) search.set(k, v)
+    }
+    const qs = search.toString()
+    if (qs) url += '?' + qs
+  }
+  return request<T>('GET', url)
+}
+
+export function apiPost<T>(path: string, body: unknown): Promise<ApiResult<T>> {
+  return request<T>('POST', path, body)
+}
+
+export function apiPatch<T>(path: string, body: unknown): Promise<ApiResult<T>> {
+  return request<T>('PATCH', path, body)
+}
+
+export function apiPut<T>(path: string, body: unknown): Promise<ApiResult<T>> {
+  return request<T>('PUT', path, body)
+}
+
+export function apiDelete<T>(path: string): Promise<ApiResult<T>> {
+  return request<T>('DELETE', path)
+}