@frontera-sdk/cli 1.52.27 → 1.52.29

package/src/commands/local/init.ts

@@ -1,26 +1,52 @@
 import { spawnSync } from 'node:child_process'
-import { basename, resolve } from 'node:path'
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs'
+import { basename, join, resolve } from 'node:path'
 
 import { UsageError } from '../../errors'
 import { writeHarnessFiles } from '../../harness'
 import { slugify } from '../../local/local-project'
 import { readProviderSetup } from '../../local/local-providers'
+import { readLink } from '../../local/local-sync-link'
+import { generateSyntheticData, addMissingBackings, loadScenario, SCENARIO_TEMPLATE } from '../../local/local-synthetic-data'
 import { writeSolutionScaffold } from '../../local/local-scaffold'
-import { flagBool, type Command } from '../types'
+import { flagBool, flagString, type Command, type CommandContext } from '../types'
+import { localSync } from './sync'
 
 /**
  * `frontera local init [name]`: a new project in the layout `local dev`
  * applies, like `supabase init`. Into `<name>/`, or this folder when no name
  * is given; files already there are kept unless `--force`.
+ *
+ * `--from-workspace` starts it from a platform workspace instead of the
+ * examples: the project files, the link (keys on stdin, as `sync connect`
+ * takes them, or the link the folder already has), a pull of the chosen
+ * kinds, and sample data for the pulled Blueprint. `frontera local start`
+ * then runs it, and `local dev` applies what was pulled.
  */
 export const localInit: Command = {
   meta: {
     noun: 'local',
     verb: 'init',
     args: [{ name: 'name', required: false, description: 'folder to create the project in (default: this folder)' }],
-    flags: { force: 'boolean', 'no-install': 'boolean' },
+    flags: {
+      force: 'boolean',
+      'no-install': 'boolean',
+      'from-workspace': 'boolean',
+      platform: 'string',
+      'workspace-key': 'string',
+      'org-key': 'string',
+      kinds: 'string',
+      'no-sample-data': 'boolean',
+      rows: 'string',
+      seed: 'string',
+    },
     summary: 'Create a project: an Agent with a test case, a workflow, a Function and a Blueprint object type with its data',
-    examples: ['frontera local init claims-intake', 'frontera local init', 'frontera local init acme-support --no-install'],
+    examples: [
+      'frontera local init claims-intake',
+      'frontera local init',
+      'frontera local init acme-support --no-install',
+      'frontera local init acme --from-workspace --platform $URL --workspace-key -',
+    ],
     offline: true,
     internal: true,
   },
@@ -32,12 +58,21 @@ export const localInit: Command = {
     if (!name) throw new UsageError('the project needs a name with letters or digits', 'frontera local init <name>')
 
     const force = flagBool(ctx, 'force')
+    const fromWorkspace = flagBool(ctx, 'from-workspace')
+    if (fromWorkspace && existsSync(target) && !force) {
+      // A folder with files in it is someone's work: start from a workspace in an empty one, or link an existing project.
+      const present = readdirSync(target).filter((f) => !f.startsWith('.') || f === '.frontera')
+      const project = present.some((f) => f === 'frontera.yaml' || f === 'frontera.solution.yaml')
+      if (present.length && !project) throw new UsageError(`${target} is not empty`, 'start from a workspace in a new or empty folder, or connect this project with `frontera local sync connect`')
+    }
+    mkdirSync(target, { recursive: true })
     // The CLI skill and CLAUDE.md, so a coding agent here knows the CLI. First,
     // so the scaffold's AGENTS.md (the generic one plus this project's loop)
     // replaces the generic one rather than the other way round.
     const harness = writeHarnessFiles(target, { force })
-    // The starter Agent takes the model the FDE chose for new Agents (`frontera local model-default`).
-    const scaffold = writeSolutionScaffold(target, name, force, { agentModel: readProviderSetup().defaults.agentModel })
+    // The starter Agent takes the model the FDE chose for new Agents (`frontera local model-default`);
+    // a project started from a workspace gets the workspace's Agents instead of the examples.
+    const scaffold = writeSolutionScaffold(target, name, force, { agentModel: readProviderSetup().defaults.agentModel, samples: !fromWorkspace })
     const listed = (files: string[]) => files.filter((f) => !f.startsWith('vendor/'))
     const written = [...new Set(listed([...scaffold.written, ...harness.written]))]
     const skipped = listed([...scaffold.skipped, ...harness.skipped]).filter((f) => !written.includes(f))
@@ -54,15 +89,24 @@ export const localInit: Command = {
       }
     }
 
+    const pulled = fromWorkspace ? await startFromWorkspace(ctx, target) : null
+
     const cd = given ? [`  cd ${given}`] : []
     const sdkWritten = scaffold.written.some((f) => f.startsWith('vendor/'))
     const heading = written.length
       ? `Created the project ${name}`
       : `${name} already has every file${sdkWritten ? '; the vendored Functions SDK was completed' : ''}`
     return {
-      data: { name, path: target, written, skipped, installed },
+      data: { name, path: target, written, skipped, installed, ...(pulled ? { workspace: pulled } : {}) },
       text: [
         heading,
+        ...(pulled
+          ? [
+              pulled.pulled
+                ? `  from ${pulled.workspace}: ${pulled.pulled} items pulled${pulled.sampleRows ? `, ${pulled.sampleRows} sample rows` : ''}`
+                : `  linked to ${pulled.workspace}; see what it has with \`frontera local sync pull --preview\``,
+            ]
+          : []),
         ...written.map((f) => `  + ${f}`),
         ...(written.length && sdkWritten ? ['  + vendor/frontera/ (the Functions SDK)'] : []),
         ...skipped.map((f) => `  · ${f} (exists; --force replaces it)`),
@@ -76,3 +120,40 @@ export const localInit: Command = {
     }
   },
 }
+
+/** Link, pull and fill the new project; each step says what it does, as Forge shows it in a terminal. */
+async function startFromWorkspace(ctx: CommandContext, target: string): Promise<{ workspace: string; pulled: number; sampleRows: number }> {
+  const sub: CommandContext = { ...ctx, cwd: target }
+  const keysGiven = flagString(ctx, 'workspace-key') !== undefined
+  if (keysGiven) {
+    ctx.output.note('Linking the project to the workspace')
+    await localSync.run({ ...sub, positional: ['connect'], flags: { ...ctx.flags } })
+  } else if (!readLink(target)) {
+    throw new UsageError('no workspace to start from', 'pass --platform <url> --workspace-key - with the key on stdin')
+  }
+  const kinds = flagString(ctx, 'kinds') ?? 'blueprint,skills,functions,plugins,knowledge,workflows,agents,evaluations'
+  // `none` links the project and pulls nothing, for someone who picks items next (`local sync pull <kind/name>…`).
+  if (kinds === 'none') {
+    const link = readLink(target)
+    return { workspace: link?.workspaceName ?? link?.workspace ?? 'the workspace', pulled: 0, sampleRows: 0 }
+  }
+  ctx.output.note(`Pulling ${kinds.split(',').join(', ')}`)
+  const pull = (await localSync.run({ ...sub, positional: ['pull'], flags: { kinds } })).data as { pulled: string[]; warnings: string[] }
+  for (const w of pull.warnings) ctx.output.note(`  could not read ${w}`)
+  let sampleRows = 0
+  const wantsData = !flagBool(ctx, 'no-sample-data') && existsSync(join(target, 'blueprint', 'object-types'))
+  if (wantsData) {
+    ctx.output.note('Writing sample data for the Blueprint')
+    const seed = Number(flagString(ctx, 'seed') ?? 7)
+    const scenarioFile = join(target, 'data', 'generate.ts')
+    if (!existsSync(scenarioFile)) {
+      mkdirSync(join(target, 'data'), { recursive: true })
+      writeFileSync(scenarioFile, SCENARIO_TEMPLATE)
+    }
+    addMissingBackings(target)
+    const scenario = await loadScenario(target, seed)
+    sampleRows = generateSyntheticData(target, { rows: Number(flagString(ctx, 'rows') ?? 200), seed, scenario: scenario ?? undefined }).reduce((n, d) => n + d.rows, 0)
+  }
+  const link = readLink(target)
+  return { workspace: link?.workspaceName ?? link?.workspace ?? 'the workspace', pulled: pull.pulled.length, sampleRows }
+}