@guanlin4924/devflow-pi 0.1.0

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/init_state.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "date"
+require "fileutils"
+require "json"
+require "optparse"
+require "yaml"
+require_relative "control_io"
+
+options = {
+  feature: nil,
+  phase: nil,
+  flow: "feature-development",
+  step: nil,
+  status: "not_started",
+  track: nil,
+  state: ".planning/STATE.md",
+  write: false,
+  force: false,
+  json: false
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: init_state.rb --feature NAME --phase NAME [--write] [--force]"
+  opts.on("--feature NAME", "Current feature name") { |value| options[:feature] = value }
+  opts.on("--phase NAME", "Current phase name") { |value| options[:phase] = value }
+  opts.on("--flow ID", "Workflow id") { |value| options[:flow] = value }
+  opts.on("--step ID", "Current step id") { |value| options[:step] = value }
+  opts.on("--status VALUE", "Initial status") { |value| options[:status] = value }
+  opts.on("--track VALUE", "Active track: A or B") { |value| options[:track] = value }
+  opts.on("--state PATH", "STATE.md path") { |value| options[:state] = value }
+  opts.on("--write", "Create/update STATE.md") { options[:write] = true }
+  opts.on("--force", "Replace existing front matter") { options[:force] = true }
+  opts.on("--json", "Print JSON output") { options[:json] = true }
+end.parse!
+
+root = Dir.pwd
+state_path = File.expand_path(options[:state], root)
+
+def front_matter(markdown)
+  match = markdown.match(/\A---\n(.*?)\n---\n/m)
+  match && match[1]
+end
+
+feature = options[:feature] || File.basename(root)
+phase = options[:phase] || "01-#{feature}"
+workflow_config = ".planning/workflows/#{options[:flow]}.yaml"
+workflow_path = File.expand_path(workflow_config, root)
+fallback_pending_steps = [
+  "requirement-triage",
+  "requirement-wayfinder",
+  "domain-modeling",
+  "requirement-feasibility-review",
+  "requirement-baseline",
+  "api-contract",
+  "backend-tech-spec",
+  "api-call-guide",
+  "ui-spec",
+  "feature-breakdown",
+  "frontend-tech-spec",
+  "api-supplement",
+  "integration-verify",
+  "change-plan",
+  "phase-structure",
+  "execute",
+  "code-index-refresh",
+  "code-review",
+  "generate-mainflow-cases",
+  "verify",
+  "audit",
+  "update-navigation",
+  "archive"
+]
+pending_steps = if File.exist?(workflow_path)
+                  workflow = YAML.safe_load(File.read(workflow_path), permitted_classes: [], aliases: false)
+                  Array(workflow["steps"]).map { |step| step.fetch("id") }
+                else
+                  fallback_pending_steps
+                end
+current_step = options[:step] || pending_steps.first || "requirement-triage"
+
+state = {
+  "state_schema_version" => 1,
+  "revision" => 0,
+  "state_updated_at" => Date.today.to_s,
+  "current_flow" => options[:flow],
+  "workflow_config" => workflow_config,
+  "current_feature" => feature,
+  "current_phase" => phase,
+  "current_step" => current_step,
+  "status" => options[:status],
+  "completed_steps" => [],
+  "pending_steps" => pending_steps,
+  "active_outputs" => {
+    "requirement_baseline" => ".planning/requirements/baseline.md",
+    "feature_dir" => ".planning/features/#{feature}/",
+    "phase_dir" => ".planning/phases/#{phase}/"
+  }
+}
+
+state["active_track"] = options[:track] if %w[A B].include?(options[:track].to_s)
+
+project_lock = DevflowControlIO.acquire_project_lock(root) if options[:write]
+
+begin
+existing = File.exist?(state_path) ? File.read(state_path) : nil
+existing_front = existing && front_matter(existing)
+action =
+  if existing_front && !options[:force]
+    "skip_existing_front_matter"
+  elsif options[:write]
+    FileUtils.mkdir_p(File.dirname(state_path))
+    body = existing || "# Project State\n\n"
+    front = state.to_yaml.sub(/\A---\n/, "")
+    content = if existing_front
+                body.sub(/\A---\n.*?\n---\n/m, "---\n#{front}---\n")
+              else
+                "---\n#{front}---\n\n#{body}"
+              end
+    DevflowControlIO.atomic_write(state_path, content)
+    existing ? "update" : "create"
+  else
+    existing ? "would_update" : "would_create"
+  end
+
+result = {
+  "ok" => true,
+  "written" => options[:write] && action != "skip_existing_front_matter",
+  "path" => options[:state],
+  "action" => action,
+  "state" => state
+}
+ensure
+  DevflowControlIO.release_lock(project_lock)
+end
+
+puts JSON.pretty_generate(result)

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/init_workflow.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "optparse"
+require "yaml"
+require_relative "control_io"
+
+options = { write: false, force: false, allow_state_mismatch: false, json: false }
+OptionParser.new do |opts|
+  opts.banner = "Usage: init_workflow.rb [--write] [--force] [--json]"
+  opts.on("--write", "Create missing workflow files") { options[:write] = true }
+  opts.on("--force", "Overwrite existing generated workflow files") { options[:force] = true }
+  opts.on("--allow-state-mismatch", "Allow overwriting the active workflow even if existing STATE.md tracks a different step set") { options[:allow_state_mismatch] = true }
+  opts.on("--json", "Print JSON output") { options[:json] = true }
+end.parse!
+
+root = Dir.pwd
+skill_root = File.expand_path("..", __dir__)
+template_dir = File.join(skill_root, "templates")
+state_path = File.join(root, ".planning", "STATE.md")
+
+def front_matter(markdown)
+  match = markdown.match(/\A---\n(.*?)\n---\n/m)
+  match && match[1]
+end
+
+project_lock = DevflowControlIO.acquire_project_lock(root) if options[:write]
+
+begin
+state = if File.exist?(state_path)
+          yaml = front_matter(File.read(state_path))
+          yaml && YAML.safe_load(yaml, permitted_classes: [], aliases: false)
+        end
+
+def workflow_step_ids(path)
+  workflow = YAML.safe_load(File.read(path), permitted_classes: [], aliases: false)
+  Array(workflow["steps"]).map { |step| step.fetch("id") }
+end
+
+def active_workflow_target?(state, target_path)
+  return false unless state
+
+  active = state["workflow_config"] || ".planning/workflows/#{state["current_flow"]}.yaml"
+  active == target_path
+end
+
+def state_step_mismatch?(state, template_path)
+  template_ids = workflow_step_ids(template_path)
+  tracked_ids = (Array(state["completed_steps"]) + Array(state["pending_steps"])).uniq
+  current_step = state["current_step"]
+  unknown_tracked = tracked_ids - template_ids
+  missing_tracked = template_ids - tracked_ids
+  unknown_current = current_step && !template_ids.include?(current_step)
+  unknown_tracked.any? || missing_tracked.any? || unknown_current
+end
+
+targets = {
+  "feature-development.yaml" => ".planning/workflows/feature-development.yaml",
+  "uat-remediation.yaml" => ".planning/workflows/uat-remediation.yaml",
+  "workflows-README.md" => ".planning/workflows/README.md"
+}
+
+blocked_target_paths = if options[:force] && options[:write] && !options[:allow_state_mismatch]
+                         targets.select do |template_name, target_path|
+                           source = File.join(template_dir, template_name)
+                           target = File.join(root, target_path)
+                           File.exist?(target) &&
+                             active_workflow_target?(state, target_path) &&
+                             state_step_mismatch?(state, source)
+                         end.values
+                       else
+                         []
+                       end
+
+changes = targets.map do |template_name, target_path|
+  source = File.join(template_dir, template_name)
+  target = File.join(root, target_path)
+  exists = File.exist?(target)
+  same_as_template = exists && File.read(target) == File.read(source)
+  state_mismatch = blocked_target_paths.include?(target_path)
+  action = if exists && !options[:force]
+             same_as_template ? "skip_existing" : "skip_existing_changed"
+           elsif state_mismatch && !options[:allow_state_mismatch]
+             "blocked_state_mismatch"
+           elsif blocked_target_paths.any?
+             exists ? "would_overwrite_blocked" : "would_create_blocked"
+           elsif options[:write]
+             FileUtils.mkdir_p(File.dirname(target))
+             DevflowControlIO.atomic_write(target, File.read(source))
+             exists ? "overwrite" : "create"
+           else
+             exists ? "would_skip_existing" : "would_create"
+           end
+
+  {
+    "template" => source,
+    "path" => target_path,
+    "exists" => exists,
+    "same_as_template" => same_as_template,
+    "state_mismatch" => state_mismatch,
+    "action" => action
+  }
+end
+
+blocked = changes.any? { |change| change["action"] == "blocked_state_mismatch" }
+result = {
+  "ok" => !blocked,
+  "written" => options[:write] && !blocked,
+  "force" => options[:force],
+  "allow_state_mismatch" => options[:allow_state_mismatch],
+  "upgrade_hint" => changes.any? { |change| change["action"] == "skip_existing_changed" } ? "Existing generated workflow differs from the bundled template. Use --force only when intentionally upgrading generated workflow files." : nil,
+  "blocked_reason" => blocked ? "active_state_step_mismatch" : nil,
+  "changes" => changes
+}.reject { |_, value| value.nil? }
+ensure
+  DevflowControlIO.release_lock(project_lock)
+end
+
+puts JSON.pretty_generate(result)