pi-gsd 2.0.1 → 2.0.2

package/src/commands/state.ts

@@ -1,102 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { BaseCommand } from "./base.js";
-
-export class StateJsonCommand extends BaseCommand {
-  static override description = "Output GSD state as JSON";
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags } = await this.parse(StateJsonCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const state = await import("../lib/state.js");
-    state.cmdStateJson(cwd, raw);
-  }
-}
-
-export class StateGetCommand extends BaseCommand {
-  static override description = "Get a specific state field";
-  static override args = { field: Args.string({ required: true }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(StateGetCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const state = await import("../lib/state.js");
-    state.cmdStateGet(cwd, args.field, raw);
-  }
-}
-
-export class StateUpdateCommand extends BaseCommand {
-  static override description = "Update a state field";
-  static override args = {
-    field: Args.string({ required: true }),
-    value: Args.string({ required: true }),
-  };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(StateUpdateCommand);
-    const { cwd } = this.resolveContext(flags);
-    const state = await import("../lib/state.js");
-    state.cmdStateUpdate(cwd, args.field, args.value);
-  }
-}
-
-export class StatePatchCommand extends BaseCommand {
-  static override description = "Patch multiple state fields";
-  static override args = { pairs: Args.string({ required: false }) };
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    field: Flags.string({ multiple: true, description: "field=value pair" }),
-  };
-
-  async run() {
-    const { flags, argv } = await this.parse(StatePatchCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const state = await import("../lib/state.js");
-    // Parse remaining argv as key value pairs
-    const patches: Record<string, string> = {};
-    const rawArgv = (argv as string[]).filter((a) => !a.startsWith("--"));
-    for (let i = 0; i < rawArgv.length; i += 2) {
-      const key = rawArgv[i].replace(/^--/, "");
-      if (key && rawArgv[i + 1] !== undefined) patches[key] = rawArgv[i + 1];
-    }
-    state.cmdStatePatch(cwd, patches, raw);
-  }
-}
-
-export class StateAdvancePlanCommand extends BaseCommand {
-  static override description = "Advance to next plan";
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags } = await this.parse(StateAdvancePlanCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const state = await import("../lib/state.js");
-    state.cmdStateAdvancePlan(cwd, raw);
-  }
-}
-
-export class StateLoadCommand extends BaseCommand {
-  static override description = "Load and display state";
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags } = await this.parse(StateLoadCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const state = await import("../lib/state.js");
-    state.cmdStateLoad(cwd, raw);
-  }
-}
-
-export class StateUpdateProgressCommand extends BaseCommand {
-  static override description = "Update progress counters";
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags } = await this.parse(StateUpdateProgressCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const state = await import("../lib/state.js");
-    state.cmdStateUpdateProgress(cwd, raw);
-  }
-}

package/src/commands/template.ts

@@ -1,52 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { BaseCommand } from "./base.js";
-
-export class TemplateSelectCommand extends BaseCommand {
-  static override description = "Select a workflow template";
-  static override args = { type: Args.string({ required: true }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(TemplateSelectCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdTemplateSelect } = await import("../lib/template.js");
-    cmdTemplateSelect(cwd, args.type, raw);
-  }
-}
-
-export class TemplateFillCommand extends BaseCommand {
-  static override description = "Fill a template with values";
-  static override args = { type: Args.string({ required: true }) };
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    phase: Flags.string(),
-    plan: Flags.string(),
-    name: Flags.string(),
-    type: Flags.string({ char: "t" }),
-    wave: Flags.string(),
-    fields: Flags.string({ description: "JSON fields" }),
-  };
-
-  async run() {
-    const { flags, args } = await this.parse(TemplateFillCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdTemplateFill } = await import("../lib/template.js");
-    let extraFields: Record<string, string> = {};
-    if (flags.fields) {
-      try { extraFields = JSON.parse(flags.fields) as Record<string, string>; } catch { /* ignore */ }
-    }
-    cmdTemplateFill(
-      cwd,
-      args.type,
-      {
-        phase: flags.phase ?? undefined,
-        plan: flags.plan ?? undefined,
-        name: flags.name ?? undefined,
-        type: flags.type ?? undefined,
-        wave: flags.wave ?? undefined,
-        ...extraFields,
-      },
-      raw,
-    );
-  }
-}

package/src/commands/verify.ts

@@ -1,70 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { BaseCommand } from "./base.js";
-
-export class ValidateConsistencyCommand extends BaseCommand {
-  static override description = "Validate planning consistency";
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags } = await this.parse(ValidateConsistencyCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const v = await import("../lib/verify.js");
-    v.cmdValidateConsistency(cwd, raw);
-  }
-}
-
-export class ValidateHealthCommand extends BaseCommand {
-  static override description = "Check .planning/ health";
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    repair: Flags.boolean({ description: "Auto-repair issues", default: false }),
-  };
-
-  async run() {
-    const { flags } = await this.parse(ValidateHealthCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const v = await import("../lib/verify.js");
-    v.cmdValidateHealth(cwd, { repair: flags.repair }, raw);
-  }
-}
-
-export class ValidateAgentsCommand extends BaseCommand {
-  static override description = "Validate agent configurations";
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags } = await this.parse(ValidateAgentsCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const v = await import("../lib/verify.js");
-    v.cmdValidateAgents(cwd, raw);
-  }
-}
-
-export class VerifyCommand extends BaseCommand {
-  static override description = "Run UAT verification";
-  static override args = { phase: Args.string({ required: false }) };
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    plan: Flags.string({ description: "Plan to verify" }),
-  };
-
-  async run() {
-    const { flags, args } = await this.parse(VerifyCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const v = await import("../lib/verify.js");
-    // verify command runs consistency check as primary action
-    v.cmdValidateConsistency(cwd, raw);
-  }
-}
-
-export class AuditUatCommand extends BaseCommand {
-  static override description = "Audit UAT results";
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags } = await this.parse(AuditUatCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdAuditUat } = await import("../lib/uat.js");
-    cmdAuditUat(cwd, raw);
-  }
-}

package/src/commands/workstream.ts

@@ -1,98 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { BaseCommand } from "./base.js";
-
-export class WorkstreamCreateCommand extends BaseCommand {
-  static override description = "Create a new workstream";
-  static override args = { name: Args.string({ required: true }) };
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    "no-migrate": Flags.boolean({ description: "Skip migration", default: false }),
-    "migrate-name": Flags.string({ description: "Migration name" }),
-  };
-
-  async run() {
-    const { flags, args } = await this.parse(WorkstreamCreateCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const ws = await import("../lib/workstream.js");
-    ws.cmdWorkstreamCreate(
-      cwd, args.name,
-      { migrate: !flags["no-migrate"], migrateName: flags["migrate-name"] ?? null },
-      raw,
-    );
-  }
-}
-
-export class WorkstreamListCommand extends BaseCommand {
-  static override description = "List workstreams";
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags } = await this.parse(WorkstreamListCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const ws = await import("../lib/workstream.js");
-    ws.cmdWorkstreamList(cwd, raw);
-  }
-}
-
-export class WorkstreamStatusCommand extends BaseCommand {
-  static override description = "Show workstream status";
-  static override args = { name: Args.string({ required: true }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(WorkstreamStatusCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const ws = await import("../lib/workstream.js");
-    ws.cmdWorkstreamStatus(cwd, args.name, raw);
-  }
-}
-
-export class WorkstreamCompleteCommand extends BaseCommand {
-  static override description = "Complete a workstream";
-  static override args = { name: Args.string({ required: true }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(WorkstreamCompleteCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const ws = await import("../lib/workstream.js");
-    ws.cmdWorkstreamComplete(cwd, args.name, {}, raw);
-  }
-}
-
-export class WorkstreamSetCommand extends BaseCommand {
-  static override description = "Set active workstream";
-  static override args = { name: Args.string({ required: true }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(WorkstreamSetCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const ws = await import("../lib/workstream.js");
-    ws.cmdWorkstreamSet(cwd, args.name, raw);
-  }
-}
-
-export class WorkstreamGetCommand extends BaseCommand {
-  static override description = "Get active workstream";
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags } = await this.parse(WorkstreamGetCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const ws = await import("../lib/workstream.js");
-    ws.cmdWorkstreamGet(cwd, raw);
-  }
-}
-
-export class WorkstreamProgressCommand extends BaseCommand {
-  static override description = "Show workstream progress";
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags } = await this.parse(WorkstreamProgressCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const ws = await import("../lib/workstream.js");
-    ws.cmdWorkstreamProgress(cwd, raw);
-  }
-}

package/src/commands/wxp.ts

@@ -1,65 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { Command } from "@oclif/core";
-import path from "node:path";
-import { processWxp, WxpProcessingError } from "../wxp/index.js";
-import { DEFAULT_SHELL_ALLOWLIST } from "../wxp/security.js";
-
-export class WxpProcessCommand extends Command {
-  static override description = "Process WXP tags in a workflow file";
-  static override args = {
-    file: Args.string({ description: "File to process", required: false }),
-  };
-  static override flags = {
-    input: Flags.string({ description: "Input content string (alternative to file)" }),
-    arguments: Flags.string({ description: "Raw $ARGUMENTS string", default: "" }),
-    "project-root": Flags.string({ description: "Project root directory", default: process.cwd() }),
-    "pkg-root": Flags.string({ description: "Package root directory", default: process.cwd() }),
-  };
-
-  async run() {
-    const { flags, args } = await this.parse(WxpProcessCommand);
-
-    let content: string;
-    let filePath: string;
-
-    if (flags.input !== undefined) {
-      content = flags.input;
-      filePath = path.join(flags["project-root"], ".pi", "gsd", "workflows", "_inline.md");
-    } else if (args.file) {
-      const fs = await import("node:fs");
-      filePath = path.resolve(args.file);
-      content = fs.default.readFileSync(filePath, "utf8");
-    } else {
-      this.error("Provide a file argument or --input string");
-      return;
-    }
-
-    const config = {
-      trustedPaths: [
-        { position: "project" as const, path: ".pi/gsd" },
-        { position: "pkg" as const, path: ".gsd/harnesses/pi/get-shit-done" },
-      ],
-      untrustedPaths: [],
-      shellAllowlist: [...DEFAULT_SHELL_ALLOWLIST],
-      shellBanlist: [],
-      shellTimeoutMs: 30_000,
-    };
-
-    try {
-      const result = processWxp(
-        content,
-        filePath,
-        config,
-        flags["project-root"],
-        flags["pkg-root"],
-        flags.arguments,
-      );
-      process.stdout.write(result);
-    } catch (err) {
-      if (err instanceof WxpProcessingError) {
-        this.error(err.message, { exit: 1 });
-      }
-      throw err;
-    }
-  }
-}