featureparity 0.0.19 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dda702b723617dde0db1b5948be499c087f4c314a9ccd6a188d66bf512523328
-  data.tar.gz: 48104e563fe159fac04b247a51fd0780d060e87042e1416497bb33b5b9530b7f
+  metadata.gz: 65fc8c40a37a8d05f6fd566fd6362a5b5f489c3ee516ea4643c37afedb0d4534
+  data.tar.gz: 2a05968f741537fbc82fc0cc12cb67d7f4bf9fa2c5cebd11bc3514a9637e1745
 SHA512:
-  metadata.gz: a34620d3c364b92651707e89882943a7dd6abb22346192f4f3bce117471708c843bbc9a1606a661f66f4debcabed20fd1e109073ad3b1016aa386be7ffef36bc
-  data.tar.gz: a4647cc613c7aba590a4611fb20a7b1ba0d1ae2b4f70950cf1230092b40689721a86962a4d3b58ddb261e4b3f5c3fd29e84f2d096bba268cd79adf2704cd7aee
+  metadata.gz: a9dc847a7281c8b018547b97fb3c06b9bbcf0bcaee596cf1afb098428f025a48af5b01acaad7b76583ed18f0385602dbc9ccae47f5a9605220bacfe31f543723
+  data.tar.gz: 95909562928c8f9780eafed047018e8d9e752d6a3e10a5feeb09cdd716ac14945e39948d692aa04102d233f1403570f8e4e926225257093e56a7ed08c1af7b1e

data/lib/fp/client.rb

@@ -22,6 +22,21 @@ module Fp
       get("/api/projects/#{id}")
     end
 
+    # POST /projects
+    def create_project(params)
+      post('/api/projects', params)
+    end
+
+    # PUT /projects/:id
+    def update_project(id, params)
+      put("/api/projects/#{id}", params)
+    end
+
+    # DELETE /projects/:id
+    def delete_project(id)
+      delete("/api/projects/#{id}")
+    end
+
     # GET /projects/:id/surfaces
     def list_surfaces(project_id)
       get("/api/projects/#{project_id}/surfaces")

data/lib/fp/commands/help.rb

@@ -14,6 +14,10 @@ module Fp
           COMMANDS
             init --project <slug>             Onboard this repo: config, CI gate, agent docs
             projects                          List projects you have access to
+            projects show <slug>              View a project and its surfaces
+            projects create <slug> --name ... Create a project (owned by your key's owner)
+            projects edit <slug> --name ...   Update a project's name or description
+            projects delete <slug> [--yes]    Delete a project (asks you to type its slug)
             surfaces --project <slug>         List surfaces for a project
             surfaces show <key> --project ... View a single surface's details
             surfaces add <key> --project ...  Create a surface
@@ -151,6 +155,17 @@ module Fp
             # List projects
             fp projects
 
+            # Create a project (agents can do this — the project lands on the account of
+            # whoever minted the key, and the same key reaches it immediately)
+            fp projects create calib-rate --name "Calib Rate" --surfaces api,web
+            fp projects show calib-rate
+            fp projects edit calib-rate --description "Calibration tooling"
+
+            # Delete a project. Interactive: type the slug to confirm. Non-interactive
+            # sessions must pass --yes, or the command refuses. Owners only.
+            fp projects delete calib-rate
+            fp projects delete calib-rate --yes
+
             # List the surfaces a project tracks (requirements may only name these)
             fp surfaces --project stowzilla
 

data/lib/fp/commands/projects.rb

@@ -2,9 +2,57 @@
 
 module Fp
   module Commands
-    # fp projects - list projects the API key has access to
+    # fp projects                                  - list projects the API key can reach
+    # fp projects show <slug>                      - view one project and its surfaces
+    # fp projects create <slug> --name "..."       - create a project (owned by the key's owner)
+    # fp projects edit <slug> --name/--description - update a project's details
+    # fp projects delete <slug> [--yes]            - delete a project, with confirmation
+    #
+    # `create` exists because the only way to start a project used to be the web app, so
+    # an agent onboarding a repo FeatureParity had never seen was stuck waiting on a human
+    # (Fizzy #1473). Keys are account-level (Fizzy #1472): the project lands on the key
+    # owner's account, and the same key reaches it immediately.
+    #
+    # `delete` is modelled on `gh repo delete`: it asks you to type the project's slug,
+    # or takes --yes to skip the prompt, and a non-interactive session without --yes is
+    # refused rather than guessed at. The server adds its own check — only an owner (or an
+    # owner's key) may delete.
     class Projects < Base
-      def run(_args)
+      CREATE_FLAGS = {
+        name: :string,
+        description: :string,
+        surfaces: :string
+      }.freeze
+
+      EDIT_FLAGS = {
+        name: :string,
+        description: :string
+      }.freeze
+
+      DELETE_FLAGS = {
+        yes: :boolean
+      }.freeze
+
+      def run(args)
+        # Subcommand dispatch. Bare `fp projects` stays the list, so existing callers
+        # (the setup wizard's "test access with fp projects") keep working.
+        case args.first
+        when 'show'
+          show(args[1..])
+        when 'create'
+          create(args[1..])
+        when 'edit'
+          edit(args[1..])
+        when 'delete'
+          delete(args[1..])
+        else
+          list
+        end
+      end
+
+      private
+
+      def list
         result = client.list_projects
 
         unless result[:ok]
@@ -17,22 +65,240 @@ module Fp
         output.success(result[:data]) do
           if projects.empty?
             puts 'No projects found.'
+            puts 'Create one with: fp projects create <slug> --name "<Name>"'
           else
             headers = %w[SLUG NAME SURFACES]
             rows = projects.map do |w|
-              surfaces_result = client.list_surfaces(w['id'])
-              surface_keys = if surfaces_result[:ok]
-                               (surfaces_result[:data]['surfaces'] || []).map { |s| s['key'] }
-                             else
-                               []
-                             end
-              surfaces = surface_keys.join(', ')
+              surfaces = surface_keys_for(w['id']).join(', ')
               [w['slug'], w['name'], surfaces.empty? ? '-' : surfaces]
             end
             output.table(headers, rows)
           end
         end
       end
+
+      def show(args)
+        _opts, positional = parse_flags(args)
+        slug = require_slug!(positional, 'fp projects show <slug>')
+
+        project = find_project!(slug)
+        result = client.get_project(project['id'])
+
+        unless result[:ok]
+          output.error(result[:error], status: result[:status])
+          exit 1
+        end
+
+        record = result[:data]['project'] || project
+        surfaces = surface_keys_for(record['id'])
+
+        output.success({ project: record, surfaces: surfaces }) do
+          print_project(record, surfaces)
+        end
+      end
+
+      def create(args)
+        opts, positional = parse_flags(args, CREATE_FLAGS)
+        slug = require_slug!(positional, 'fp projects create <slug> --name "<Name>" [--description "..."] [--surfaces api,web]')
+
+        # The slug is the project's permanent key and the name is what people see. Let
+        # `fp projects create calib-rate` work on its own: the name defaults to the slug
+        # and can be fixed up later with `fp projects edit`.
+        params = { slug: slug, name: opts[:name] || slug }
+        params[:description] = opts[:description] if opts[:description]
+
+        surfaces = split_list(opts[:surfaces])
+        params[:surfaces] = surfaces unless surfaces.empty?
+
+        result = client.create_project(params)
+
+        unless result[:ok]
+          output.error(result[:error], status: result[:status])
+          exit 1
+        end
+
+        project = result[:data]['project'] || {}
+        created_surfaces = (result[:data]['surfaces'] || []).map { |s| s['key'] }
+
+        output.success(result[:data]) do
+          puts "Created project '#{project['slug'] || slug}'."
+          puts
+          puts "  Name:     #{project['name']}"
+          puts "  Slug:     #{project['slug'] || slug}"
+          puts "  Surfaces: #{created_surfaces.empty? ? '(none yet)' : created_surfaces.join(', ')}"
+          puts
+          puts 'Next:'
+          puts "  fp surfaces add <key> --project #{project['slug'] || slug} --name \"<Name>\"" if created_surfaces.empty?
+          puts "  fp init --project #{project['slug'] || slug} --surface <key>   # onboard a repo"
+        end
+      end
+
+      def edit(args)
+        opts, positional = parse_flags(args, EDIT_FLAGS)
+        slug = require_slug!(positional, 'fp projects edit <slug> [--name "..."] [--description "..."]')
+
+        params = {}
+        params[:name] = opts[:name] if opts[:name]
+        params[:description] = opts[:description] if opts.key?(:description)
+
+        if params.empty?
+          output.error('Nothing to change. Pass --name and/or --description.')
+          exit 1
+        end
+
+        project = find_project!(slug)
+        result = client.update_project(project['id'], params)
+
+        unless result[:ok]
+          output.error(result[:error], status: result[:status])
+          exit 1
+        end
+
+        record = result[:data]['project'] || {}
+
+        output.success(result[:data]) do
+          puts "Updated project '#{record['slug'] || slug}'."
+          puts
+          puts "  Name:        #{record['name']}"
+          puts "  Description: #{blank?(record['description']) ? '(none)' : record['description']}"
+        end
+      end
+
+      def delete(args)
+        opts, positional = parse_flags(args, DELETE_FLAGS)
+        slug = require_slug!(positional, 'fp projects delete <slug> [--yes]')
+
+        project = find_project!(slug)
+        confirm_delete!(project, opts)
+
+        result = client.delete_project(project['id'])
+
+        unless result[:ok]
+          output.error(result[:error], status: result[:status])
+          exit 1
+        end
+
+        output.success({ deleted: true, project: { 'id' => project['id'], 'slug' => project['slug'] } }) do
+          puts "Deleted project '#{project['slug']}'."
+        end
+      end
+
+      # The gh-style guard. Three ways through:
+      #   --yes                 → no prompt (scripts, agents, CI)
+      #   interactive terminal  → type the slug back, exactly
+      #   neither               → refuse; a pipeline must say --yes out loud
+      #
+      # The prompt shows what is about to go with the project (surfaces, requirements)
+      # so "the wrong project" is caught by a human reading, not only by typing.
+      def confirm_delete!(project, opts)
+        return if opts[:yes]
+
+        unless interactive?
+          output.error(
+            "Refusing to delete '#{project['slug']}' without confirmation. " \
+            'Re-run with --yes to confirm from a non-interactive session.'
+          )
+          exit 1
+        end
+
+        surfaces = surface_keys_for(project['id'])
+        requirements = requirement_count_for(project['id'])
+
+        warn "This will permanently delete project '#{project['slug']}' (#{project['name']})."
+        warn "  Surfaces:     #{surfaces.empty? ? 'none' : surfaces.join(', ')}"
+        warn "  Requirements: #{requirements.nil? ? 'unknown' : requirements}"
+        warn 'Its requirements, evidence, and memberships will no longer be reachable.'
+        $stderr.print "Type '#{project['slug']}' to confirm: "
+        $stderr.flush
+
+        typed = $stdin.gets&.strip
+        return if typed == project['slug']
+
+        output.error('Aborted. The slug did not match; nothing was deleted.')
+        exit 1
+      end
+
+      def interactive?
+        $stdin.respond_to?(:tty?) && $stdin.tty?
+      end
+
+      # --- helpers ----------------------------------------------------------
+
+      def require_slug!(positional, usage)
+        slug = positional.first
+        if slug.nil? || slug.strip.empty?
+          output.error("Usage: #{usage}")
+          exit 1
+        end
+        slug.strip
+      end
+
+      # The project record (not just its id) by slug or id, or exit 1. Mirrors
+      # Base#resolve_project_id, but the commands here print name/slug too.
+      def find_project!(slug_or_id)
+        result = client.list_projects
+        unless result[:ok]
+          output.error(result[:error], status: result[:status])
+          exit 1
+        end
+
+        projects = result[:data]['projects'] || []
+        project = projects.find { |w| w['slug'] == slug_or_id || w['id'] == slug_or_id }
+
+        unless project
+          output.error("Project '#{slug_or_id}' not found")
+          exit 1
+        end
+
+        project
+      end
+
+      def surface_keys_for(project_id)
+        result = client.list_surfaces(project_id)
+        return [] unless result[:ok]
+
+        (result[:data]['surfaces'] || []).map { |s| s['key'] }
+      end
+
+      # Nil when the read fails — the confirmation prompt says "unknown" rather than
+      # claiming a project is empty.
+      def requirement_count_for(project_id)
+        result = client.list_requirements(project_id: project_id)
+        return nil unless result[:ok]
+
+        (result[:data]['requirements'] || []).size
+      end
+
+      def print_project(project, surfaces)
+        name = project['name'] || project['slug'].to_s
+        puts name
+        puts '=' * name.length
+        puts
+        puts "Slug:         #{project['slug']}"
+        puts "Description:  #{blank?(project['description']) ? '(none)' : project['description']}"
+        puts "Enforcement:  #{project['enforcement_level']}" if project['enforcement_level']
+        puts "Surfaces:     #{surfaces.empty? ? '(none)' : surfaces.join(', ')}"
+
+        vocabulary = Array(project['test_type_vocabulary'])
+        puts "Test types:   #{vocabulary.join(', ')}" unless vocabulary.empty?
+        defaults = Array(project['default_test_types'])
+        puts "Default types: #{defaults.join(', ')}" unless defaults.empty?
+
+        puts
+        puts "ID:           #{project['id']}" if project['id']
+        puts "Created:      #{project['created_at']}" if project['created_at']
+        puts "Updated:      #{project['updated_at']}" if project['updated_at']
+      end
+
+      def split_list(value)
+        return [] if value.nil? || value == true
+
+        value.to_s.split(',').map(&:strip).reject(&:empty?)
+      end
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
     end
   end
 end

data/lib/fp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fp
-  VERSION = '0.0.19'
+  VERSION = '0.0.20'
 end

data/skills/fp/SKILL.md

@@ -352,6 +352,19 @@ FeatureParity section in `AGENTS.md`):
 fp init --project <slug> --surface <surface>
 ```
 
+If the project itself doesn't exist yet, create it first — you don't need a human to do
+this in the web app. The project lands on the account of whoever minted your key, and
+your key reaches it immediately:
+
+```bash
+fp projects create <slug> --name "<Name>" --surfaces api,web
+```
+
+Creation is subject to the owner's plan allowance; a free account gets one project, and
+the command relays the upgrade message if that's used up. `fp projects delete` exists but
+asks a human to type the slug back (or `--yes` in scripts) and is owner-only — don't reach
+for it to tidy up; a project's requirements, evidence, and history go with it.
+
 ### Triage requirement quality (`fp analyze`)
 
 `fp analyze` checks how well requirements are written and whether they belong in the
@@ -404,6 +417,8 @@ not as the fix — you still write the proposal.
 | View matrix | `fp matrix --project X` |
 | List surfaces | `fp surfaces --project X` |
 | List projects | `fp projects` |
+| Create a project | `fp projects create <slug> --name "..." --surfaces api,web` |
+| View / edit a project | `fp projects show <slug>`, `fp projects edit <slug> --name "..."` |
 
 All commands support `--json` for machine-readable output.
 

data/skills/fp/references/cli.md

@@ -29,13 +29,29 @@ fp setup --api-key fp_... --profile ci      # Named profile
 
 ### fp projects
 
-List accessible projects.
+List accessible projects, or view, create, edit and delete one.
 
 ```bash
-fp projects
+fp projects                       # list
 fp projects --json
+fp projects show <slug>           # details + surfaces
+fp projects create <slug> --name "Name" [--description "..."] [--surfaces api,web]
+fp projects edit <slug> [--name "..."] [--description "..."]
+fp projects delete <slug> [--yes]
 ```
 
+`create` is open to agents: the project is owned by the human who minted the key
+(it counts against *their* plan allowance — a free account gets one project, and the
+command relays the server's upgrade message if that's used up), and the same key reaches
+the new project on its next call. `--name` defaults to the slug. `--surfaces` takes
+surface names, comma-separated; each becomes a surface with a derived key and default
+kind/audience, the same as `fp surfaces add` without flags.
+
+`delete` is guarded the way `gh repo delete` is. In a terminal it shows the project's
+surfaces and requirement count and asks you to type the slug back; a mismatch aborts.
+Outside a terminal it refuses unless `--yes` is passed. Server-side, only a project
+owner — or a key minted by one — may delete; a member's key gets 403.
+
 ### fp surfaces
 
 List surfaces for a project.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: featureparity
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.20
 platform: ruby
 authors:
 - Stowzilla