promptlineapp 1.6.0 → 1.8.0

package/bin/cli.js

@@ -4,14 +4,75 @@
  * create-promptline-app CLI
  *
  * Usage:
- *   npx create-promptline-app my-app
- *   npx create-promptline-app my-app --preset saas
+ *   npx promptlineapp my-app           - Create new app from scratch
+ *   npx promptlineapp get <git-url>    - Get existing app from Git
  */
 
 const fs = require('fs');
 const path = require('path');
 const readline = require('readline');
 
+// Simple YAML parser for extracting ai_bindings
+// Only parses what we need - not a full YAML parser
+function parseBindingsFromYaml(yamlContent) {
+  const bindings = [];
+  const lines = yamlContent.split('\n');
+  let inAiBindings = false;
+  let currentIndent = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Skip empty lines and comments
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    // Detect ai_bindings: section
+    if (trimmed === 'ai_bindings:') {
+      inAiBindings = true;
+      currentIndent = line.search(/\S/);
+      continue;
+    }
+
+    // If we're in ai_bindings section
+    if (inAiBindings) {
+      const lineIndent = line.search(/\S/);
+
+      // If we hit something at same or lower indent, we're out of ai_bindings
+      if (lineIndent <= currentIndent && trimmed && !trimmed.startsWith('#')) {
+        inAiBindings = false;
+        continue;
+      }
+
+      // Check if this is a binding name (indent = currentIndent + 2, ends with :)
+      if (lineIndent === currentIndent + 2 && trimmed.endsWith(':') && !trimmed.includes(' ')) {
+        const bindingName = trimmed.slice(0, -1);
+        // Look ahead for type and description
+        let type = 'prompt';
+        let description = '';
+
+        for (let j = i + 1; j < Math.min(i + 10, lines.length); j++) {
+          const nextLine = lines[j].trim();
+          if (nextLine.startsWith('type:')) {
+            type = nextLine.split(':')[1].trim().replace(/["']/g, '');
+          }
+          if (nextLine.startsWith('description:')) {
+            description = nextLine.split(':').slice(1).join(':').trim().replace(/["']/g, '');
+          }
+          // Stop if we hit another binding
+          if (lines[j].search(/\S/) === currentIndent + 2 && nextLine.endsWith(':') && !nextLine.includes(' ')) {
+            break;
+          }
+        }
+
+        bindings.push({ name: bindingName, type, description });
+      }
+    }
+  }
+
+  return bindings;
+}
+
 // ANSI colors
 const colors = {
   reset: '\x1b[0m',
@@ -2098,6 +2159,547 @@ function parseArgs() {
   return options;
 }
 
+// Templates for injected dev files
+const devTemplates = {
+  // Hybrid SDK that calls real APIs when configured
+  sdkHybrid: (bindings) => `/**
+ * PromptLine SDK - Hybrid Mode
+ * Calls real PromptLine APIs when endpoints are configured via /_dev
+ *
+ * Auto-generated by: npx promptlineapp get
+ */
+import React, { createContext, useContext, useState, useMemo } from 'react'
+
+const STORAGE_KEY = 'promptline_endpoints_config'
+const API_KEY_STORAGE = 'promptline_api_key'
+
+// Bindings detected from promptline.yaml
+export const availableBindings = ${JSON.stringify(bindings, null, 2)}
+
+// Get stored configuration
+function getConfig() {
+  try {
+    return JSON.parse(localStorage.getItem(STORAGE_KEY) || '{}')
+  } catch { return {} }
+}
+
+function getApiKey() {
+  return localStorage.getItem(API_KEY_STORAGE) || ''
+}
+
+// Convert PromptLine URLs to use local proxy
+function toProxyUrl(endpointId) {
+  return '/api/promptline/' + endpointId
+}
+
+// Call PromptLine API
+async function callPromptLineAPI(endpointId, apiKey, input, variables = {}) {
+  const proxyUrl = toProxyUrl(endpointId)
+  const fullUrl = proxyUrl + '?mode=sync'
+
+  const res = await fetch(fullUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      ...(apiKey ? { 'X-API-Key': apiKey } : {})
+    },
+    body: JSON.stringify({
+      input: typeof input === 'string' ? { text: input } : input,
+      variables
+    })
+  })
+
+  const data = await res.json()
+  if (!res.ok || data.error) {
+    throw new Error(data.detail || data.error?.message || data.error || res.statusText)
+  }
+
+  const output = data.data?.output || data.data?.response || data.output || data.response
+  return {
+    response: typeof output === 'string' ? output : JSON.stringify(output),
+    data: data.data || data
+  }
+}
+
+const PromptLineContext = createContext(null)
+
+export function PromptLineProvider({ children }) {
+  const value = {
+    config: {},
+    user: { id: 'dev-user', email: 'dev@example.com', name: 'Dev User' }
+  }
+  return (
+    <PromptLineContext.Provider value={value}>
+      {children}
+    </PromptLineContext.Provider>
+  )
+}
+
+export function usePromptLine(bindingName) {
+  const context = useContext(PromptLineContext)
+  const [isLoading, setIsLoading] = useState(false)
+
+  const endpointId = useMemo(() => {
+    const config = getConfig()
+    return config[bindingName] || null
+  }, [bindingName])
+
+  const execute = async (input, variables = {}) => {
+    if (!endpointId) {
+      console.warn(\`[PromptLine] Binding "\${bindingName}" not configured. Go to /_dev\`)
+      return {
+        response: \`[Not Configured] Binding "\${bindingName}" not set. Go to /_dev to configure it.\`,
+        error: true
+      }
+    }
+
+    const apiKey = getApiKey()
+    if (!apiKey) {
+      return {
+        response: '[No API Key] Configure your API key in /_dev',
+        error: true
+      }
+    }
+
+    setIsLoading(true)
+    try {
+      const result = await callPromptLineAPI(endpointId, apiKey, input, variables)
+      return result
+    } catch (err) {
+      console.error(\`[PromptLine] Error calling "\${bindingName}":\`, err)
+      return { response: '[API Error] ' + err.message, error: true }
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  return {
+    execute,
+    isLoading,
+    isConfigured: !!endpointId,
+    config: context?.config || {},
+    user: context?.user || {},
+    // Aliases for compatibility
+    callAI: execute,
+    submitForm: async (collection, data) => {
+      console.log('[PromptLine] submitForm:', collection, data)
+      return { success: true, id: 'mock-' + Date.now() }
+    },
+    fetchCollection: async () => ({ items: [], total: 0 })
+  }
+}
+
+// For SDK compatibility
+export const sdk = {
+  ai: {
+    call: async (bindingName, input) => {
+      const config = getConfig()
+      const endpointId = config[bindingName]
+      if (!endpointId) {
+        throw new Error(\`Binding "\${bindingName}" not configured\`)
+      }
+      return callPromptLineAPI(endpointId, getApiKey(), input)
+    }
+  },
+  collections: {
+    create: async (col, data) => ({ id: 'mock-' + Date.now() }),
+    list: async () => ({ data: [] }),
+    query: async () => [],
+    get: async () => null,
+    update: async () => ({ success: true }),
+    delete: async () => ({ success: true })
+  },
+  variables: {},
+  navigate: (path) => { window.location.href = path },
+  getNavigationState: () => undefined
+}
+
+export const initSDK = () => sdk
+export default sdk
+`,
+
+  // Dev admin page for configuring endpoints
+  devAdmin: (bindings) => `/**
+ * PromptLine Dev Admin - /_dev
+ * Configure your AI endpoints here
+ *
+ * Auto-generated by: npx promptlineapp get
+ */
+import React, { useState, useEffect } from 'react'
+import { Link } from 'react-router-dom'
+import { availableBindings } from './sdk-mock'
+
+const STORAGE_KEY = 'promptline_endpoints_config'
+const API_KEY_STORAGE = 'promptline_api_key'
+
+// Helper to extract endpoint ID from URL or return as-is
+function extractEndpointId(value) {
+  if (!value) return ''
+  // If it's a full URL, extract the endpoint ID
+  const match = value.match(/\\/api\\/v1\\/live\\/([^?/]+)/) || value.match(/\\/live\\/([^?/]+)/)
+  if (match) return match[1]
+  // If it starts with ep_ or similar, use as-is
+  return value
+}
+
+export default function DevAdmin() {
+  const [apiKey, setApiKey] = useState('')
+  const [endpoints, setEndpoints] = useState({})
+  const [endpointStatus, setEndpointStatus] = useState({}) // { bindingName: { alive: bool, info: obj, loading: string } }
+  const [testBinding, setTestBinding] = useState('')
+  const [testInput, setTestInput] = useState('Hello, test!')
+  const [testResult, setTestResult] = useState('')
+  const [testing, setTesting] = useState(false)
+  const [saved, setSaved] = useState(false)
+
+  useEffect(() => {
+    setApiKey(localStorage.getItem(API_KEY_STORAGE) || '')
+    try {
+      setEndpoints(JSON.parse(localStorage.getItem(STORAGE_KEY) || '{}'))
+    } catch {}
+    if (availableBindings.length > 0) {
+      setTestBinding(availableBindings[0].name)
+    }
+  }, [])
+
+  const save = () => {
+    // Clean endpoint values (extract IDs from URLs)
+    const cleanedEndpoints = {}
+    Object.entries(endpoints).forEach(([key, value]) => {
+      cleanedEndpoints[key] = extractEndpointId(value)
+    })
+    setEndpoints(cleanedEndpoints)
+    localStorage.setItem(API_KEY_STORAGE, apiKey)
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(cleanedEndpoints))
+    setSaved(true)
+    setTimeout(() => setSaved(false), 2000)
+  }
+
+  const updateEndpoint = (name, value) => {
+    setEndpoints(prev => ({ ...prev, [name]: value }))
+  }
+
+  // Check if endpoint is alive
+  const checkIsAlive = async (bindingName) => {
+    const endpointId = extractEndpointId(endpoints[bindingName])
+    if (!endpointId) {
+      setEndpointStatus(prev => ({ ...prev, [bindingName]: { ...prev[bindingName], alive: false, error: 'No endpoint ID' } }))
+      return
+    }
+
+    setEndpointStatus(prev => ({ ...prev, [bindingName]: { ...prev[bindingName], loading: 'alive' } }))
+
+    try {
+      const res = await fetch('/api/promptline/' + endpointId + '/isAlive', {
+        method: 'GET',
+        headers: apiKey ? { 'X-API-Key': apiKey } : {}
+      })
+      const data = await res.json().catch(() => ({}))
+      setEndpointStatus(prev => ({
+        ...prev,
+        [bindingName]: {
+          ...prev[bindingName],
+          alive: res.ok && data.alive === true,
+          loading: null,
+          error: res.ok ? null : (data.detail || res.statusText)
+        }
+      }))
+    } catch (err) {
+      setEndpointStatus(prev => ({
+        ...prev,
+        [bindingName]: { ...prev[bindingName], alive: false, loading: null, error: err.message }
+      }))
+    }
+  }
+
+  // Get endpoint info
+  const fetchInfo = async (bindingName) => {
+    const endpointId = extractEndpointId(endpoints[bindingName])
+    if (!endpointId) {
+      setEndpointStatus(prev => ({ ...prev, [bindingName]: { ...prev[bindingName], error: 'No endpoint ID' } }))
+      return
+    }
+
+    setEndpointStatus(prev => ({ ...prev, [bindingName]: { ...prev[bindingName], loading: 'info' } }))
+
+    try {
+      const res = await fetch('/api/promptline/' + endpointId + '/info', {
+        method: 'GET',
+        headers: apiKey ? { 'X-API-Key': apiKey } : {}
+      })
+      const data = await res.json().catch(() => ({}))
+      setEndpointStatus(prev => ({
+        ...prev,
+        [bindingName]: {
+          ...prev[bindingName],
+          info: res.ok ? data : null,
+          loading: null,
+          error: res.ok ? null : (data.detail || res.statusText)
+        }
+      }))
+    } catch (err) {
+      setEndpointStatus(prev => ({
+        ...prev,
+        [bindingName]: { ...prev[bindingName], info: null, loading: null, error: err.message }
+      }))
+    }
+  }
+
+  const testEndpoint = async () => {
+    const endpointId = extractEndpointId(endpoints[testBinding])
+    if (!testBinding || !endpointId) {
+      setTestResult('Error: Endpoint not configured')
+      return
+    }
+    if (!apiKey) {
+      setTestResult('Error: API Key not set')
+      return
+    }
+
+    setTesting(true)
+    setTestResult('Calling API...')
+
+    try {
+      const res = await fetch('/api/promptline/' + endpointId + '?mode=sync', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': apiKey
+        },
+        body: JSON.stringify({ input: { text: testInput } })
+      })
+      const data = await res.json()
+      if (!res.ok || data.error) {
+        setTestResult('Error: ' + (data.detail || data.error?.message || res.statusText))
+      } else {
+        const output = data.data?.output || data.data?.response || data.output || data.response
+        setTestResult(typeof output === 'string' ? output : JSON.stringify(output, null, 2))
+      }
+    } catch (err) {
+      setTestResult('Error: ' + err.message)
+    }
+    setTesting(false)
+  }
+
+  const configuredCount = Object.values(endpoints).filter(Boolean).length
+
+  const btnStyle = (loading) => ({
+    padding: '4px 8px',
+    fontSize: 11,
+    border: '1px solid #d1d5db',
+    borderRadius: 4,
+    background: loading ? '#f3f4f6' : '#fff',
+    cursor: loading ? 'wait' : 'pointer',
+    marginRight: 4
+  })
+
+  return (
+    <div style={{ maxWidth: 1000, margin: '0 auto', padding: 24, fontFamily: 'system-ui, sans-serif' }}>
+      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 24 }}>
+        <h1 style={{ margin: 0, color: '#f59e0b' }}>/_dev</h1>
+        <Link to="/" style={{ color: '#6366f1' }}>← Back to App</Link>
+      </div>
+
+      <div style={{ background: '#fefce8', border: '1px solid #fde047', borderRadius: 8, padding: 16, marginBottom: 24 }}>
+        <strong>⚠️ Development Only</strong>
+        <p style={{ margin: '8px 0 0', fontSize: 14 }}>Configure your PromptLine endpoints here. Never commit API keys to git!</p>
+      </div>
+
+      {/* API Key */}
+      <div style={{ background: '#fff', border: '1px solid #e5e7eb', borderRadius: 8, padding: 16, marginBottom: 24 }}>
+        <h2 style={{ margin: '0 0 16px', fontSize: 18 }}>🔑 API Key</h2>
+        <input
+          type="password"
+          value={apiKey}
+          onChange={e => setApiKey(e.target.value)}
+          placeholder="sk_org_... or sk_ws_..."
+          style={{ width: '100%', padding: 12, border: '1px solid #d1d5db', borderRadius: 6, fontSize: 14 }}
+        />
+        <p style={{ margin: '8px 0 0', fontSize: 12, color: '#6b7280' }}>
+          This API key will be used for Info and IsAlive checks
+        </p>
+      </div>
+
+      {/* Bindings */}
+      <div style={{ background: '#fff', border: '1px solid #e5e7eb', borderRadius: 8, padding: 16, marginBottom: 24 }}>
+        <h2 style={{ margin: '0 0 16px', fontSize: 18 }}>
+          📋 AI Bindings ({configuredCount}/{availableBindings.length} configured)
+        </h2>
+        <table style={{ width: '100%', borderCollapse: 'collapse' }}>
+          <thead>
+            <tr style={{ borderBottom: '2px solid #e5e7eb' }}>
+              <th style={{ textAlign: 'left', padding: 8 }}>Binding</th>
+              <th style={{ textAlign: 'left', padding: 8 }}>Endpoint ID</th>
+              <th style={{ textAlign: 'center', padding: 8, width: 140 }}>Actions</th>
+              <th style={{ textAlign: 'center', padding: 8, width: 60 }}>Status</th>
+            </tr>
+          </thead>
+          <tbody>
+            {availableBindings.map(b => {
+              const status = endpointStatus[b.name] || {}
+              return (
+                <tr key={b.name} style={{ borderBottom: '1px solid #f3f4f6' }}>
+                  <td style={{ padding: 8 }}>
+                    <div style={{ fontWeight: 500 }}>{b.name}</div>
+                    <div style={{ fontSize: 12, color: '#6b7280' }}>{b.description?.slice(0, 50) || b.type}</div>
+                  </td>
+                  <td style={{ padding: 8 }}>
+                    <input
+                      type="text"
+                      value={endpoints[b.name] || ''}
+                      onChange={e => updateEndpoint(b.name, e.target.value)}
+                      placeholder="ep_... or full URL"
+                      style={{ width: '100%', padding: 8, border: '1px solid #d1d5db', borderRadius: 4, fontSize: 12 }}
+                    />
+                  </td>
+                  <td style={{ padding: 8, textAlign: 'center' }}>
+                    <button
+                      onClick={() => checkIsAlive(b.name)}
+                      disabled={status.loading === 'alive'}
+                      style={btnStyle(status.loading === 'alive')}
+                      title="Check if endpoint is alive"
+                    >
+                      {status.loading === 'alive' ? '...' : '♥ Alive'}
+                    </button>
+                    <button
+                      onClick={() => fetchInfo(b.name)}
+                      disabled={status.loading === 'info'}
+                      style={btnStyle(status.loading === 'info')}
+                      title="Get endpoint info"
+                    >
+                      {status.loading === 'info' ? '...' : 'ℹ Info'}
+                    </button>
+                  </td>
+                  <td style={{ padding: 8, textAlign: 'center' }}>
+                    <span
+                      style={{
+                        display: 'inline-block',
+                        width: 12,
+                        height: 12,
+                        borderRadius: '50%',
+                        background: status.alive === true ? '#22c55e' : status.alive === false ? '#ef4444' : (endpoints[b.name] ? '#fbbf24' : '#d1d5db')
+                      }}
+                      title={status.error || (status.alive ? 'Alive' : status.alive === false ? 'Not responding' : 'Not checked')}
+                    />
+                  </td>
+                </tr>
+              )
+            })}
+          </tbody>
+        </table>
+
+        {/* Show info panel if any endpoint has info */}
+        {Object.entries(endpointStatus).some(([_, s]) => s.info) && (
+          <div style={{ marginTop: 16, padding: 12, background: '#f9fafb', borderRadius: 6, fontSize: 12 }}>
+            <strong>Endpoint Info:</strong>
+            {Object.entries(endpointStatus).filter(([_, s]) => s.info).map(([name, s]) => (
+              <div key={name} style={{ marginTop: 8 }}>
+                <strong>{name}:</strong>
+                <pre style={{ margin: '4px 0', whiteSpace: 'pre-wrap', fontSize: 11 }}>
+                  {JSON.stringify(s.info, null, 2)}
+                </pre>
+              </div>
+            ))}
+          </div>
+        )}
+
+        {/* Show errors */}
+        {Object.entries(endpointStatus).some(([_, s]) => s.error) && (
+          <div style={{ marginTop: 16, padding: 12, background: '#fef2f2', borderRadius: 6, fontSize: 12, color: '#dc2626' }}>
+            <strong>Errors:</strong>
+            {Object.entries(endpointStatus).filter(([_, s]) => s.error).map(([name, s]) => (
+              <div key={name}>{name}: {s.error}</div>
+            ))}
+          </div>
+        )}
+      </div>
+
+      {/* Save Button */}
+      <button
+        onClick={save}
+        style={{
+          width: '100%',
+          padding: 14,
+          background: saved ? '#22c55e' : '#6366f1',
+          color: '#fff',
+          border: 'none',
+          borderRadius: 8,
+          fontSize: 16,
+          fontWeight: 600,
+          cursor: 'pointer',
+          marginBottom: 24
+        }}
+      >
+        {saved ? '✓ Saved!' : 'Save Configuration'}
+      </button>
+
+      {/* Test Panel */}
+      <div style={{ background: '#fff', border: '1px solid #e5e7eb', borderRadius: 8, padding: 16 }}>
+        <h2 style={{ margin: '0 0 16px', fontSize: 18 }}>🧪 Test AI Call</h2>
+        <div style={{ display: 'flex', gap: 8, marginBottom: 12 }}>
+          <select
+            value={testBinding}
+            onChange={e => setTestBinding(e.target.value)}
+            style={{ flex: 1, padding: 8, border: '1px solid #d1d5db', borderRadius: 4 }}
+          >
+            {availableBindings.map(b => (
+              <option key={b.name} value={b.name}>{b.name}</option>
+            ))}
+          </select>
+          <button
+            onClick={testEndpoint}
+            disabled={testing}
+            style={{
+              padding: '8px 16px',
+              background: '#6366f1',
+              color: '#fff',
+              border: 'none',
+              borderRadius: 4,
+              cursor: testing ? 'wait' : 'pointer'
+            }}
+          >
+            {testing ? '...' : 'Send'}
+          </button>
+        </div>
+        <textarea
+          value={testInput}
+          onChange={e => setTestInput(e.target.value)}
+          placeholder="Test input..."
+          rows={2}
+          style={{ width: '100%', padding: 8, border: '1px solid #d1d5db', borderRadius: 4, marginBottom: 12, resize: 'vertical' }}
+        />
+        {testResult && (
+          <pre style={{
+            background: '#f9fafb',
+            padding: 12,
+            borderRadius: 4,
+            fontSize: 13,
+            overflow: 'auto',
+            maxHeight: 200,
+            whiteSpace: 'pre-wrap'
+          }}>
+            {testResult}
+          </pre>
+        )}
+      </div>
+    </div>
+  )
+}
+`,
+
+  // Vite config addition for proxy
+  viteProxyConfig: `
+    // PromptLine API Proxy (added by npx promptlineapp get)
+    proxy: {
+      '/api/promptline': {
+        target: 'https://app.promptlineops.com',
+        changeOrigin: true,
+        rewrite: (path) => path.replace(/^\\/api\\/promptline/, '/api/v1/live'),
+        secure: true
+      }
+    },`
+}
+
 // Get project from Git repository
 async function getProject(gitUrl, destName) {
   const { execSync } = require('child_process');
@@ -2106,9 +2708,6 @@ async function getProject(gitUrl, destName) {
 
   // Extract repo name from URL if destName not provided
   if (!destName) {
-    // Handle various URL formats
-    // https://github.com/user/repo.git -> repo
-    // git@github.com:user/repo.git -> repo
     const match = gitUrl.match(/\/([^\/]+?)(\.git)?$/) || gitUrl.match(/:([^\/]+?)(\.git)?$/);
     destName = match ? match[1] : 'promptline-app';
   }
@@ -2122,7 +2721,6 @@ async function getProject(gitUrl, destName) {
 
   const targetDir = path.resolve(process.cwd(), destName);
 
-  // Check if directory exists
   if (fs.existsSync(targetDir)) {
     error(`Directory "${destName}" already exists.`);
     process.exit(1);
@@ -2132,34 +2730,123 @@ async function getProject(gitUrl, destName) {
   console.log(`${c.cyan}→${c.reset} Destination: ${c.green}${destName}${c.reset}\n`);
 
   try {
-    // Clone with depth 1 for speed, stdio inherit for git auth prompts
+    // Clone
     execSync(`git clone --depth 1 "${gitUrl}" "${destName}"`, {
       stdio: 'inherit',
       cwd: process.cwd()
     });
 
-    // Remove .git directory
+    // Remove .git
     const gitDir = path.join(targetDir, '.git');
     if (fs.existsSync(gitDir)) {
       fs.rmSync(gitDir, { recursive: true });
     }
-    success('Removed .git directory');
+    success('Cloned repository');
 
-    // Initialize fresh git repo
+    // Init fresh git
     try {
       execSync('git init', { cwd: targetDir, stdio: 'pipe' });
       success('Initialized new git repository');
-    } catch (e) {
-      // Git init is optional
-    }
+    } catch (e) {}
 
-    // Detect project structure for instructions
+    // Detect structure
     const hasDevRuntime = fs.existsSync(path.join(targetDir, 'dev-runtime'));
-    const hasDev = fs.existsSync(path.join(targetDir, 'dev'));
-    const hasPackageJson = fs.existsSync(path.join(targetDir, 'package.json'));
-    const hasDevRuntimePackage = fs.existsSync(path.join(targetDir, 'dev-runtime', 'package.json'));
+    const hasPromptlineYaml = fs.existsSync(path.join(targetDir, 'promptline.yaml'));
+
+    // Parse bindings from promptline.yaml
+    let bindings = [];
+    if (hasPromptlineYaml) {
+      try {
+        const yamlContent = fs.readFileSync(path.join(targetDir, 'promptline.yaml'), 'utf8');
+        bindings = parseBindingsFromYaml(yamlContent);
+        success(`Detected ${bindings.length} AI bindings from promptline.yaml`);
+      } catch (e) {
+        console.log(`${c.yellow}!${c.reset} Could not parse promptline.yaml: ${e.message}`);
+      }
+    }
+
+    // Inject dev files if we have dev-runtime
+    if (hasDevRuntime && bindings.length > 0) {
+      const srcDir = path.join(targetDir, 'dev-runtime', 'src');
+
+      // Backup original sdk-mock if exists
+      const sdkPath = path.join(srcDir, 'sdk-mock.ts');
+      if (fs.existsSync(sdkPath)) {
+        fs.renameSync(sdkPath, path.join(srcDir, 'sdk-mock.original.ts'));
+        success('Backed up original sdk-mock.ts');
+      }
+
+      // Write new SDK (as .tsx for JSX support)
+      fs.writeFileSync(path.join(srcDir, 'sdk-mock.tsx'), devTemplates.sdkHybrid(bindings));
+      success('Injected hybrid SDK (sdk-mock.tsx)');
+
+      // Write DevAdmin page
+      fs.writeFileSync(path.join(srcDir, 'DevAdmin.tsx'), devTemplates.devAdmin(bindings));
+      success('Injected /_dev page (DevAdmin.tsx)');
+
+      // Modify Router.tsx to add /_dev route
+      const routerPath = path.join(srcDir, 'Router.tsx');
+      if (fs.existsSync(routerPath)) {
+        let routerContent = fs.readFileSync(routerPath, 'utf8');
+
+        // Add import if not present
+        if (!routerContent.includes('DevAdmin')) {
+          routerContent = routerContent.replace(
+            /(import .+ from ['"].+['"];?\n)/,
+            "$1import DevAdmin from './DevAdmin'\n"
+          );
+        }
+
+        // Add route if not present
+        if (!routerContent.includes('/_dev')) {
+          // Try to find the routes array and add /_dev
+          routerContent = routerContent.replace(
+            /(<Route\s+path=["']\/["']\s+element=)/,
+            "<Route path=\"/_dev\" element={<DevAdmin />} />\n      $1"
+          );
+        }
+
+        fs.writeFileSync(routerPath, routerContent);
+        success('Added /_dev route to Router.tsx');
+      }
 
-    // Success message with appropriate instructions
+      // Check and update vite.config.ts for proxy
+      const viteConfigPath = path.join(targetDir, 'dev-runtime', 'vite.config.ts');
+      if (fs.existsSync(viteConfigPath)) {
+        let viteContent = fs.readFileSync(viteConfigPath, 'utf8');
+        if (!viteContent.includes('/api/promptline')) {
+          // Add proxy config to server section
+          if (viteContent.includes('server:')) {
+            viteContent = viteContent.replace(
+              /server:\s*\{/,
+              'server: {' + devTemplates.viteProxyConfig
+            );
+          } else {
+            // Add server section before the closing of defineConfig
+            viteContent = viteContent.replace(
+              /}\s*\)\s*$/,
+              `,\n  server: {${devTemplates.viteProxyConfig}\n  }\n})`
+            );
+          }
+          fs.writeFileSync(viteConfigPath, viteContent);
+          success('Added API proxy to vite.config.ts');
+        }
+      }
+    }
+
+    // Determine dev directory and port
+    const devDir = hasDevRuntime ? 'dev-runtime' : '.';
+    let devPort = '5173';
+
+    // Try to detect port from vite config
+    const viteConfigPath = path.join(targetDir, hasDevRuntime ? 'dev-runtime' : '', 'vite.config.ts');
+    if (fs.existsSync(viteConfigPath)) {
+      const viteContent = fs.readFileSync(viteConfigPath, 'utf8');
+      const portMatch = viteContent.match(/port:\s*(\d+)/);
+      if (portMatch) devPort = portMatch[1];
+    }
+
+    // Success message
     console.log(`
 ${c.green}╔═══════════════════════════════════════════════════════════╗
 ║                                                               ║
@@ -2169,29 +2856,19 @@ ${c.green}╔══════════════════════
 
 ${c.bold}Next steps:${c.reset}
 
-  ${c.cyan}cd ${destName}${c.reset}`);
-
-    if (hasDevRuntime && hasDevRuntimePackage) {
-      console.log(`
-  ${c.dim}# This project has a dev-runtime environment${c.reset}
-  ${c.cyan}cd dev-runtime${c.reset}
+  ${c.cyan}cd ${destName}${hasDevRuntime ? '/dev-runtime' : ''}${c.reset}
   ${c.cyan}npm install${c.reset}
-  ${c.cyan}npm run dev${c.reset}`);
-    } else if (hasDev || hasPackageJson) {
-      console.log(`
-  ${c.cyan}npm install${c.reset}
-  ${c.cyan}npm run dev${c.reset}`);
-    } else {
-      console.log(`
-  ${c.dim}# Check the project README for setup instructions${c.reset}`);
-    }
+  ${c.cyan}npm run dev${c.reset}
 
-    console.log(`
-${c.bold}Key files:${c.reset}
+${c.bold}Configure AI endpoints:${c.reset}
+
+  Open ${c.yellow}http://localhost:${devPort}/_dev${c.reset}
+  1. Enter your API key
+  2. Add endpoint IDs for each binding
+  3. Test your endpoints
 
-  ${c.yellow}promptline.yaml${c.reset}   Main configuration
-  ${c.yellow}public/${c.reset}           Public pages
-  ${c.yellow}private/${c.reset}          Admin/dashboard pages
+${c.bold}${bindings.length} AI bindings detected:${c.reset}
+${bindings.slice(0, 5).map(b => `  ${c.dim}•${c.reset} ${b.name}`).join('\n')}${bindings.length > 5 ? `\n  ${c.dim}... and ${bindings.length - 5} more${c.reset}` : ''}
 
 ${c.bold}Documentation:${c.reset} ${c.cyan}https://docs.promptlineops.com${c.reset}
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promptlineapp",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Create PromptLine applications with ease",
   "author": "PromptLine <support@promptlineops.com>",
   "license": "MIT",