@biznetgio/neo-app 0.4.18 → 0.4.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biznetgio/neo-app",
-  "version": "0.4.18",
+  "version": "0.4.20",
   "description": "NEO App CLI — one-command agent onboarding, MCP server, and project ops for coding agents (Codex, Claude Code).",
   "type": "module",
   "bin": {

package/src/mcp/tools.js

@@ -105,12 +105,12 @@ export const TOOLS = [
         controlPlane,
         resourceTypes,
         // Verbs this MCP build exposes today (no create-DB/queue/cron/bucket, no costed plan/apply yet).
-        lifecycleVerbs: ['create', 'list', 'get', 'deploy', 'scale', 'logs', 'get_variables', 'set_variable', 'estimate', 'bind', 'unbind', 'run_cron', 'delete', 'list_approvals', 'get_approval', 'get_credit', 'list_templates'],
+        lifecycleVerbs: ['plan', 'apply', 'get_operation', 'create', 'list', 'get', 'deploy', 'scale', 'logs', 'get_variables', 'set_variable', 'estimate', 'bind', 'unbind', 'run_cron', 'delete', 'list_approvals', 'get_approval', 'get_credit', 'list_templates'],
         bindings: { supported: true, targets: ['neo_db', 'neo_queue'], writeOnly: true, note: 'neo_bind_resource injects DATABASE_URL/NATS_URL server-side at deploy; the secret is never returned (handoff 5)' },
         sourceTypes: ['git', 'image', 'dockerfile', 'local', 'template'],
         environments: ['staging', 'production'],
         pricing,
-        costConsent: { estimateAvailable: true, dryRunIncludesCost: true, planApplyEnforced: false, note: 'neo_estimate + deploy dry-run show cost (0.4.16); server-enforced neo_plan_stack / Approve & Create is still TODO (handoff 3.3-3.5)' },
+        costConsent: { estimateAvailable: true, dryRunIncludesCost: true, planApplyEnforced: true, note: 'neo_plan_stack returns a costed immutable plan; neo_apply_stack is server-enforced (hash/expiry/one-shot) so a billable stack requires a reviewed plan (handoff 3.3-3.5)' },
         minClientVersion: pkgVersion(),
         deprecations: [],
       };
@@ -304,6 +304,44 @@ export const TOOLS = [
       return { ...est, priceBook: orgId ? `org:${orgId}` : 'global-defaults' };
     },
   },
+  {
+    name: 'neo_scan_repo',
+    description:
+      'Scan a Git repository and return its deployable components (monorepo-aware): each root directory with a build marker, its detected stack, and a suggested service type + build type. Use it to show the user the component inventory and ask which to deploy — never collapse a monorepo into one service without explicit selection (handoff 6). Read-only; deploys nothing.',
+    mutating: false,
+    schema: {
+      type: 'object',
+      properties: {
+        repoUrl: str('Git repository URL (https://host/owner/repo)'),
+        branch: str('Branch (optional; default the repo default branch)'),
+        gitProviderId: str('Git profile id for a private repo (optional)'),
+      },
+      required: ['repoUrl'],
+    },
+    async call(api, args) {
+      const { data } = await api.post('/api/v1/repos/scan', { repoUrl: args.repoUrl, branch: args.branch, gitProviderId: args.gitProviderId });
+      const subdirs = data?.subdirs || [];
+      const components = subdirs.map((s) => ({
+        path: s.path || '.',
+        name: s.name,
+        stack: s.type, // docker | node | go | python | java | php | ruby | rust | static
+        suggestedServiceType: s.type === 'static' ? 'static_site' : 'web',
+        suggestedBuildType: s.type === 'docker' ? 'dockerfile' : 'railpack',
+        contextDir: s.path || undefined,
+      }));
+      return {
+        repoUrl: args.repoUrl,
+        count: components.length,
+        components,
+        note:
+          components.length > 1
+            ? 'Monorepo: multiple deployable components. Ask the user which to deploy and create each selected one with its `contextDir` — do NOT collapse them into one service (handoff 6). Worker vs web cannot be inferred from the tree alone; confirm the type with the user.'
+            : components.length === 1
+              ? 'One deployable component found.'
+              : 'No deployable component found (no Dockerfile/package.json/go.mod/requirements.txt/index.html/… at any root).',
+      };
+    },
+  },
   {
     name: 'neo_list_templates',
     description: 'List deployable templates (e.g. wordpress, n8n, redis).',
@@ -617,6 +655,93 @@ export const TOOLS = [
       return result(status, data);
     },
   },
+  // --- Costed plan / apply backbone (handoff 3.3-3.5 + 7): plan a whole stack
+  // zero-write, review the cost, then apply with the plan id+hash. The server
+  // enforces the plan (hash/expiry/one-shot) and runs it in dependency order. ---
+  {
+    name: 'neo_plan_stack',
+    description:
+      'Create an immutable, COSTED plan for a whole stack (services + databases/queues/buckets + bindings) WITHOUT creating anything — zero-write (handoff 3.3). Returns planId, planHash, itemized monthly/hourly cost, and ordered phases. Show the cost to the user for approval, then call neo_apply_stack with planId+planHash. The plan expires in 15 minutes.',
+    mutating: false,
+    schema: {
+      type: 'object',
+      properties: {
+        projectId: str('Project id'),
+        environment: { type: 'string', enum: ['staging', 'production'], description: 'REQUIRED — staging or production (never defaulted, handoff §2)' },
+        resources: {
+          type: 'array',
+          description: 'The stack resources. Each needs a unique name + kind (app | database | queue | bucket).',
+          items: {
+            type: 'object',
+            properties: {
+              kind: { type: 'string', enum: ['app', 'database', 'queue', 'bucket'] },
+              name: str('Unique resource name within this stack (bindings reference it)'),
+              serviceType: str('app: web | worker | static_site'),
+              image: str('app: prebuilt image reference'),
+              repoUrl: str('app: git repository URL'),
+              branch: str('app: git branch'),
+              port: int('app: container port'),
+              computeTier: str('app/db/queue: micro | small | medium | large | xlarge'),
+              engine: str('database: postgres | mysql'),
+              version: str('database: engine version, e.g. 16'),
+              volumeSize: str('database: storage size, e.g. 10Gi'),
+              quotaGB: int('bucket: storage quota GB'),
+              region: str('bucket: region'),
+            },
+            required: ['kind', 'name'],
+          },
+        },
+        bindings: {
+          type: 'array',
+          description: 'Wire a database/queue into a consumer app (injected as an env var at deploy, server-side).',
+          items: {
+            type: 'object',
+            properties: {
+              consumer: str('The consumer app resource name'),
+              targetType: { type: 'string', enum: ['neo_db', 'neo_queue'] },
+              target: str('The database/queue resource name'),
+              envKey: str('Env var name (optional; default DATABASE_URL / NATS_URL)'),
+            },
+            required: ['consumer', 'targetType', 'target'],
+          },
+        },
+      },
+      required: ['projectId', 'environment', 'resources'],
+    },
+    async call(api, args) {
+      requireEnv(args.environment);
+      const { projectId, ...body } = args;
+      const { status, data } = await api.post(`/api/v1/projects/${projectId}/plans`, body);
+      return result(status, data);
+    },
+  },
+  {
+    name: 'neo_apply_stack',
+    description:
+      'Apply a planned stack. REQUIRES the planId and the exact planHash from neo_plan_stack — the SERVER rejects a missing, changed, expired, or already-applied plan, so a billable stack can never be created without first creating + reviewing its costed plan (handoff 3.4/3.5, server-enforced approval). Creates resources in dependency order (foundations → services → bindings → deploy) and returns an operationId to poll with neo_get_operation.',
+    mutating: true,
+    schema: {
+      type: 'object',
+      properties: {
+        planId: str('Plan id from neo_plan_stack'),
+        planHash: str('Plan hash from neo_plan_stack — must match exactly (proves you reviewed this plan)'),
+      },
+      required: ['planId', 'planHash'],
+    },
+    async call(api, args) {
+      const { status, data } = await api.post(`/api/v1/plans/${args.planId}/apply`, { planHash: args.planHash });
+      return result(status, data);
+    },
+  },
+  {
+    name: 'neo_get_operation',
+    description: 'Get the status of a stack apply (the operationId/planId from neo_apply_stack): overall status (applying | applied | failed) plus per-resource status (creating | created | deployed | failed). Poll until terminal.',
+    mutating: false,
+    schema: { type: 'object', properties: { operationId: str('Operation id (= plan id from neo_apply_stack)') }, required: ['operationId'] },
+    async call(api, args) {
+      return redactSecrets((await api.get(`/api/v1/plans/${args.operationId}`)).data);
+    },
+  },
   // --- Cleanup (handoff 3.6): MCP can delete every resource type it can reach, so
   // an agent never leaks a resource it created. These are DESTRUCTIVE and permanent;
   // the server hard-deletes the record and tears down the running workload. ---