@kata-sh/pi-symphony-extension 0.1.0

package/src/command-args.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { parseAttachArgs, parseDoctorArgs, parseInitArgs, parseStartArgs, parseSteerArgs } from "./command-args.ts";
+
+describe("command argument parsing", () => {
+  it("parses init force flag", () => {
+    expect(parseInitArgs("--force")).toEqual({ force: true });
+    expect(parseInitArgs("")).toEqual({ force: false });
+  });
+
+  it("rejects unknown init flags", () => {
+    expect(() => parseInitArgs("--bad")).toThrow("Unknown /symphony:init option: --bad");
+  });
+
+  it("keeps workflow arguments as one path string", () => {
+    expect(parseDoctorArgs(".symphony/WORKFLOW.md")).toEqual({ workflow: ".symphony/WORKFLOW.md" });
+    expect(parseStartArgs("/tmp/My Workflow.md")).toEqual({ workflow: "/tmp/My Workflow.md" });
+    expect(parseStartArgs("   ")).toEqual({ workflow: undefined });
+  });
+
+  it("parses attach URL as optional", () => {
+    expect(parseAttachArgs("http://127.0.0.1:8080")).toEqual({ url: "http://127.0.0.1:8080" });
+    expect(parseAttachArgs("")).toEqual({ url: undefined });
+  });
+
+  it("parses steer issue and instruction", () => {
+    expect(parseSteerArgs("SIM-123 Use the existing auth module")).toEqual({
+      issueIdentifier: "SIM-123",
+      instruction: "Use the existing auth module",
+    });
+    expect(() => parseSteerArgs("SIM-123")).toThrow("Usage: /symphony:steer <ISSUE> <instruction>");
+    expect(() => parseSteerArgs("   ")).toThrow("Usage: /symphony:steer <ISSUE> <instruction>");
+  });
+});

package/src/command-args.ts

@@ -0,0 +1,58 @@
+export interface InitArgs {
+  force: boolean;
+}
+
+export interface WorkflowArgs {
+  workflow?: string;
+}
+
+export interface AttachArgs {
+  url?: string;
+}
+
+export interface SteerArgs {
+  issueIdentifier: string;
+  instruction: string;
+}
+
+export function parseInitArgs(args: string): InitArgs {
+  const tokens = args.trim().split(/\s+/).filter(Boolean);
+  let force = false;
+  for (const token of tokens) {
+    if (token === "--force") {
+      force = true;
+      continue;
+    }
+    throw new Error(`Unknown /symphony:init option: ${token}`);
+  }
+  return { force };
+}
+
+export function parseDoctorArgs(args: string): WorkflowArgs {
+  return parseWorkflowArg(args);
+}
+
+export function parseStartArgs(args: string): WorkflowArgs {
+  return parseWorkflowArg(args);
+}
+
+function parseWorkflowArg(args: string): WorkflowArgs {
+  const workflow = args.trim();
+  return workflow ? { workflow } : { workflow: undefined };
+}
+
+export function parseAttachArgs(args: string): AttachArgs {
+  const url = args.trim();
+  return { url: url || undefined };
+}
+
+export function parseSteerArgs(args: string): SteerArgs {
+  const trimmed = args.trim();
+  const firstSpaceIndex = trimmed.search(/\s/);
+  if (!trimmed || firstSpaceIndex === -1) throw new Error("Usage: /symphony:steer <ISSUE> <instruction>");
+
+  const issueIdentifier = trimmed.slice(0, firstSpaceIndex).trim();
+  const instruction = trimmed.slice(firstSpaceIndex).trim();
+  if (!issueIdentifier || !instruction) throw new Error("Usage: /symphony:steer <ISSUE> <instruction>");
+  return { issueIdentifier, instruction };
+}