pi-gsd 2.0.1 → 2.0.3

package/src/commands/base.ts

@@ -1,67 +0,0 @@
-import { Command, Flags } from "@oclif/core";
-import path from "node:path";
-import fs from "node:fs";
-import {
-  findProjectRoot,
-  getActiveWorkstream,
-  gsdError,
-  resolveWorktreeRoot,
-} from "../lib/core.js";
-
-/**
- * BaseCommand — extends oclif Command with GSD global flags.
- * All pi-gsd-tools commands extend this.
- */
-export abstract class BaseCommand extends Command {
-  static override enableJsonFlag = false;
-
-  static override baseFlags = {
-    cwd: Flags.string({ description: "Working directory", default: "" }),
-    ws: Flags.string({ description: "Workstream override", default: "" }),
-    raw: Flags.boolean({ description: "Raw JSON output", default: false }),
-    output: Flags.string({
-      description: "Output format",
-      options: ["json", "toon"],
-      default: "json",
-    }),
-    pick: Flags.string({ description: "JSONPath pick expression", default: "" }),
-  };
-
-  /** Resolve cwd + ws from flags and environment, following GSD conventions. */
-  protected resolveContext(flags: {
-    cwd?: string;
-    ws?: string;
-    raw?: boolean;
-    output?: string;
-    pick?: string;
-  }): { cwd: string; ws: string | null; raw: boolean } {
-    let cwd = flags.cwd ? path.resolve(flags.cwd) : process.cwd();
-
-    if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) {
-      gsdError(`Invalid --cwd: ${cwd}`);
-    }
-
-    // Worktree resolution
-    if (!fs.existsSync(path.join(cwd, ".planning"))) {
-      const worktreeRoot = resolveWorktreeRoot(cwd);
-      if (worktreeRoot !== cwd) cwd = worktreeRoot;
-    }
-
-    let ws: string | null = null;
-    if (flags.ws) {
-      ws = flags.ws;
-    } else if (process.env["GSD_WORKSTREAM"]) {
-      ws = process.env["GSD_WORKSTREAM"].trim();
-    } else {
-      ws = getActiveWorkstream(cwd);
-    }
-
-    if (ws && !/^[a-zA-Z0-9_-]+$/.test(ws)) gsdError("Invalid workstream name");
-    if (ws) process.env["GSD_WORKSTREAM"] = ws;
-
-    // Root resolution (most commands)
-    cwd = findProjectRoot(cwd);
-
-    return { cwd, ws, raw: flags.raw ?? false };
-  }
-}

package/src/commands/commit.ts

@@ -1,22 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { BaseCommand } from "./base.js";
-
-export class CommitCommand extends BaseCommand {
-  static override description = "Commit GSD changes to git";
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    amend: Flags.boolean({ description: "Amend last commit", default: false }),
-    "no-verify": Flags.boolean({ description: "Skip git hooks", default: false }),
-    files: Flags.string({ description: "Files to include", multiple: true }),
-  };
-  static override strict = false;
-
-  async run() {
-    const { flags, argv } = await this.parse(CommitCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdCommit } = await import("../lib/commands.js");
-    const rawArgv = argv as string[];
-    const message = rawArgv.filter((a) => !a.startsWith("--")).join(" ") || undefined;
-    cmdCommit(cwd, message, flags.files ?? [], raw, flags.amend, flags["no-verify"]);
-  }
-}

package/src/commands/config.ts

@@ -1,71 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { BaseCommand } from "./base.js";
-
-export class ConfigGetCommand extends BaseCommand {
-  static override description = "Get a config value";
-  static override args = { key: Args.string({ required: true }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(ConfigGetCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdConfigGet } = await import("../lib/config.js");
-    cmdConfigGet(cwd, args.key, raw);
-  }
-}
-
-export class ConfigSetCommand extends BaseCommand {
-  static override description = "Set a config value";
-  static override args = {
-    key: Args.string({ required: false }),
-    value: Args.string({ required: false }),
-  };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(ConfigSetCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdConfigSet } = await import("../lib/config.js");
-    cmdConfigSet(cwd, args.key, args.value, raw);
-  }
-}
-
-export class ConfigSetModelProfileCommand extends BaseCommand {
-  static override description = "Set the active model profile";
-  static override args = { profile: Args.string({ required: true }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(ConfigSetModelProfileCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdConfigSetModelProfile } = await import("../lib/config.js");
-    cmdConfigSetModelProfile(cwd, args.profile, raw);
-  }
-}
-
-export class ConfigNewProjectCommand extends BaseCommand {
-  static override description = "Initialise a new project config";
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    choices: Flags.string({ description: "Choices JSON" }),
-  };
-
-  async run() {
-    const { flags } = await this.parse(ConfigNewProjectCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdConfigNewProject } = await import("../lib/config.js");
-    cmdConfigNewProject(cwd, flags.choices, raw);
-  }
-}
-
-export class ConfigEnsureSectionCommand extends BaseCommand {
-  static override description = "Ensure a config section exists";
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags } = await this.parse(ConfigEnsureSectionCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdConfigEnsureSection } = await import("../lib/config.js");
-    cmdConfigEnsureSection(cwd, raw);
-  }
-}

package/src/commands/frontmatter.ts

@@ -1,51 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { BaseCommand } from "./base.js";
-
-export class FrontmatterGetCommand extends BaseCommand {
-  static override description = "Get frontmatter field from a file";
-  static override args = { file: Args.string({ required: true }) };
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    field: Flags.string({ description: "Field name" }),
-  };
-
-  async run() {
-    const { flags, args } = await this.parse(FrontmatterGetCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const fm = await import("../lib/frontmatter.js");
-    fm.cmdFrontmatterGet(cwd, args.file, flags.field ?? null, raw);
-  }
-}
-
-export class FrontmatterSetCommand extends BaseCommand {
-  static override description = "Set frontmatter field in a file";
-  static override args = { file: Args.string({ required: true }) };
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    field: Flags.string({ description: "Field name" }),
-    value: Flags.string({ description: "Field value" }),
-  };
-
-  async run() {
-    const { flags, args } = await this.parse(FrontmatterSetCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const fm = await import("../lib/frontmatter.js");
-    fm.cmdFrontmatterSet(cwd, args.file, flags.field, flags.value, raw);
-  }
-}
-
-export class FrontmatterMergeCommand extends BaseCommand {
-  static override description = "Merge frontmatter data into a file";
-  static override args = { file: Args.string({ required: true }) };
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    data: Flags.string({ description: "JSON data to merge" }),
-  };
-
-  async run() {
-    const { flags, args } = await this.parse(FrontmatterMergeCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const fm = await import("../lib/frontmatter.js");
-    fm.cmdFrontmatterMerge(cwd, args.file, flags.data, raw);
-  }
-}

package/src/commands/index.ts

@@ -1,76 +0,0 @@
-// Re-export all command classes
-export {
-  StateJsonCommand,
-  StateGetCommand,
-  StateUpdateCommand,
-  StatePatchCommand,
-  StateAdvancePlanCommand,
-  StateLoadCommand,
-  StateUpdateProgressCommand,
-} from "./state.js";
-
-export { InitCommand } from "./init.js";
-
-export {
-  RoadmapAnalyzeCommand,
-  RoadmapGetPhaseCommand,
-  RoadmapUpdatePlanProgressCommand,
-} from "./roadmap.js";
-
-export {
-  ConfigGetCommand,
-  ConfigSetCommand,
-  ConfigSetModelProfileCommand,
-  ConfigNewProjectCommand,
-  ConfigEnsureSectionCommand,
-} from "./config.js";
-
-export {
-  PhaseNextDecimalCommand,
-  PhaseAddCommand,
-  PhaseInsertCommand,
-  PhaseRemoveCommand,
-  PhaseCompleteCommand,
-  PhasePlanIndexCommand,
-} from "./phase.js";
-
-export { MilestoneCompleteCommand, RequirementsMarkCompleteCommand } from "./milestone.js";
-
-export {
-  ValidateConsistencyCommand,
-  ValidateHealthCommand,
-  ValidateAgentsCommand,
-  VerifyCommand,
-  AuditUatCommand,
-} from "./verify.js";
-
-export {
-  WorkstreamCreateCommand,
-  WorkstreamListCommand,
-  WorkstreamStatusCommand,
-  WorkstreamCompleteCommand,
-  WorkstreamSetCommand,
-  WorkstreamGetCommand,
-  WorkstreamProgressCommand,
-} from "./workstream.js";
-
-export { ScaffoldCommand } from "./scaffold.js";
-export { CommitCommand } from "./commit.js";
-
-export {
-  FrontmatterGetCommand,
-  FrontmatterSetCommand,
-  FrontmatterMergeCommand,
-} from "./frontmatter.js";
-
-export { TemplateSelectCommand, TemplateFillCommand } from "./template.js";
-
-export {
-  ProgressCommand,
-  StatsCommand,
-  TodoCompleteCommand,
-  TodoMatchPhaseCommand,
-  SummaryExtractCommand,
-} from "./progress.js";
-
-export { WxpProcessCommand } from "./wxp.js";

package/src/commands/init.ts

@@ -1,43 +0,0 @@
-import { Args } from "@oclif/core";
-import { BaseCommand } from "./base.js";
-
-export class InitCommand extends BaseCommand {
-  static override description = "Initialise a GSD workflow context";
-  static override args = {
-    workflow: Args.string({ required: true }),
-    phase: Args.string({ required: false }),
-    rest: Args.string({ required: false }),
-  };
-  static override flags = { ...BaseCommand.baseFlags };
-  static override strict = false;
-
-  async run() {
-    const { flags, argv } = await this.parse(InitCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const rawArgv = argv as string[];
-    const workflow = rawArgv[0];
-    const init = await import("../lib/init.js");
-    const { gsdError } = await import("../lib/core.js");
-
-    switch (workflow) {
-      case "execute-phase": return init.cmdInitExecutePhase(cwd, rawArgv[1], raw);
-      case "plan-phase": return init.cmdInitPlanPhase(cwd, rawArgv[1], raw);
-      case "new-project": return init.cmdInitNewProject(cwd, raw);
-      case "new-milestone": return init.cmdInitNewMilestone(cwd, raw);
-      case "quick": return init.cmdInitQuick(cwd, rawArgv.slice(1).join(" "), raw);
-      case "resume": return init.cmdInitResume(cwd, raw);
-      case "verify-work": return init.cmdInitVerifyWork(cwd, rawArgv[1], raw);
-      case "phase-op": return init.cmdInitPhaseOp(cwd, rawArgv[1], raw);
-      case "todos": return init.cmdInitTodos(cwd, rawArgv[1], raw);
-      case "milestone-op": return init.cmdInitMilestoneOp(cwd, raw);
-      case "map-codebase": return init.cmdInitMapCodebase(cwd, raw);
-      case "progress": return init.cmdInitProgress(cwd, raw);
-      case "manager": return init.cmdInitManager(cwd, raw);
-      case "new-workspace": return init.cmdInitNewWorkspace(cwd, raw);
-      case "list-workspaces": return init.cmdInitListWorkspaces(cwd, raw);
-      case "remove-workspace": return init.cmdInitRemoveWorkspace(cwd, rawArgv[1], raw);
-      default:
-        gsdError(`Unknown init workflow: ${workflow}`);
-    }
-  }
-}

package/src/commands/milestone.ts

@@ -1,37 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { BaseCommand } from "./base.js";
-
-export class MilestoneCompleteCommand extends BaseCommand {
-  static override description = "Complete the current milestone";
-  static override args = { version: Args.string({ required: false }) };
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    name: Flags.string({ description: "Milestone name" }),
-    "archive-phases": Flags.boolean({ description: "Archive phases", default: false }),
-  };
-
-  async run() {
-    const { flags, args } = await this.parse(MilestoneCompleteCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdMilestoneComplete } = await import("../lib/milestone.js");
-    cmdMilestoneComplete(
-      cwd,
-      args.version ?? "",
-      { name: flags.name ?? null, archivePhases: flags["archive-phases"] },
-      raw,
-    );
-  }
-}
-
-export class RequirementsMarkCompleteCommand extends BaseCommand {
-  static override description = "Mark requirements as complete";
-  static override flags = { ...BaseCommand.baseFlags };
-  static override strict = false;
-
-  async run() {
-    const { flags, argv } = await this.parse(RequirementsMarkCompleteCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdRequirementsMarkComplete } = await import("../lib/milestone.js");
-    cmdRequirementsMarkComplete(cwd, argv as string[], raw);
-  }
-}

package/src/commands/phase.ts

@@ -1,92 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { BaseCommand } from "./base.js";
-
-export class PhaseNextDecimalCommand extends BaseCommand {
-  static override description = "Get next decimal phase number";
-  static override args = { phase: Args.string({ required: true }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(PhaseNextDecimalCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const phase = await import("../lib/phase.js");
-    phase.cmdPhaseNextDecimal(cwd, args.phase, raw);
-  }
-}
-
-export class PhaseAddCommand extends BaseCommand {
-  static override description = "Add a new phase";
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    id: Flags.string({ description: "Custom phase ID" }),
-  };
-  static override strict = false;
-
-  async run() {
-    const { flags, argv } = await this.parse(PhaseAddCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const phase = await import("../lib/phase.js");
-    const desc = (argv as string[]).join(" ");
-    phase.cmdPhaseAdd(cwd, desc, raw, flags.id ?? null);
-  }
-}
-
-export class PhaseInsertCommand extends BaseCommand {
-  static override description = "Insert a phase at position";
-  static override args = {
-    position: Args.string({ required: true }),
-    description: Args.string({ required: false }),
-  };
-  static override flags = { ...BaseCommand.baseFlags };
-  static override strict = false;
-
-  async run() {
-    const { flags, argv } = await this.parse(PhaseInsertCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const rawArgv = argv as string[];
-    const phase = await import("../lib/phase.js");
-    phase.cmdPhaseInsert(cwd, rawArgv[0], rawArgv.slice(1).join(" "), raw);
-  }
-}
-
-export class PhaseRemoveCommand extends BaseCommand {
-  static override description = "Remove a phase";
-  static override args = { phase: Args.string({ required: true }) };
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    force: Flags.boolean({ description: "Force removal", default: false }),
-  };
-
-  async run() {
-    const { flags, args } = await this.parse(PhaseRemoveCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const phase = await import("../lib/phase.js");
-    phase.cmdPhaseRemove(cwd, args.phase, { force: flags.force }, raw);
-  }
-}
-
-export class PhaseCompleteCommand extends BaseCommand {
-  static override description = "Mark a phase as complete";
-  static override args = { phase: Args.string({ required: true }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(PhaseCompleteCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const phase = await import("../lib/phase.js");
-    phase.cmdPhaseComplete(cwd, args.phase, raw);
-  }
-}
-
-export class PhasePlanIndexCommand extends BaseCommand {
-  static override description = "Get phase plan index";
-  static override args = { phase: Args.string({ required: true }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(PhasePlanIndexCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdPhasePlanIndex } = await import("../lib/phase.js");
-    cmdPhasePlanIndex(cwd, args.phase, raw);
-  }
-}

package/src/commands/progress.ts

@@ -1,71 +0,0 @@
-import { Args } from "@oclif/core";
-import { BaseCommand } from "./base.js";
-
-export class ProgressCommand extends BaseCommand {
-  static override description = "Show project progress";
-  static override args = { format: Args.string({ default: "json" }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(ProgressCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdProgressRender } = await import("../lib/commands.js");
-    cmdProgressRender(cwd, args.format, raw);
-  }
-}
-
-export class StatsCommand extends BaseCommand {
-  static override description = "Show project statistics";
-  static override args = { format: Args.string({ default: "json" }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(StatsCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdStats } = await import("../lib/commands.js");
-    cmdStats(cwd, args.format, raw);
-  }
-}
-
-export class TodoCompleteCommand extends BaseCommand {
-  static override description = "Mark a todo as complete";
-  static override args = { id: Args.string({ required: true }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(TodoCompleteCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdTodoComplete } = await import("../lib/commands.js");
-    cmdTodoComplete(cwd, args.id, raw);
-  }
-}
-
-export class TodoMatchPhaseCommand extends BaseCommand {
-  static override description = "Match todos to phase";
-  static override args = { phase: Args.string({ required: true }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(TodoMatchPhaseCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdTodoMatchPhase } = await import("../lib/commands.js");
-    cmdTodoMatchPhase(cwd, args.phase, raw);
-  }
-}
-
-export class SummaryExtractCommand extends BaseCommand {
-  static override description = "Extract fields from summary files";
-  static override args = { phase: Args.string({ required: true }) };
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    fields: BaseCommand.baseFlags.pick, // reuse pick flag for field list
-  };
-
-  async run() {
-    const { flags, args } = await this.parse(SummaryExtractCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdSummaryExtract } = await import("../lib/commands.js");
-    const fields = flags.fields ? flags.fields.split(",") : null;
-    cmdSummaryExtract(cwd, args.phase, fields, raw);
-  }
-}

package/src/commands/roadmap.ts

@@ -1,40 +0,0 @@
-import { Args } from "@oclif/core";
-import { BaseCommand } from "./base.js";
-
-export class RoadmapAnalyzeCommand extends BaseCommand {
-  static override description = "Analyze roadmap phases and status";
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags } = await this.parse(RoadmapAnalyzeCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const roadmap = await import("../lib/roadmap.js");
-    roadmap.cmdRoadmapAnalyze(cwd, raw);
-  }
-}
-
-export class RoadmapGetPhaseCommand extends BaseCommand {
-  static override description = "Get details for a specific phase";
-  static override args = { phase: Args.string({ required: true }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(RoadmapGetPhaseCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const roadmap = await import("../lib/roadmap.js");
-    roadmap.cmdRoadmapGetPhase(cwd, args.phase, raw);
-  }
-}
-
-export class RoadmapUpdatePlanProgressCommand extends BaseCommand {
-  static override description = "Update plan progress in roadmap";
-  static override args = { phase: Args.string({ required: true }) };
-  static override flags = { ...BaseCommand.baseFlags };
-
-  async run() {
-    const { flags, args } = await this.parse(RoadmapUpdatePlanProgressCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const roadmap = await import("../lib/roadmap.js");
-    roadmap.cmdRoadmapUpdatePlanProgress(cwd, args.phase, raw);
-  }
-}

package/src/commands/scaffold.ts

@@ -1,19 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { BaseCommand } from "./base.js";
-
-export class ScaffoldCommand extends BaseCommand {
-  static override description = "Scaffold a GSD artefact";
-  static override args = { type: Args.string({ required: true }) };
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    phase: Flags.string({ description: "Phase number" }),
-    name: Flags.string({ description: "Artefact name" }),
-  };
-
-  async run() {
-    const { flags, args } = await this.parse(ScaffoldCommand);
-    const { cwd, raw } = this.resolveContext(flags);
-    const { cmdScaffold } = await import("../lib/commands.js");
-    cmdScaffold(cwd, args.type, { phase: flags.phase ?? null, name: flags.name ?? null }, raw);
-  }
-}