@xyd-js/opencli2go 0.1.0-build.0

package/__fixtures__/4.body-flatten/input.json

@@ -0,0 +1,153 @@
+{
+  "opencli": "1.0.0",
+  "info": {
+    "title": "chat-api",
+    "version": "1.0.0"
+  },
+  "x-openapi": {
+    "servers": [
+      "https://api.chat.test/v1"
+    ],
+    "security": [
+      {
+        "type": "http",
+        "kind": "bearer",
+        "envVar": "CHAT_API_API_KEY",
+        "scheme": "bearer"
+      }
+    ]
+  },
+  "commands": [
+    {
+      "name": "chat",
+      "commands": [
+        {
+          "name": "completions",
+          "commands": [
+            {
+              "name": "create",
+              "description": "Creates a model response for the given chat conversation.",
+              "options": [
+                {
+                  "name": "model",
+                  "group": "body",
+                  "required": true,
+                  "description": "ID of the model to use.",
+                  "arguments": [
+                    {
+                      "name": "string",
+                      "acceptedValues": [
+                        "gpt-4o",
+                        "gpt-4o-mini",
+                        "o3"
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "name": "messages",
+                  "group": "body",
+                  "required": true,
+                  "description": "A list of messages comprising the conversation.",
+                  "arguments": [
+                    {
+                      "name": "json",
+                      "arity": {
+                        "minimum": 0
+                      }
+                    }
+                  ]
+                },
+                {
+                  "name": "temperature",
+                  "group": "body",
+                  "description": "Sampling temperature.",
+                  "arguments": [
+                    {
+                      "name": "number"
+                    }
+                  ]
+                },
+                {
+                  "name": "stop",
+                  "group": "body",
+                  "arguments": [
+                    {
+                      "name": "string",
+                      "arity": {
+                        "minimum": 0
+                      }
+                    }
+                  ]
+                },
+                {
+                  "name": "stream",
+                  "group": "body"
+                },
+                {
+                  "name": "response-format",
+                  "group": "body",
+                  "arguments": [
+                    {
+                      "name": "json"
+                    }
+                  ]
+                }
+              ],
+              "x-openapi": {
+                "method": "post",
+                "path": "/chat/completions",
+                "operationId": "createChatCompletion",
+                "contentType": "application/json",
+                "body": {
+                  "style": "flatten",
+                  "contentType": "application/json",
+                  "properties": [
+                    {
+                      "name": "model",
+                      "from": "option:model",
+                      "jsonPath": "model",
+                      "encoding": "string",
+                      "required": true
+                    },
+                    {
+                      "name": "messages",
+                      "from": "option:messages",
+                      "jsonPath": "messages",
+                      "encoding": "array",
+                      "required": true
+                    },
+                    {
+                      "name": "temperature",
+                      "from": "option:temperature",
+                      "jsonPath": "temperature",
+                      "encoding": "number"
+                    },
+                    {
+                      "name": "stop",
+                      "from": "option:stop",
+                      "jsonPath": "stop",
+                      "encoding": "array"
+                    },
+                    {
+                      "name": "stream",
+                      "from": "option:stream",
+                      "jsonPath": "stream",
+                      "encoding": "boolean"
+                    },
+                    {
+                      "name": "response_format",
+                      "from": "option:response-format",
+                      "jsonPath": "response_format",
+                      "encoding": "json"
+                    }
+                  ]
+                }
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

package/__fixtures__/4.body-flatten/output/cmd/chat-api/main.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+
+	"example.com/chat-api/pkg/cmd"
+	"github.com/urfave/cli/v3"
+)
+
+func main() {
+	app := &cli.Command{
+		Name: "chat-api",
+		Version: "1.0.0",
+		Commands: []*cli.Command{
+			cmd.NewChatCommand(),
+		},
+	}
+	if err := app.Run(context.Background(), os.Args); err != nil {
+		log.Fatal(err)
+	}
+}

package/__fixtures__/4.body-flatten/output/go.mod

@@ -0,0 +1,3 @@
+module example.com/chat-api
+
+go 1.22

package/__fixtures__/4.body-flatten/output/internal/runtime/config.go

@@ -0,0 +1,23 @@
+package runtime
+
+import (
+	"net/http"
+	"os"
+)
+
+const defaultBaseURL = "https://api.chat.test/v1"
+
+// BaseURL returns the API base URL, overridable via CHAT_API_BASE_URL.
+func BaseURL() string {
+	if v := os.Getenv("CHAT_API_BASE_URL"); v != "" {
+		return v
+	}
+	return defaultBaseURL
+}
+
+// applyAuth attaches credentials read from the environment to the request.
+func applyAuth(req *http.Request) {
+	if v := os.Getenv("CHAT_API_API_KEY"); v != "" {
+		req.Header.Set("Authorization", "Bearer "+v)
+	}
+}

package/__fixtures__/4.body-flatten/output/internal/runtime/runtime.go

@@ -0,0 +1,64 @@
+package runtime
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+// Request is a generic API request assembled by a generated command handler.
+type Request struct {
+	Method  string
+	Path    string
+	Query   url.Values
+	Headers http.Header
+	Body    []byte
+}
+
+// Do executes the request against the configured base URL (applying auth) and
+// prints the response body to stdout.
+func Do(ctx context.Context, req Request) error {
+	endpoint := strings.TrimRight(BaseURL(), "/") + req.Path
+	if len(req.Query) > 0 {
+		endpoint += "?" + req.Query.Encode()
+	}
+
+	var body io.Reader
+	if len(req.Body) > 0 {
+		body = bytes.NewReader(req.Body)
+	}
+
+	httpReq, err := http.NewRequestWithContext(ctx, req.Method, endpoint, body)
+	if err != nil {
+		return err
+	}
+	for key, values := range req.Headers {
+		for _, value := range values {
+			httpReq.Header.Add(key, value)
+		}
+	}
+	if len(req.Body) > 0 && httpReq.Header.Get("Content-Type") == "" {
+		httpReq.Header.Set("Content-Type", "application/json")
+	}
+	applyAuth(httpReq)
+
+	resp, err := http.DefaultClient.Do(httpReq)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	out, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	fmt.Println(string(out))
+	if resp.StatusCode >= 400 {
+		return fmt.Errorf("request failed: %s", resp.Status)
+	}
+	return nil
+}

package/__fixtures__/4.body-flatten/output/pkg/cmd/chat.go

@@ -0,0 +1,90 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+
+	"example.com/chat-api/internal/runtime"
+	"github.com/urfave/cli/v3"
+)
+
+func NewChatCommand() *cli.Command {
+	return &cli.Command{
+		Name: "chat",
+		Commands: []*cli.Command{
+			&cli.Command{
+				Name: "completions",
+				Commands: []*cli.Command{
+					&cli.Command{
+						Name: "create",
+						Usage: "Creates a model response for the given chat conversation.",
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name: "model",
+								Usage: "ID of the model to use.",
+								Required: true,
+							},
+							&cli.StringSliceFlag{
+								Name: "messages",
+								Usage: "A list of messages comprising the conversation.",
+								Required: true,
+							},
+							&cli.FloatFlag{
+								Name: "temperature",
+								Usage: "Sampling temperature.",
+							},
+							&cli.StringSliceFlag{
+								Name: "stop",
+							},
+							&cli.BoolFlag{
+								Name: "stream",
+							},
+							&cli.StringFlag{
+								Name: "response-format",
+							},
+						},
+						Action: handleChatCompletionsCreate,
+					},
+				},
+			},
+		},
+	}
+}
+
+func handleChatCompletionsCreate(ctx context.Context, cmd *cli.Command) error {
+	path := "/chat/completions"
+	body := map[string]any{}
+	if cmd.IsSet("model") {
+		body["model"] = cmd.String("model")
+	}
+	if cmd.IsSet("messages") {
+		body["messages"] = cmd.StringSlice("messages")
+	}
+	if cmd.IsSet("temperature") {
+		body["temperature"] = cmd.Float("temperature")
+	}
+	if cmd.IsSet("stop") {
+		body["stop"] = cmd.StringSlice("stop")
+	}
+	if cmd.IsSet("stream") {
+		body["stream"] = cmd.Bool("stream")
+	}
+	if cmd.IsSet("response-format") {
+		raw := cmd.String("response-format")
+		var v any
+		if err := json.Unmarshal([]byte(raw), &v); err != nil {
+			v = raw
+		}
+		body["response_format"] = v
+	}
+	bodyBytes, err := json.Marshal(body)
+	if err != nil {
+		return err
+	}
+	req := runtime.Request{
+		Method: "POST",
+		Path: path,
+		Body: bodyBytes,
+	}
+	return runtime.Do(ctx, req)
+}

package/__tests__/docs.test.ts

@@ -0,0 +1,109 @@
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { beforeAll, describe, expect, it } from 'vitest';
+
+import { opencli2go, writeProject } from '../index';
+
+// Generation-only deps (used when O2G_BUILD_DOCS=1); the regen-guard test below
+// is pure (opencli input.json → go).
+import { deferencedOpenAPI } from '@xyd-js/openapi';
+import { openapi2opencli } from '@xyd-js/openapi2opencli';
+
+const O2G_FIX = path.join(__dirname, '../__fixtures__/-2.complex.openai');
+// The openapi2opencli package owns the vendored spec + the per-method (method, path).
+const A2O = path.join(__dirname, '../../xyd-openapi2opencli');
+const SPEC = path.join(A2O, 'oracle/openai-openapi.yaml');
+const A2O_FIX = path.join(A2O, '__fixtures__/-2.complex.openai');
+
+const BUILD = process.env.O2G_BUILD_DOCS === '1';
+const GO_SMOKE = process.env.O2G_GO_SMOKE === '1';
+
+const cmdFileKey = (files: Record<string, string>) => Object.keys(files).find((k) => k.startsWith('pkg/cmd/'));
+
+/** A minimal, self-contained OpenAPI doc for a single operation. */
+function miniDoc(spec: any, method: string, p: string): any | null {
+  const op = spec.paths?.[p]?.[method];
+  if (!op) return null;
+  return {
+    openapi: spec.openapi || '3.0.3',
+    info: { title: 'openai', version: spec.info?.version || '1.0.0' },
+    servers: spec.servers,
+    security: spec.security,
+    components: spec.components ? { securitySchemes: spec.components.securitySchemes } : undefined,
+    paths: { [p]: { [method]: op } },
+  };
+}
+
+// ---- Generator (opt-in): per-method OpenCLI input + Go output ------------
+describe.runIf(BUILD)('generate opencli → go fixtures (assumed-correct, for review)', () => {
+  it('build __fixtures__/-2.complex.openai/<method>/{input.json, output.go}', async () => {
+    const spec = await deferencedOpenAPI(SPEC);
+    if (!spec) throw new Error(`vendored spec not found at ${SPEC}`);
+
+    let n = 0;
+    for (const dir of fs.readdirSync(A2O_FIX)) {
+      const metaPath = path.join(A2O_FIX, dir, 'input.json');
+      if (!fs.existsSync(metaPath)) continue;
+      const meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+      if (!meta.path || !meta.httpMethod) continue;
+
+      const doc = miniDoc(spec, meta.httpMethod, meta.path);
+      if (!doc) continue;
+
+      const opencli = openapi2opencli(doc, { cliName: 'openai' });
+      const files = opencli2go(opencli);
+      const key = cmdFileKey(files);
+      if (!key) continue;
+
+      const out = path.join(O2G_FIX, dir);
+      fs.mkdirSync(out, { recursive: true });
+      fs.writeFileSync(path.join(out, 'input.json'), `${JSON.stringify(opencli, null, 2)}\n`);
+      fs.writeFileSync(path.join(out, 'output.go'), files[key]);
+      n++;
+    }
+    expect(n).toBeGreaterThan(100);
+  }, 300000);
+});
+
+// ---- Regen guard (offline; pure opencli → go) ----------------------------
+const fixtures = fs.existsSync(O2G_FIX)
+  ? fs.readdirSync(O2G_FIX).filter((d) => fs.existsSync(path.join(O2G_FIX, d, 'input.json')))
+  : [];
+
+describe.skipIf(!fixtures.length || BUILD)('opencli2go docs (opencli → go, regen guard)', () => {
+  for (const dir of fixtures) {
+    it(dir, () => {
+      const opencli = JSON.parse(fs.readFileSync(path.join(O2G_FIX, dir, 'input.json'), 'utf8'));
+      const files = opencli2go(opencli);
+      const key = cmdFileKey(files);
+      expect(key, `no pkg/cmd file generated for ${dir}`).toBeTruthy();
+      const expected = fs.readFileSync(path.join(O2G_FIX, dir, 'output.go'), 'utf8');
+      expect(files[key as string]).toEqual(expected);
+    });
+  }
+});
+
+// ---- Optional: a sample of the generated projects compiles ---------------
+describe.runIf(GO_SMOKE && fixtures.length > 0)('opencli2go docs (go build smoke, sample)', () => {
+  // Spread the sample across resources (alphabetical), not just the first few.
+  const step = Math.max(1, Math.floor(fixtures.length / 8));
+  const sample = fixtures.filter((_, i) => i % step === 0).slice(0, 8);
+  for (const dir of sample) {
+    it(`builds ${dir}`, async () => {
+      const opencli = JSON.parse(fs.readFileSync(path.join(O2G_FIX, dir, 'input.json'), 'utf8'));
+      const files = opencli2go(opencli);
+      const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'o2g-docs-'));
+      try {
+        await writeProject(files, tmp);
+        execSync('go mod tidy', { cwd: tmp, stdio: 'pipe' });
+        execSync('go build ./...', { cwd: tmp, stdio: 'pipe' });
+        execSync('go vet ./...', { cwd: tmp, stdio: 'pipe' });
+      } finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+      }
+    }, 120000);
+  }
+});