@open-mercato/cli 0.7.1-develop.7203.1.9396450b78 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/cli",
-  "version": "0.7.1-develop.7203.1.9396450b78",
+  "version": "0.8.0",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,9 +60,9 @@
     "@mikro-orm/decorators": "^7.1.14",
     "@mikro-orm/migrations": "^7.1.14",
     "@mikro-orm/postgresql": "^7.1.14",
-    "@open-mercato/queue": "0.7.1-develop.7203.1.9396450b78",
-    "@open-mercato/shared": "0.7.1-develop.7203.1.9396450b78",
-    "@open-mercato/telemetry": "0.7.1-develop.7203.1.9396450b78",
+    "@open-mercato/queue": "0.8.0",
+    "@open-mercato/shared": "0.8.0",
+    "@open-mercato/telemetry": "0.8.0",
     "cross-spawn": "^7.0.6",
     "pg": "8.23.0",
     "semver": "^7.8.5",
@@ -73,10 +73,10 @@
     "typescript-js": "npm:typescript@6.0.3"
   },
   "peerDependencies": {
-    "@open-mercato/shared": "0.7.1-develop.7203.1.9396450b78"
+    "@open-mercato/shared": "0.8.0"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.7.1-develop.7203.1.9396450b78",
+    "@open-mercato/shared": "0.8.0",
     "@types/jest": "^30.0.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.12"
@@ -88,6 +88,5 @@
     "type": "git",
     "url": "https://github.com/open-mercato/open-mercato",
     "directory": "packages/cli"
-  },
-  "stableVersion": "0.7.0"
+  }
 }

package/src/lib/generators/__tests__/agent-files-extension.test.ts

@@ -474,4 +474,122 @@ describe('createAgentFilesExtension', () => {
     )
     expect(manifest).toContain('export const fileAgentDescriptors: FileAgentDescriptor[] = []')
   })
+
+  describe('standalone app layout', () => {
+    /**
+     * A scaffolded app has no `packages/` tree and no `docker/opencode/` before
+     * the first generate, so the legacy `findRepoRoot` walk-up could never
+     * resolve and the extension silently emitted nothing. With a resolver
+     * reporting `isMonorepo() === false` the artifacts land in the app instead.
+     */
+    function makeStandaloneFixture(): { appDir: string; appBase: string; pkgBase: string } {
+      const appDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-files-standalone-'))
+      const appBase = path.join(appDir, 'src', 'modules', 'agent_examples')
+      const pkgBase = path.join(
+        appDir,
+        'node_modules',
+        '@open-mercato',
+        'enterprise',
+        'dist',
+        'modules',
+        'agent_examples',
+      )
+      const agentDir = path.join(appBase, 'agents', 'deals_health_check')
+      fs.mkdirSync(agentDir, { recursive: true })
+      fs.writeFileSync(
+        path.join(agentDir, 'AGENT.md'),
+        [
+          '---',
+          'id: deals.health_check',
+          'label: Deal health check',
+          'description: Assess a deal.',
+          '---',
+          'You assess a deal.',
+        ].join('\n'),
+        'utf8',
+      )
+      fs.writeFileSync(
+        path.join(agentDir, 'OUTCOME.md'),
+        [
+          '---',
+          'kind: proposal',
+          '---',
+          '```json',
+          JSON.stringify({
+            type: 'object',
+            required: ['confidence'],
+            properties: { confidence: { type: 'number' } },
+          }),
+          '```',
+        ].join('\n'),
+        'utf8',
+      )
+      return { appDir, appBase, pkgBase }
+    }
+
+    function standaloneResolver(appDir: string) {
+      return {
+        isMonorepo: () => false,
+        getRootDir: () => appDir,
+        getAppDir: () => appDir,
+        getOutputDir: () => path.join(appDir, '.mercato', 'generated'),
+      }
+    }
+
+    let appDir = ''
+    afterEach(() => {
+      if (appDir) fs.rmSync(appDir, { recursive: true, force: true })
+      appDir = ''
+    })
+
+    it('writes the manifest to .mercato/generated and agents under the app docker/ dir', () => {
+      const fixture = makeStandaloneFixture()
+      appDir = fixture.appDir
+
+      const extension = createAgentFilesExtension(standaloneResolver(fixture.appDir))
+      extension.scanModule(createScanContext('agent_examples', fixture.appBase, fixture.pkgBase))
+      extension.generateOutput()
+
+      // The manifest lands in the generated output dir that
+      // `findGeneratedFile()` probes as `<cwd>/.mercato/generated/<file>`.
+      const manifestPath = path.join(
+        fixture.appDir,
+        '.mercato',
+        'generated',
+        'file-agents.generated.ts',
+      )
+      expect(fs.existsSync(manifestPath)).toBe(true)
+      expect(fs.readFileSync(manifestPath, 'utf8')).toContain('id: "deals.health_check"')
+
+      // It must NOT write into node_modules, which yarn install rewrites.
+      expect(
+        fs.existsSync(path.join(fixture.appDir, 'node_modules', '@open-mercato', 'enterprise', 'src')),
+      ).toBe(false)
+
+      const dockerFile = path.join(
+        fixture.appDir,
+        'docker',
+        'opencode',
+        'agents',
+        'deals_health_check.md',
+      )
+      expect(fs.existsSync(dockerFile)).toBe(true)
+      expect(fs.readFileSync(dockerFile, 'utf8')).toContain('mode: primary')
+    })
+
+    it('warns instead of silently dropping agents when no output root resolves', () => {
+      const fixture = makeStandaloneFixture()
+      appDir = fixture.appDir
+      const warn = jest.spyOn(console, 'warn').mockImplementation(() => {})
+
+      // No resolver AND no in-repo markers: the legacy walk-up returns null.
+      const extension = createAgentFilesExtension()
+      extension.scanModule(createScanContext('agent_examples', fixture.appBase, fixture.pkgBase))
+      const output = extension.generateOutput()
+
+      expect(output.size).toBe(0)
+      expect(warn).toHaveBeenCalledWith(expect.stringContaining('Could not resolve an output root'))
+      warn.mockRestore()
+    })
+  })
 })

package/src/lib/generators/extensions/agent-files.ts

@@ -4,6 +4,18 @@ import { countTokens } from '@open-mercato/shared/lib/ai/token-count'
 import type { GeneratorExtension, ModuleScanContext } from '../extension'
 import { resolveStandaloneSourceMirrorBase } from '../scanner'
 
+/**
+ * The slice of `PackageResolver` this extension needs. Kept structural (rather
+ * than importing the full interface) so the extension stays testable with a
+ * literal and carries no dependency on the resolver module.
+ */
+export type AgentFilesResolver = {
+  isMonorepo(): boolean
+  getRootDir(): string
+  getAppDir(): string
+  getOutputDir(): string
+}
+
 /**
  * Generator extension for the `agents/<id>/` file-defined-agent convention
  * (AGENT.md + OUTCOME.md). For every enabled module it scans the module's
@@ -839,6 +851,62 @@ function findRepoRoot(start: string): string | null {
   return null
 }
 
+/**
+ * Where this extension's three artifacts land. The two layouts differ because a
+ * standalone app has no `packages/` tree to host the manifest: the enterprise
+ * module lives under `node_modules/`, which `yarn install` rewrites.
+ *
+ * | Artifact  | Monorepo                                                   | Standalone                                |
+ * |-----------|------------------------------------------------------------|-------------------------------------------|
+ * | manifest  | `packages/enterprise/src/modules/agent_orchestrator/generated/` | `<app>/.mercato/generated/`            |
+ * | agents/   | `<repo>/docker/opencode/agents/`                            | `<app>/docker/opencode/agents/`           |
+ * | skills/   | `<repo>/docker/opencode/skills/`                            | `<app>/docker/opencode/skills/`           |
+ *
+ * The standalone manifest sits in the generated output dir that
+ * `findGeneratedFile()` already probes (`generated-registry-loader.ts` resolves
+ * `<cwd>/.mercato/generated/<file>` for exactly this case), so the runtime
+ * loader reaches it with no new resolution logic. It is regenerated on every
+ * `yarn generate`, which both `scripts/dev.mjs` setup and
+ * `docker/scripts/init-or-migrate.sh` run before the app boots.
+ */
+type AgentFilesTargets = {
+  manifestPath: string
+  dockerAgentsDir: string
+  dockerSkillsDir: string
+}
+
+function resolveAgentFilesTargets(
+  resolver: AgentFilesResolver | undefined,
+  fallbackRepoRoot: string | null,
+): AgentFilesTargets | null {
+  if (resolver && !resolver.isMonorepo()) {
+    const appDir = resolver.getAppDir()
+    return {
+      manifestPath: path.join(resolver.getOutputDir(), 'file-agents.generated.ts'),
+      dockerAgentsDir: path.join(appDir, 'docker', 'opencode', 'agents'),
+      dockerSkillsDir: path.join(appDir, 'docker', 'opencode', 'skills'),
+    }
+  }
+  // Monorepo. Prefer the resolver's root, falling back to the walk-up probe so
+  // unit tests that construct the extension without a resolver keep working.
+  const repoRoot = resolver?.getRootDir() ?? fallbackRepoRoot
+  if (!repoRoot) return null
+  return {
+    manifestPath: path.join(
+      repoRoot,
+      'packages',
+      'enterprise',
+      'src',
+      'modules',
+      'agent_orchestrator',
+      'generated',
+      'file-agents.generated.ts',
+    ),
+    dockerAgentsDir: path.join(repoRoot, 'docker', 'opencode', 'agents'),
+    dockerSkillsDir: path.join(repoRoot, 'docker', 'opencode', 'skills'),
+  }
+}
+
 function listAgentDirs(agentsBase: string): string[] {
   if (!fs.existsSync(agentsBase)) return []
   return fs
@@ -1125,7 +1193,7 @@ export const fileAgentDescriptors: FileAgentDescriptor[] = [${
 `
 }
 
-export function createAgentFilesExtension(): GeneratorExtension {
+export function createAgentFilesExtension(resolver?: AgentFilesResolver): GeneratorExtension {
   const discovered: DiscoveredAgent[] = []
   const seenIds = new Set<string>()
   let repoRoot: string | null = null
@@ -1238,9 +1306,22 @@ export function createAgentFilesExtension(): GeneratorExtension {
     generateOutput() {
       const sorted = [...discovered].sort((a, b) => a.id.localeCompare(b.id))
 
-      if (!repoRoot) {
-        // No module roots resolved to a repo (e.g. an isolated unit test). Skip
+      const targets = resolveAgentFilesTargets(resolver, repoRoot)
+
+      if (!targets) {
+        // No layout resolved (e.g. an isolated unit test constructing the
+        // extension without a resolver and without in-repo module roots). Skip
         // the fs side effect; the empty-Map return keeps the contract intact.
+        // Stay silent only when there is nothing to emit — otherwise the run
+        // would drop real agents without saying so (the pre-2026-09 behaviour).
+        if (sawOrchestratorModule || sorted.length > 0) {
+          console.warn(
+            '[agent-files] Could not resolve an output root, so the file-agent manifest and ' +
+              'docker/opencode/{agents,skills} were NOT written. ' +
+              `Discovered ${sorted.length} file agent(s). ` +
+              'In a standalone app this means the generator ran without a package resolver.',
+          )
+        }
         return new Map<string, string>()
       }
 
@@ -1253,20 +1334,10 @@ export function createAgentFilesExtension(): GeneratorExtension {
         return new Map<string, string>()
       }
 
-      const manifestPath = path.join(
-        repoRoot,
-        'packages',
-        'enterprise',
-        'src',
-        'modules',
-        'agent_orchestrator',
-        'generated',
-        'file-agents.generated.ts',
-      )
+      const { manifestPath, dockerAgentsDir, dockerSkillsDir } = targets
       fs.mkdirSync(path.dirname(manifestPath), { recursive: true })
       fs.writeFileSync(manifestPath, renderManifest(sorted), 'utf8')
 
-      const dockerAgentsDir = path.join(repoRoot, 'docker', 'opencode', 'agents')
       fs.mkdirSync(dockerAgentsDir, { recursive: true })
       const desiredFiles = new Map<string, string>()
       for (const agent of sorted) {
@@ -1292,7 +1363,6 @@ export function createAgentFilesExtension(): GeneratorExtension {
       // remove stale skill dirs not in the current desired set. Sub-agents
       // (Phase 4) may carry their own skills too, so flatten them in.
       const allAgents = sorted.flatMap((agent) => [agent, ...agent.subAgentsContent])
-      const dockerSkillsDir = path.join(repoRoot, 'docker', 'opencode', 'skills')
       // The synthetic `__agent_tools__` skill only carries an agent's local
       // `tools/*.ts` sources (run via `run_skill_script`); it has no instructions
       // and MUST NOT be emitted as a native OpenCode skill (OpenCode requires a

package/src/lib/generators/extensions/index.ts

@@ -1,5 +1,5 @@
 import type { GeneratorExtension } from '../extension'
-import { createAgentFilesExtension } from './agent-files'
+import { createAgentFilesExtension, type AgentFilesResolver } from './agent-files'
 import { createAiAgentsExtension } from './ai-agents'
 import { createAiToolsExtension } from './ai-tools'
 import { createAnalyticsExtension } from './analytics'
@@ -19,14 +19,19 @@ import { createSearchExtension } from './search'
 import { createTranslatableFieldsExtension } from './translatable-fields'
 import { createWorkflowsExtension } from './workflows'
 
-export function loadGeneratorExtensions(): GeneratorExtension[] {
+/**
+ * `resolver` is optional so existing callers and unit tests keep working; the
+ * agent-files extension uses it to tell a monorepo checkout from a standalone
+ * app when choosing where to write its artifacts.
+ */
+export function loadGeneratorExtensions(resolver?: AgentFilesResolver): GeneratorExtension[] {
   return [
     createSearchExtension(),
     createNotificationsExtension(),
     createMessagesExtension(),
     createAiToolsExtension(),
     createAiAgentsExtension(),
-    createAgentFilesExtension(),
+    createAgentFilesExtension(resolver),
     createEventsExtension(),
     createAnalyticsExtension(),
     createTranslatableFieldsExtension(),

package/src/lib/generators/module-registry.ts

@@ -3591,7 +3591,7 @@ async function generateModuleRegistryFromDiscovery(options: ModuleRegistryRender
   const commandLoadersChecksumFile = path.join(outputDir, 'command-loaders.generated.checksum')
 
   const enabled = discovery.enabled
-  const extensions = loadGeneratorExtensions()
+  const extensions = loadGeneratorExtensions(resolver)
 
   // Pre-pass: collect generator plugins from each enabled module's generators.ts
   const pluginRegistry = new Map<string, import('@open-mercato/shared/modules/generators').GeneratorPlugin>()