@vrdmr/fnx-test 0.4.2 → 0.5.0

package/lib/azurite-manager.js

@@ -14,16 +14,65 @@ let azuriteProcess = null;
 let weStartedAzurite = false;
 
 /**
- * Determine whether Azurite is needed based on AzureWebJobsStorage value.
- * Returns true for "UseDevelopmentStorage=true", empty string, or missing key.
+ * Check if a connection string value indicates development/emulator storage.
+ * Matches:
+ * - "UseDevelopmentStorage=true"
+ * - "UseDevelopmentStorage=true;DevelopmentStorageProxyUri=..."
+ * - Connection strings pointing to devstoreaccount1 (Azurite default)
+ * - Connection strings pointing to 127.0.0.1:10000 (Azurite default ports)
  */
-function needsAzurite(mergedValues) {
-  const connStr = mergedValues?.AzureWebJobsStorage;
-  if (!connStr || connStr === '') return true;
-  if (connStr === 'UseDevelopmentStorage=true') return true;
+function isDevStorageConnectionString(value) {
+  if (!value || typeof value !== 'string') return false;
+  
+  const normalized = value.toLowerCase();
+  
+  // Check for UseDevelopmentStorage=true (with or without additional params)
+  if (normalized.startsWith('usedevelopmentstorage=true')) {
+    return true;
+  }
+  
+  // Check for Azurite default account name
+  if (normalized.includes('devstoreaccount1')) {
+    return true;
+  }
+  
+  // Check for localhost Azurite ports (10000, 10001, 10002)
+  if (normalized.includes('127.0.0.1:10000') || 
+      normalized.includes('127.0.0.1:10001') || 
+      normalized.includes('127.0.0.1:10002') ||
+      normalized.includes('localhost:10000') ||
+      normalized.includes('localhost:10001') ||
+      normalized.includes('localhost:10002')) {
+    return true;
+  }
+  
   return false;
 }
 
+/**
+ * Determine whether Azurite is needed based on any setting using development storage.
+ * Returns { needed: boolean, keys: string[] } where keys are the ones using dev storage.
+ */
+function needsAzurite(mergedValues) {
+  if (!mergedValues) return { needed: false, keys: [] };
+  
+  const devStorageKeys = [];
+  
+  for (const [key, value] of Object.entries(mergedValues)) {
+    if (isDevStorageConnectionString(value)) {
+      devStorageKeys.push(key);
+    }
+  }
+  
+  // Also check AzureWebJobsStorage specially - empty/missing means dev storage
+  const webJobsStorage = mergedValues.AzureWebJobsStorage;
+  if ((!webJobsStorage || webJobsStorage === '') && !devStorageKeys.includes('AzureWebJobsStorage')) {
+    devStorageKeys.push('AzureWebJobsStorage');
+  }
+  
+  return { needed: devStorageKeys.length > 0, keys: devStorageKeys };
+}
+
 /**
  * TCP probe — resolves true if a connection can be established on the given port.
  */
@@ -130,12 +179,21 @@ export async function ensureAzurite(mergedValues, opts = {}) {
     return null;
   }
 
-  if (!needsAzurite(mergedValues)) {
+  const { needed, keys } = needsAzurite(mergedValues);
+  if (!needed) {
     return null;
   }
 
-  const storageVal = mergedValues?.AzureWebJobsStorage || '(empty)';
-  console.log(info(`[fnx] Detected AzureWebJobsStorage=${storageVal}`));
+  // Log which connection strings are using dev storage
+  if (keys.length === 1) {
+    const val = mergedValues?.[keys[0]] || '(empty)';
+    console.log(info(`[fnx] Detected ${keys[0]}=${val}`));
+  } else {
+    console.log(info(`[fnx] Detected ${keys.length} connection strings requiring Azurite:`));
+    for (const key of keys) {
+      console.log(info(`[fnx]   • ${key}`));
+    }
+  }
 
   // Check if Azurite is already running
   if (await isAzuriteRunning()) {

package/lib/chat/index.js

@@ -0,0 +1,281 @@
+/**
+ * fnx chat — launch a coding agent with Azure Functions context.
+ * Detects available agents, generates .fnx/agent.md with project
+ * context, and starts the agent with the right flags.
+ */
+
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join, resolve, dirname } from 'node:path';
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { detectProject } from '../setup/detect.js';
+import { detectAgents } from '../setup/agent-detect.js';
+import { title, info, funcName, success, error as errorColor, warning, dim, bold } from '../colors.js';
+
+/**
+ * Agent launcher definitions — how to start each coding agent.
+ */
+const LAUNCHERS = {
+  'claude-code': {
+    command: 'claude',
+    buildArgs: (ctx) => [],  // Claude reads CLAUDE.md and .claude/skills/ automatically
+    description: 'Claude Code reads .claude/skills/ and CLAUDE.md automatically',
+  },
+  'github-copilot': {
+    command: 'copilot',
+    buildArgs: (ctx) => [],  // Copilot reads .github/copilot-instructions.md automatically
+    description: 'GitHub Copilot reads .github/copilot-instructions.md automatically',
+  },
+  'codex': {
+    command: 'codex',
+    buildArgs: (ctx) => [],  // Codex reads AGENTS.md automatically
+    description: 'Codex reads AGENTS.md automatically',
+  },
+};
+
+/**
+ * Run fnx chat.
+ * @param {string[]} args - CLI arguments
+ */
+export async function runChat(args) {
+  const appPath = resolveAppPath(args);
+  const agentFlag = getFlag(args, '--agent');
+  const promptFlag = getFlag(args, '--prompt');
+  const setupOnly = args.includes('--setup-only');
+
+  console.log();
+  console.log(title('fnx chat') + dim(' — AI-assisted Azure Functions development'));
+  console.log();
+
+  // Step 1: Detect project
+  console.log(bold('🔍 Loading project context...'));
+  const project = await detectProject(appPath);
+  if (project) {
+    console.log(success(`  ✓ ${formatRuntime(project)} (${project.sku})`));
+    if (project.functions.length > 0) {
+      console.log(dim(`    Functions: ${project.functions.map(f => `${f.name} (${f.type})`).join(', ')}`));
+    }
+  } else {
+    console.log(warning('  ⚠ No Azure Functions project detected. The agent can help you create one.'));
+  }
+
+  // Show skill status (informational only — setup runs after agent selection)
+  const skillsDir = join(appPath, '.agents', 'skills');
+  const needsSetup = !existsSync(skillsDir);
+  if (!needsSetup) {
+    try {
+      const { readdir } = await import('node:fs/promises');
+      const skills = (await readdir(skillsDir)).filter(d => !d.startsWith('.'));
+      console.log(dim(`    Skills: ${skills.length} installed in .agents/skills/`));
+    } catch { /* ignore */ }
+  }
+  console.log();
+
+  // Step 2: Detect agents and select (only CLI-launchable agents)
+  console.log(bold('🤖 Detecting coding agents...'));
+  let agents = await detectAgents(appPath);
+  const launchableAgents = agents.filter(a => LAUNCHERS[a.id] && a.type === 'cli');
+
+  let selectedId;
+
+  if (agentFlag) {
+    // Validate explicit agent
+    const launcher = LAUNCHERS[agentFlag];
+    if (!launcher) {
+      console.error(errorColor(`  ✗ Unknown agent: ${agentFlag}`));
+      console.error(dim(`    Available: ${Object.keys(LAUNCHERS).join(', ')}`));
+      process.exit(1);
+    }
+    selectedId = agentFlag;
+  } else if (launchableAgents.length === 0) {
+    console.log(warning('  ⚠ No supported CLI agents detected.'));
+    console.log();
+    console.log('  Install one of the following:');
+    console.log(dim('    • Claude Code: https://claude.ai/download'));
+    console.log(dim('    • GitHub Copilot CLI: https://docs.github.com/en/copilot/using-github-copilot/using-github-copilot-in-the-command-line'));
+    console.log(dim('    • Codex CLI: npm install -g @openai/codex'));
+    console.log();
+    console.log(dim('  Or use --agent to specify: fnx chat --agent claude-code'));
+    process.exit(1);
+  } else {
+    for (const a of launchableAgents) {
+      console.log(success(`  ✓ ${a.name}`));
+    }
+    console.log();
+
+    if (launchableAgents.length === 1) {
+      selectedId = launchableAgents[0].id;
+    } else {
+      selectedId = await promptAgentSelection(launchableAgents);
+    }
+  }
+
+  // Step 3: Auto-run setup if needed (after agent is selected)
+  if (needsSetup) {
+    console.log();
+    console.log(warning('  ⚠ No skills installed. Running fnx setup for ' + selectedId + '...'));
+    console.log();
+    const { runSetup } = await import('../setup/index.js');
+    await runSetup(['--all', '--agent', selectedId, '--app-path', appPath]);
+  }
+
+  // Step 4: Generate .fnx/agent.md
+  const agentMdPath = join(appPath, '.fnx', 'agent.md');
+  await generateAgentMd(appPath, project, agentMdPath);
+
+  // Step 5: Launch agent (skip if --setup-only)
+  if (setupOnly) {
+    console.log();
+    console.log(success('  ✓ Setup complete. Skipping agent launch (--setup-only).'));
+    return;
+  }
+  const launcher = LAUNCHERS[selectedId];
+  await launchAgent(selectedId, launcher, appPath, project, promptFlag);
+}
+
+async function launchAgent(agentId, launcher, appPath, project, prompt) {
+  const agentName = agentId.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+
+  console.log(bold('🚀 Launching ' + agentName + '...'));
+  console.log(dim(`  ${launcher.description}`));
+  console.log();
+
+  console.log('┌' + '─'.repeat(50) + '┐');
+  console.log('│  ' + bold('fnx chat') + ' • ' + agentName.padEnd(38) + '│');
+  if (project) {
+    console.log('│  ' + dim(`SKU: ${project.sku} | ${project.functions.length} functions`).padEnd(56) + '│');
+  }
+  console.log('└' + '─'.repeat(50) + '┘');
+  console.log();
+
+  const args = launcher.buildArgs({ appPath, project });
+  if (prompt) args.push(prompt);
+
+  // Launch the agent as an interactive child process
+  // Use shell: false to prevent shell injection via user-controlled args (e.g., --prompt)
+  const child = spawn(launcher.command, args, {
+    cwd: appPath,
+    stdio: 'inherit',
+    shell: false,
+  });
+
+  child.on('error', (err) => {
+    console.error(errorColor(`  ✗ Failed to launch ${agentName}: ${err.message}`));
+    if (err.code === 'ENOENT') {
+      console.error(dim(`    Make sure '${launcher.command}' is installed and in your PATH.`));
+    }
+    process.exit(1);
+  });
+
+  child.on('exit', (code) => {
+    if (code !== 0 && code !== null) {
+      console.log(warning(`\n  ${agentName} exited with code ${code}`));
+    }
+  });
+}
+
+async function generateAgentMd(appPath, project, outputPath) {
+  await mkdir(dirname(outputPath), { recursive: true });
+
+  const lines = [
+    '# Azure Functions Development Agent',
+    '',
+    'You are assisting a developer building Azure Functions applications with fnx.',
+    '',
+  ];
+
+  if (project) {
+    const funcList = project.functions.map(f => f.name + ' (' + f.type + ')').join(', ') || 'none detected';
+    lines.push(
+      '## Project Context',
+      '- **Runtime:** ' + formatRuntime(project),
+      '- **Programming Model:** ' + (project.programmingModel || 'v4'),
+      '- **SKU:** ' + project.sku,
+      '- **Functions:** ' + funcList,
+      '- **Emulator:** fnx (SKU-aware local emulator)',
+    );
+  } else {
+    lines.push(
+      '## No Project Detected',
+      'No Azure Functions project was found in the current directory.',
+    );
+  }
+
+  lines.push(
+    '',
+    '## Available MCP Tools',
+    'If the fnx Templates MCP server is configured, you can use:',
+    '- `functions_language_list` — Get supported languages and runtime versions',
+    '- `functions_template_get` — Generate function template code',
+    '- `functions_project_get` — Scaffold project files',
+    '',
+    '## Guidelines',
+    '- Always use the latest programming model for the detected runtime',
+    '- Check SKU compatibility before suggesting triggers/bindings',
+    '- Use `fnx start` for local testing (not `func start`)',
+    '- Use `app-config.yaml` for non-secret config (committed to git)',
+    '- Do NOT put secrets in workspace files',
+    '- Refer to installed skills for detailed guidance',
+    '',
+  );
+
+  await writeFile(outputPath, lines.join('\n'));
+}
+
+async function promptAgentSelection(agents) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  console.log('Which agent would you like to use?');
+  agents.forEach((a, i) => {
+    console.log(`  ${i + 1}. ${a.name}${i === 0 ? dim(' (recommended)') : ''}`);
+  });
+
+  return new Promise((resolve) => {
+    rl.question('\nSelect [1]: ', (answer) => {
+      rl.close();
+      const idx = parseInt(answer || '1', 10) - 1;
+      resolve(agents[Math.max(0, Math.min(idx, agents.length - 1))].id);
+    });
+  });
+}
+
+function formatRuntime(project) {
+  if (!project) return 'unknown';
+  const name = project.runtime === 'node' ? 'Node.js' : project.runtime;
+  return `${name} (${project.language || project.runtime})`;
+}
+
+function resolveAppPath(args) {
+  const explicit = getFlag(args, '--app-path');
+  return explicit ? resolve(explicit) : process.cwd();
+}
+
+function getFlag(args, name) {
+  const idx = args.indexOf(name);
+  return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : null;
+}
+
+export function printChatHelp() {
+  console.log(`${title('Usage:')} fnx chat [options]
+
+${title('Description:')}
+  Launch a coding agent with Azure Functions context. Detects your project,
+  generates context files, and starts your preferred coding agent.
+
+${title('Options:')}
+  ${success('--agent')} <name>     Use a specific agent: ${funcName('claude-code')}, ${funcName('github-copilot')}, ${funcName('codex')}
+  ${success('--app-path')} <dir>   Path to function app (default: current directory)
+  ${success('--prompt')} <text>    Pass prompt text as CLI argument to the agent
+  ${success('-h')}, ${success('--help')}       Show this help
+
+${title('Examples:')}
+  ${dim('# Auto-detect agent and launch')}
+  fnx chat
+
+  ${dim('# Use Claude Code specifically')}
+  fnx chat --agent claude-code
+
+  ${dim('# Non-interactive mode')}
+  fnx chat --prompt "Add a timer trigger that runs every 5 minutes"
+`);
+}

package/lib/cli.js

@@ -112,6 +112,17 @@ export async function main(args) {
     return;
   }
 
+  if (cmd === 'init') {
+    if (hasHelp(args.slice(1))) {
+      const { printInitHelp } = await import('./init.js');
+      printInitHelp();
+      return;
+    }
+    const { runInit } = await import('./init.js');
+    await runInit(args.slice(1));
+    return;
+  }
+
   if (cmd === 'doctor') {
     if (hasHelp(args.slice(1))) { printDoctorHelp(); return; }
     const { runDoctor } = await import('./doctor.js');
@@ -155,6 +166,28 @@ export async function main(args) {
     return;
   }
 
+  if (cmd === 'setup') {
+    if (hasHelp(args.slice(1))) {
+      const { printSetupHelp } = await import('./setup/index.js');
+      printSetupHelp();
+      return;
+    }
+    const { runSetup } = await import('./setup/index.js');
+    await runSetup(args.slice(1));
+    return;
+  }
+
+  if (cmd === 'chat') {
+    if (hasHelp(args.slice(1))) {
+      const { printChatHelp } = await import('./chat/index.js');
+      printChatHelp();
+      return;
+    }
+    const { runChat } = await import('./chat/index.js');
+    await runChat(args.slice(1));
+    return;
+  }
+
   if (cmd !== 'start') {
     console.error(errorColor(`Unknown command: ${cmd}\n`));
     printHelp();
@@ -469,7 +502,10 @@ function printHelp() {
   console.log(`${title('Usage:')} fnx <command> [options]
 
 ${title('Commands:')}
+  ${funcName('init')}             Initialize a new Azure Functions project.
   ${funcName('start')}            Launch the Azure Functions host runtime for a specific SKU.
+  ${funcName('setup')}            Add AI agent skills, MCP config, and instructions.
+  ${funcName('chat')}             Launch a coding agent with Azure Functions context.
   ${funcName('doctor')}           Validate project setup and diagnose common issues.
   ${funcName('sync')}             Sync cached host/extensions with current catalog profile.
   ${funcName('pack')}             Package a Functions app into a deployment zip.

package/lib/config.js

@@ -3,8 +3,8 @@
 // Reads app-config.yaml (primary) or auto-creates it from local.settings.json.
 // Validates against config-schema.js, checks for secrets, manages .gitignore protection.
 
-import { readFile, writeFile, access, readdir } from 'node:fs/promises';
-import { join, resolve as resolvePath } from 'node:path';
+import { readFile, writeFile, access } from 'node:fs/promises';
+import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
 
@@ -134,6 +134,46 @@ export async function migrateConfig(appPath) {
   return autoCreateFromLocalSettings(appPath, localSettingsPath);
 }
 
+/**
+ * Create app-config.yaml from local.settings.json (if exists) with CLI overrides.
+ * Used by fnx init to generate config after template download.
+ * @param {string} appPath - Directory containing local.settings.json
+ * @param {Object} overrides - { runtime, version, sku } from CLI flags
+ * @param {Object} options - { silent: boolean } suppress output
+ * @returns {Promise<boolean>} true if file was created, false if already exists
+ */
+export async function createAppConfig(appPath, overrides = {}, options = {}) {
+  const appConfigPath = join(appPath, APP_CONFIG_FILE);
+
+  // Skip if already exists
+  if (await fileExists(appConfigPath)) {
+    return false;
+  }
+
+  const localSettingsPath = join(appPath, LOCAL_SETTINGS_FILE);
+  let localSettings = {};
+
+  if (await fileExists(localSettingsPath)) {
+    try {
+      localSettings = await readJsonFile(localSettingsPath);
+    } catch {
+      // Ignore parse errors, proceed with overrides only
+    }
+  }
+
+  // Build config using shared function (overrides take precedence)
+  const config = buildConfigFromLocalSettings(localSettings, overrides);
+
+  // Write app-config.yaml
+  await writeFile(appConfigPath, generateYaml(config), 'utf-8');
+
+  if (!options.silent) {
+    console.log(successColor(`  ✓ Created app-config.yaml`));
+  }
+
+  return true;
+}
+
 /**
  * Validate app-config.yaml (standalone command).
  * Returns { valid, errors, warnings, secrets }.
@@ -263,47 +303,62 @@ async function readJsonFile(filePath) {
   }
 }
 
-async function autoCreateFromLocalSettings(appPath, localSettingsPath) {
-  const localSettings = await readJsonFile(localSettingsPath);
-  if (!localSettings?.Values) {
-    console.error(errorColor('  local.settings.json has no Values section.'));
-    process.exit(1);
-  }
-
-  const values = localSettings.Values;
+/**
+ * Build config object from local.settings.json values.
+ * Extracts runtime, version, sku, and allowed configurations (excluding secrets).
+ * @param {Object} localSettings - Parsed local.settings.json object
+ * @param {Object} overrides - Optional overrides { runtime, version, sku }
+ * @returns {Object} Config object ready for generateYaml()
+ */
+export function buildConfigFromLocalSettings(localSettings, overrides = {}) {
+  const values = localSettings?.Values || {};
   const secrets = detectSecretsInFlatValues(values);
-  const nonSecretKeys = Object.keys(values).filter(k => !secrets.has(k));
 
   // Build structured config
   const config = {};
 
-  // Extract runtime
-  const runtime = values.FUNCTIONS_WORKER_RUNTIME;
+  // Extract runtime (CLI override takes precedence)
+  const runtime = overrides.runtime || values.FUNCTIONS_WORKER_RUNTIME;
   if (runtime) {
     config.runtime = { name: runtime };
-    // Check for runtime version in env or values
-    const version = values.FUNCTIONS_WORKER_RUNTIME_VERSION;
+    // Check for runtime version (CLI override takes precedence)
+    const version = overrides.version || values.FUNCTIONS_WORKER_RUNTIME_VERSION;
     if (version) config.runtime.version = version;
   }
 
-  // Extract targetSku from local settings (non-standard but some users set it)
-  if (localSettings.TargetSku) {
-    config.local = { targetSku: localSettings.TargetSku };
+  // Extract targetSku (CLI override takes precedence)
+  const sku = overrides.sku || localSettings.TargetSku;
+  if (sku) {
+    config.local = { targetSku: sku };
   }
 
   // Remaining non-secret, non-structured values → configurations
   const structuredEnvVars = new Set(Object.values(STRUCTURED_FIELDS).map(s => s.envVar));
   const configEntries = {};
-  for (const key of nonSecretKeys) {
+  for (const [key, val] of Object.entries(values)) {
     if (structuredEnvVars.has(key)) continue; // Already mapped structurally
+    if (secrets.has(key)) continue; // Skip secrets
     if (ALLOWED_CONFIGURATIONS.has(key)) {
-      configEntries[key] = values[key];
+      configEntries[key] = val;
     }
   }
   if (Object.keys(configEntries).length > 0) {
     config.configurations = configEntries;
   }
 
+  return config;
+}
+
+async function autoCreateFromLocalSettings(appPath, localSettingsPath) {
+  const localSettings = await readJsonFile(localSettingsPath);
+  if (!localSettings?.Values) {
+    console.error(errorColor('  local.settings.json has no Values section.'));
+    process.exit(1);
+  }
+
+  const config = buildConfigFromLocalSettings(localSettings);
+  const secrets = detectSecretsInFlatValues(localSettings.Values);
+
   // Write app-config.yaml
   const yaml = generateYaml(config);
   const appConfigPath = join(appPath, APP_CONFIG_FILE);
@@ -347,7 +402,6 @@ async function interactiveCreate(appPath) {
     local: { targetSku: 'flex' },
     runtime: { name: runtime },
     configurations: {
-      AzureWebJobsFeatureFlags: 'EnableWorkerIndexing',
     },
   };
 
@@ -372,7 +426,7 @@ async function interactiveCreate(appPath) {
   return config;
 }
 
-function generateYaml(config) {
+export function generateYaml(config) {
   const lines = [
     '# Azure Functions App Configuration',
     '# Commit this to source control. Do NOT put secrets here.',
@@ -413,7 +467,7 @@ function generateYaml(config) {
  * Detect which keys in a flat values map are secrets (for migration).
  * Returns a Set of secret key names.
  */
-function detectSecretsInFlatValues(values) {
+export function detectSecretsInFlatValues(values) {
   const secretKeys = new Set();
   const secretKeyPatterns = [
     /ConnectionString$/i,