Improve content success output and post update prompt order

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: ruibaby

src/commands/post/__test__/post-json-entry.spec.ts

@@ -211,6 +211,79 @@ test("tryRunPostCommand imports json by updating an existing post", async () =>
   expect(publishMyPost).toHaveBeenCalledWith({ name: "post-1" });
 });
 
+test("tryRunPostCommand prints import summary with permalink and inspect command", async () => {
+  const stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+
+  const getMyPost = vi.fn().mockRejectedValue({
+    isAxiosError: true,
+    response: { status: 404 },
+  });
+  const createMyPost = vi.fn().mockResolvedValue({
+    data: { metadata: { name: "post-1" } },
+  });
+  const publishMyPost = vi.fn().mockResolvedValue(undefined);
+  ucPostApiState.implementation = {
+    getMyPost,
+    getMyPostDraft: vi.fn(),
+    updateMyPost: vi.fn(),
+    updateMyPostDraft: vi.fn(),
+    createMyPost,
+    publishMyPost,
+    unpublishMyPost: vi.fn(),
+  };
+
+  const getPost = vi.fn().mockResolvedValue({
+    data: {
+      metadata: { name: "post-1" },
+      status: { permalink: "/archives/post-1" },
+    },
+  });
+  const fetchPostHeadContent = vi.fn().mockResolvedValue({
+    data: { raw: "# Halo", content: "<h1>Halo</h1>", rawType: "markdown" },
+  });
+  const runtimeMock = {
+    getClientsForOptions: vi.fn().mockResolvedValue({
+      profile: { baseUrl: "https://example.com/console" },
+      clients: {
+        axios: {},
+        core: {
+          content: {
+            post: {
+              getPost,
+            },
+          },
+        },
+        console: {
+          content: {
+            post: {
+              fetchPostHeadContent,
+            },
+          },
+        },
+      },
+    }),
+  };
+
+  await expect(
+    tryRunPostCommand(
+      [
+        "post",
+        "import-json",
+        "--raw",
+        '{"post":{"metadata":{"name":"post-1"},"spec":{"publish":true}},"content":{"raw":"# Halo","content":"<h1>Halo</h1>","rawType":"markdown"}}',
+      ],
+      runtimeMock as never,
+    ),
+  ).resolves.toBe(true);
+
+  const output = stdoutSpy.mock.calls.map((call) => String(call[0])).join("");
+  expect(output).toContain("Post imported successfully from inline JSON.");
+  expect(output).toContain("\n\nmetadata.name: post-1");
+  expect(output).toContain("metadata.name: post-1");
+  expect(output).toContain("permalink: https://example.com/archives/post-1");
+  expect(output).toContain("inspect: halo post get post-1");
+});
+
 test("tryRunPostCommand rejects invalid inline json", async () => {
   const runtimeMock = {
     getClientsForOptions: vi.fn(),

src/commands/post/__test__/post-markdown-entry.spec.ts

@@ -270,3 +270,90 @@ halo:
     await rm(tempDir, { recursive: true, force: true });
   }
 });
+
+test("tryRunPostCommand prints markdown import summary when permalink is unavailable", async () => {
+  const stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+
+  const tempDir = await mkdtemp(join(tmpdir(), "halo-post-import-markdown-summary-"));
+  const filePath = join(tempDir, "hello-halo.md");
+
+  try {
+    await writeFile(
+      filePath,
+      `---
+title: Hello Halo
+---
+# Hello Halo
+`,
+      "utf8",
+    );
+
+    const createMyPost = vi.fn().mockResolvedValue({
+      data: { metadata: { name: "post-1" } },
+    });
+
+    ucPostApiState.implementation = {
+      createMyPost,
+      publishMyPost: vi.fn().mockResolvedValue(undefined),
+      unpublishMyPost: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const getPost = vi.fn().mockResolvedValue({
+      data: {
+        metadata: { name: "post-1" },
+        spec: {
+          title: "Hello Halo",
+          slug: "hello-halo",
+          excerpt: { autoGenerate: true },
+          cover: "",
+          categories: [],
+          tags: [],
+          publish: false,
+        },
+        status: {},
+      },
+    });
+    const fetchPostHeadContent = vi.fn().mockResolvedValue({
+      data: {
+        raw: "# Hello Halo",
+        content: "<h1>Hello Halo</h1>\n",
+        rawType: "markdown",
+      },
+    });
+    const runtimeMock = {
+      getClientsForOptions: vi.fn().mockResolvedValue({
+        profile: { baseUrl: "https://example.com" },
+        clients: {
+          axios: {},
+          core: {
+            content: {
+              post: {
+                getPost,
+              },
+            },
+          },
+          console: {
+            content: {
+              post: {
+                fetchPostHeadContent,
+              },
+            },
+          },
+        },
+      }),
+    };
+
+    await expect(
+      tryRunPostCommand(["post", "import-markdown", "--file", filePath], runtimeMock as never),
+    ).resolves.toBe(true);
+
+    const output = stdoutSpy.mock.calls.map((call) => String(call[0])).join("");
+    expect(output).toContain(`Markdown post imported successfully from ${filePath}.`);
+    expect(output).toContain("\n\nmetadata.name: post-1");
+    expect(output).toContain("metadata.name: post-1");
+    expect(output).toContain("permalink: (not available until published)");
+    expect(output).toContain("inspect: halo post get post-1");
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});

src/commands/post/__test__/post-update-prompt-order.spec.ts

@@ -0,0 +1,161 @@
+import { afterEach, expect, test, vi } from "vitest";
+
+const ucPostApiState = vi.hoisted(() => ({
+  implementation: {} as Record<string, unknown>,
+}));
+
+const promptState = vi.hoisted(() => ({
+  input: vi.fn(),
+  confirm: vi.fn(),
+  checkbox: vi.fn(),
+}));
+
+vi.mock("@halo-dev/api-client", async () => {
+  const actual =
+    await vi.importActual<typeof import("@halo-dev/api-client")>("@halo-dev/api-client");
+
+  return {
+    ...actual,
+    PostV1alpha1UcApi: vi.fn(function MockPostV1alpha1UcApi() {
+      return ucPostApiState.implementation;
+    }),
+  };
+});
+
+vi.mock("@inquirer/prompts", () => ({
+  input: promptState.input,
+  confirm: promptState.confirm,
+  checkbox: promptState.checkbox,
+}));
+
+import { tryRunPostCommand } from "../index.js";
+
+const originalStdinTty = process.stdin.isTTY;
+const originalStdoutTty = process.stdout.isTTY;
+
+afterEach(() => {
+  ucPostApiState.implementation = {};
+  promptState.input.mockReset();
+  promptState.confirm.mockReset();
+  promptState.checkbox.mockReset();
+  vi.restoreAllMocks();
+  Object.defineProperty(process.stdin, "isTTY", { value: originalStdinTty, configurable: true });
+  Object.defineProperty(process.stdout, "isTTY", { value: originalStdoutTty, configurable: true });
+});
+
+test("tryRunPostCommand prompts title and slug before categories and tags on update", async () => {
+  Object.defineProperty(process.stdin, "isTTY", { value: true, configurable: true });
+  Object.defineProperty(process.stdout, "isTTY", { value: true, configurable: true });
+  vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+
+  const order: string[] = [];
+
+  promptState.input.mockImplementation(async (config: { message: string }) => {
+    order.push(config.message);
+
+    if (config.message === "Post title") {
+      return "Updated Halo";
+    }
+
+    if (config.message === "Post slug") {
+      return "updated-halo";
+    }
+
+    if (config.message === "Post content") {
+      return "# Updated Halo";
+    }
+
+    return "";
+  });
+
+  promptState.confirm.mockImplementation(async (config: { message: string }) => {
+    order.push(config.message);
+    return false;
+  });
+
+  promptState.checkbox.mockImplementation(async (config: { message: string }) => {
+    order.push(config.message);
+    return [];
+  });
+
+  const getMyPost = vi
+    .fn()
+    .mockResolvedValueOnce({
+      data: {
+        metadata: { name: "post-1" },
+        spec: {
+          title: "Hello Halo",
+          slug: "hello-halo",
+          categories: [],
+          tags: [],
+          cover: "",
+          template: "",
+          visible: "PUBLIC",
+          publish: false,
+          pinned: false,
+          allowComment: true,
+          priority: 0,
+          excerpt: { autoGenerate: true },
+        },
+      },
+    })
+    .mockResolvedValueOnce({
+      data: {
+        metadata: { name: "post-1" },
+        spec: {
+          title: "Updated Halo",
+          slug: "updated-halo",
+        },
+      },
+    });
+  const getMyPostDraft = vi.fn().mockResolvedValue({
+    data: {
+      metadata: { name: "post-1", annotations: {} },
+      spec: { rawType: "markdown" },
+    },
+  });
+  const updateMyPost = vi.fn().mockResolvedValue({
+    data: { metadata: { name: "post-1" } },
+  });
+  const updateMyPostDraft = vi.fn().mockResolvedValue(undefined);
+
+  ucPostApiState.implementation = {
+    getMyPost,
+    getMyPostDraft,
+    updateMyPost,
+    updateMyPostDraft,
+    publishMyPost: vi.fn().mockResolvedValue(undefined),
+    unpublishMyPost: vi.fn().mockResolvedValue(undefined),
+  };
+
+  const runtimeMock = {
+    getClientsForOptions: vi.fn().mockResolvedValue({
+      profile: { baseUrl: "https://example.com" },
+      clients: {
+        axios: {
+          get: vi.fn().mockImplementation(async (url: string) => {
+            if (url.includes("/categories")) {
+              return { data: { items: [] } };
+            }
+
+            if (url.includes("/tags")) {
+              return { data: { items: [] } };
+            }
+
+            throw new Error(`Unexpected axios.get url: ${url}`);
+          }),
+          post: vi.fn(),
+        },
+      },
+    }),
+  };
+
+  await expect(
+    tryRunPostCommand(["post", "update", "post-1", "--json"], runtimeMock as never),
+  ).resolves.toBe(true);
+
+  expect(order.indexOf("Post title")).toBe(0);
+  expect(order.indexOf("Post slug")).toBe(1);
+  expect(order.indexOf("Select categories")).toBeGreaterThan(order.indexOf("Post slug"));
+  expect(order.indexOf("Select tags")).toBeGreaterThan(order.indexOf("Select categories"));
+});