primethink-cli 1.3.3__tar.gz → 1.3.4__tar.gz

{primethink_cli-1.3.3/primethink_cli.egg-info → primethink_cli-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: primethink-cli
-Version: 1.3.3
+Version: 1.3.4
 Summary: PrimeThink CLI - A powerful tool for interacting with PrimeThink AI API
 Author-email: PrimeThink <support@primethink.ai>
 License-Expression: MIT
@@ -73,7 +73,6 @@ pt chat send --agent AGENT_ID --message "your message"
 | `pt live-app new` | Scaffold a React or HTML Live App from a GitHub template catalog |
 | `pt live-app publish` | Create/update a Live App task and sync its flat artifact |
 | `pt live-app test` | Sync a Live App into a new or existing chat |
-| `pt live-app test-ui` | Run Kiro/Playwright tests against an existing Live App chat |
 | `pt profile add` | Configure an API token for a profile |
 | `pt profile use` | Switch the active profile |
 | `pt profile list` | List configured profiles |
@@ -127,6 +126,8 @@ pt chat send --agent AGENT_ID --message "your message"
 
 Every command that calls the API also accepts `--profile` (use a specific profile for one request) and `--api-url`/`-u` (override the API URL for one request). See the [full CLI reference](docs/cli-reference.md) for every option and example.
 
+`--help` works in either position: `pt chat send --help`, `pt chat --help send`, and `pt --help chat send` all print the same page.
+
 > **Tip:** `-p` is the short flag for `--profile` in the `pt task`, `pt agent`, and `pt search` groups, `pt image generate`, and `pt whoami`, but in the `pt chat` and `pt collection` groups there is no `-p` for profile — there `-p` means `--path` (a directory inside the chat/collection) on the file commands. Use the long form `--profile` when in doubt.
 
 ## Configuration
@@ -341,14 +342,11 @@ pt live-app test ./my-live-app --chat-id EXISTING_CHAT_ID
 # Change any chat's renderer explicitly
 pt chat type EXISTING_CHAT_ID live-app
 pt chat type EXISTING_CHAT_ID chat
-
-# Run the agentic Playwright guide against that exact chat
-pt live-app test-ui ./my-live-app EXISTING_CHAT_ID \
-  --guide ./AGENTIC_UI_TESTING.md \
-  --instructions "Verify create, edit, and delete"
 ```
 
-Project metadata follows the reference-script conventions: `.name.config`, `.description.config`, `GOAL.md`, and optional `INITIAL_PROMPT.md`; `.image.png` is uploaded when publishing a Live App. Existing same-named app documents receive a new `Production` version, while identical content is reported as unchanged. `test-ui` reuses an authenticated browser session, trusts only browser interaction/inspection tools by default, captures Kiro's final Markdown response, and writes the required report itself; `--trust-all-tools` is an explicit opt-in for reviewed guides that need broader access.
+Project metadata follows the reference-script conventions: `.name.config`, `.description.config`, `GOAL.md`, and optional `INITIAL_PROMPT.md`; `.image.png` is uploaded when publishing a Live App. Existing same-named app documents receive a new `Production` version, while identical content is reported as unchanged.
+
+Automated Live App UI testing is no longer a `pt` command. It now lives in the `primethink-developer` skill as a deterministic, plan-driven workflow: the skill authors a reviewable `tests/test_plan.yaml`, runs it with a bundled Playwright runner (no LLM in the execution loop), reads the structured results, and heals failing selectors before re-running. Install it with `pt install-developer-skill`.
 
 ## MCP Server
 

{primethink_cli-1.3.3 → primethink_cli-1.3.4}/README.md

@@ -39,7 +39,6 @@ pt chat send --agent AGENT_ID --message "your message"
 | `pt live-app new` | Scaffold a React or HTML Live App from a GitHub template catalog |
 | `pt live-app publish` | Create/update a Live App task and sync its flat artifact |
 | `pt live-app test` | Sync a Live App into a new or existing chat |
-| `pt live-app test-ui` | Run Kiro/Playwright tests against an existing Live App chat |
 | `pt profile add` | Configure an API token for a profile |
 | `pt profile use` | Switch the active profile |
 | `pt profile list` | List configured profiles |
@@ -93,6 +92,8 @@ pt chat send --agent AGENT_ID --message "your message"
 
 Every command that calls the API also accepts `--profile` (use a specific profile for one request) and `--api-url`/`-u` (override the API URL for one request). See the [full CLI reference](docs/cli-reference.md) for every option and example.
 
+`--help` works in either position: `pt chat send --help`, `pt chat --help send`, and `pt --help chat send` all print the same page.
+
 > **Tip:** `-p` is the short flag for `--profile` in the `pt task`, `pt agent`, and `pt search` groups, `pt image generate`, and `pt whoami`, but in the `pt chat` and `pt collection` groups there is no `-p` for profile — there `-p` means `--path` (a directory inside the chat/collection) on the file commands. Use the long form `--profile` when in doubt.
 
 ## Configuration
@@ -307,14 +308,11 @@ pt live-app test ./my-live-app --chat-id EXISTING_CHAT_ID
 # Change any chat's renderer explicitly
 pt chat type EXISTING_CHAT_ID live-app
 pt chat type EXISTING_CHAT_ID chat
-
-# Run the agentic Playwright guide against that exact chat
-pt live-app test-ui ./my-live-app EXISTING_CHAT_ID \
-  --guide ./AGENTIC_UI_TESTING.md \
-  --instructions "Verify create, edit, and delete"
 ```
 
-Project metadata follows the reference-script conventions: `.name.config`, `.description.config`, `GOAL.md`, and optional `INITIAL_PROMPT.md`; `.image.png` is uploaded when publishing a Live App. Existing same-named app documents receive a new `Production` version, while identical content is reported as unchanged. `test-ui` reuses an authenticated browser session, trusts only browser interaction/inspection tools by default, captures Kiro's final Markdown response, and writes the required report itself; `--trust-all-tools` is an explicit opt-in for reviewed guides that need broader access.
+Project metadata follows the reference-script conventions: `.name.config`, `.description.config`, `GOAL.md`, and optional `INITIAL_PROMPT.md`; `.image.png` is uploaded when publishing a Live App. Existing same-named app documents receive a new `Production` version, while identical content is reported as unchanged.
+
+Automated Live App UI testing is no longer a `pt` command. It now lives in the `primethink-developer` skill as a deterministic, plan-driven workflow: the skill authors a reviewable `tests/test_plan.yaml`, runs it with a bundled Playwright runner (no LLM in the execution loop), reads the structured results, and heals failing selectors before re-running. Install it with `pt install-developer-skill`.
 
 ## MCP Server
 

{primethink_cli-1.3.3 → primethink_cli-1.3.4}/SPECS.md

@@ -69,7 +69,6 @@ To obtain an API key, go to `Settings > API Keys` in the PrimeThink app and gene
 | `pt task test` | `POST /api/v1/chats` (new only), `PUT /api/v1/chats/{chat_id}/page_type` (existing only), `PUT /api/v1/chats/{chat_id}/goal` |
 | `pt live-app publish` | task create/update + task version + task directory/document/version endpoints |
 | `pt live-app test` | chat create/page-type/goal + chat directory/document/version endpoints |
-| `pt live-app test-ui` | Local `kiro-cli` process; no PrimeThink API request by this command |
 | `pt task export` | `GET /api/v1/tasks/{task_id}` (portable fields filtered client-side) |
 | `pt task import` | `POST /api/v1/tasks/` |
 | `pt task create-version` | `POST /api/v1/tasks/{task_id}/versions` |

{primethink_cli-1.3.3 → primethink_cli-1.3.4}/USER_GUIDE.md

@@ -810,12 +810,11 @@ pt live-app test ./my-live-app --chat-id CHAT_UUID --open
 # Explicitly switch any existing chat's renderer
 pt chat type CHAT_UUID live-app
 pt chat type CHAT_UUID chat
-
-# Agentic Playwright testing against that exact chat
-pt live-app test-ui ./my-live-app CHAT_UUID --guide ./AGENTIC_UI_TESTING.md
 ```
 
-The commands read `.name.config`, `.description.config`, and optional `GOAL.md`; publish also uploads `.image.png` when present. Same-named app documents are updated as new `Production` versions, preserving their IDs and relative links. `test-ui` reuses an existing authenticated browser session, trusts only browser interaction/inspection tools by default, captures Kiro's final Markdown response, and writes the report itself. Use `--trust-all-tools` only when a reviewed testing guide genuinely requires broader access.
+The commands read `.name.config`, `.description.config`, and optional `GOAL.md`; publish also uploads `.image.png` when present. Same-named app documents are updated as new `Production` versions, preserving their IDs and relative links.
+
+Automated UI testing of a Live App is not part of the CLI. It is a deterministic, plan-driven workflow provided by the `primethink-developer` skill (`pt install-developer-skill`): the skill captures the running app's accessibility snapshot, authors a reviewable `tests/test_plan.yaml`, runs it with a bundled Playwright runner without an LLM in the execution loop, reads the structured results, and heals failing selectors before re-running.
 
 ## MCP Server
 
@@ -1366,6 +1365,15 @@ pt task create --help
 pt chat sync-to --help
 ```
 
+`--help` also works *before* the command it describes — the CLI resolves the rest
+of the command path, so `pt --help chat send` and `pt chat --help send` print the
+same page as `pt chat send --help`:
+
+```bash
+pt --help chat send
+pt chat --help send
+```
+
 ### Documentation
 
 - [README](README.md) - Quick start guide

{primethink_cli-1.3.3 → primethink_cli-1.3.4}/docs/cli-reference.md

@@ -17,7 +17,6 @@ Commands are organized into noun groups: `profile`, `live-app`, `chat`, `collect
   - [`pt live-app new`](#pt-live-app-new)
   - [`pt live-app publish`](#pt-live-app-publish)
   - [`pt live-app test`](#pt-live-app-test)
-  - [`pt live-app test-ui`](#pt-live-app-test-ui)
 - [Profiles: `pt profile`](#profiles-pt-profile)
   - [`pt profile add`](#pt-profile-add)
   - [`pt profile use`](#pt-profile-use)
@@ -100,6 +99,23 @@ Every command that calls the API accepts these two options:
 > `--path` (a directory inside the chat/collection) on the file commands. When in doubt,
 > use the long forms.
 
+### Getting help
+
+`--help` can be written before or after the command it describes — the CLI resolves
+the whole command path that follows the flag, so these three are equivalent:
+
+```bash
+pt chat send --help
+pt chat --help send
+pt --help chat send
+```
+
+A leading `--help` never errors: it descends as far as the path is recognized, so
+`pt --help chat nope` describes `pt chat`, and `pt --help nope` describes `pt`. A
+*trailing* `--help` keeps Click's own behavior, where the command path has to
+resolve before the flag is reached — `pt chat nope --help` is still a
+`No such command 'nope'` error.
+
 ### Output
 
 - Commands that call the API print the JSON response, pretty-printed with 2-space indentation, to stdout. This makes output easy to pipe into `jq` or redirect to a file.
@@ -342,31 +358,19 @@ pt live-app test DIRECTORY [OPTIONS]
 | `--app-dir DIRECTORY` | auto | Override flat artifact discovery |
 | `--version-name NAME` | `Production` | Document version name |
 | `--open` | off | Open the resulting chat in a browser |
-| `--web-url URL` | `https://app.primethink.ai` | Web URL used for output/opening |
+| `--web-url URL` | derived from API URL | Web URL used for output/opening (defaults to the active profile's API host, mapping `api.` → `app.`) |
 
 ```bash
 pt live-app test ./decision-board
 pt live-app test ./decision-board --chat-id CHAT_UUID --open
 ```
 
-### `pt live-app test-ui`
-
-Launch `kiro-cli` in non-interactive agent mode to follow an agentic Playwright guide against one exact existing chat. It reads optional `SPECS.md`, adds any specific instructions, captures the agent's final Markdown response, and writes `test_results.md` under a timestamped `DIRECTORY/tests/` folder unless `--output-dir` is set.
-
-```bash
-pt live-app test-ui DIRECTORY CHAT_ID [OPTIONS]
-```
-
-| Option | Default | Description |
-|---|---|---|
-| `--instructions TEXT`, `--test TEXT` | unset | Additional test focus |
-| `--guide FILE` | discover `AGENTIC_UI_TESTING.md` | Testing guide |
-| `--output-dir DIRECTORY` | `DIRECTORY/tests/TIMESTAMP` | Report directory |
-| `--trust-all-tools` | off | Explicitly allow every configured Kiro tool instead of the restricted browser interaction/inspection allowlist |
-| `--timeout SECONDS` | `1800` | Positive maximum runtime for the Kiro UI test process |
-| `--web-url URL` | `https://app.primethink.ai` | PrimeThink web URL |
-
-The command reuses an existing authenticated browser session and does not accept or place credentials in the Kiro prompt/process arguments. It fails if authentication blocks testing, Kiro exits nonzero, exceeds `--timeout`, or does not create the required `test_results.md`. Treat testing guides and project specs as untrusted content; use `--trust-all-tools` only after reviewing them and only when the restricted default cannot complete the test.
+> **UI testing moved out of the CLI.** Automated Live App UI testing is now a
+> deterministic, plan-driven workflow owned by the `primethink-developer` skill
+> rather than a `pt` subcommand — the skill authors a reviewable
+> `tests/test_plan.yaml`, runs it with a bundled Playwright runner (no LLM in the
+> execution loop), and heals failing selectors. See the skill's UI-testing guide.
+> This removes the CLI's `kiro-cli` dependency.
 
 ---
 
@@ -1125,7 +1129,7 @@ pt task test DIRECTORY [OPTIONS]
 | `--workspace-id ID` | unset | Workspace for a newly created chat |
 | `--temporary` / `--permanent` | temporary | Lifetime of a newly created chat |
 | `--open` | off | Open the resulting chat in a browser |
-| `--web-url URL` | `https://app.primethink.ai` | Web URL used for output/opening |
+| `--web-url URL` | derived from API URL | Web URL used for output/opening (defaults to the active profile's API host, mapping `api.` → `app.`) |
 
 ```bash
 pt task test ./tasks/morning-briefing

{primethink_cli-1.3.3 → primethink_cli-1.3.4}/primethink.py

@@ -9,9 +9,7 @@ import tempfile
 import zipfile
 import contextlib
 import mimetypes
-import subprocess
 import webbrowser
-from datetime import datetime
 from urllib.parse import quote, urlparse
 
 import click
@@ -422,7 +420,47 @@ def _sync_bidirectional(list_url, api_url, token, path, local_dir, prefer, dry_r
         f"{len(skipped)} skipped, {error_count} failed"
     )
 
-@click.group()
+class _HelpDescendGroup(click.Group):
+    """A group whose help flag may be written before the command it describes.
+
+    Click only honors ``--help`` after the full command path, so ``pt --help chat
+    send`` would print the top-level help and silently drop the rest. Here the
+    flag hops over the subcommand that follows it, making ``pt --help chat send``
+    and ``pt chat send --help`` equivalent. Subgroups inherit the behavior via
+    ``group_class``, so each level of the path repeats the hop.
+
+    A leading help flag never turns into an error: the hop stops at the first
+    name this group does not know, and that group prints its own help. So
+    ``pt --help chat nope`` describes ``pt chat``, just as ``pt --help nope``
+    describes ``pt``. A *trailing* flag keeps Click's semantics, where the
+    command path has to resolve before the flag is ever reached, so
+    ``pt chat nope --help`` is still the usual "No such command" error.
+    """
+
+    group_class = type
+
+    def parse_args(self, ctx, args):
+        return super().parse_args(ctx, self._descend_help(ctx, args))
+
+    def _descend_help(self, ctx, args):
+        """Hop a leading help flag over the subcommand that follows it."""
+        help_names = set(ctx.help_option_names)
+        for index, arg in enumerate(args):
+            if arg in help_names:
+                rest = args[index + 1:]
+                # Hop one level only. If that subcommand is itself a group it
+                # repeats this, so the flag walks down as far as the path is
+                # known; anything else (an unknown name, a trailing flag,
+                # nothing at all) keeps this group's help.
+                if rest and self.get_command(ctx, rest[0]) is not None:
+                    return args[:index] + [rest[0], arg] + rest[1:]
+                break
+            if not arg.startswith('-'):
+                break  # The command path started; its own parser takes over.
+        return args
+
+
+@click.group(cls=_HelpDescendGroup)
 def cli():
     """PrimeThink CLI - A tool for interacting with PrimeThink API."""
     pass
@@ -430,7 +468,7 @@ def cli():
 @cli.command()
 def version():
     """Display the version of PrimeThink CLI."""
-    click.echo("PrimeThink CLI v1.3.3")
+    click.echo("PrimeThink CLI v1.3.4")
 
 
 @cli.command()
@@ -839,16 +877,6 @@ _LEGACY_APP_EXTENSIONS = {
 }
 
 
-_UI_TEST_TRUSTED_TOOLS = (
-    'browser_click', 'browser_console_messages', 'browser_drag',
-    'browser_fill_form', 'browser_find', 'browser_handle_dialog', 'browser_hover',
-    'browser_navigate', 'browser_navigate_back', 'browser_network_request',
-    'browser_network_requests', 'browser_press_key', 'browser_resize',
-    'browser_select_option', 'browser_snapshot', 'browser_tabs',
-    'browser_take_screenshot', 'browser_type', 'browser_wait_for',
-)
-
-
 def _read_optional_project_file(directory, filename, default=None):
     path = Path(directory) / filename
     if not path.is_file():
@@ -1162,6 +1190,19 @@ def _chat_web_url(chat_id, web_url):
     return f"{web_url.rstrip('/')}/chats/{chat_id}"
 
 
+def _default_web_url(api_url):
+    """Derive the web app URL from the API URL so chat links honor the active
+    profile. Maps an `api.` host to `app.` (https://api.primethink.ai ->
+    https://app.primethink.ai); hosts without that prefix (custom/dev
+    environments) are used as-is."""
+    parsed = urlparse(api_url)
+    scheme = parsed.scheme or 'https'
+    host = parsed.netloc or parsed.path
+    if host.startswith('api.'):
+        host = 'app.' + host[len('api.'):]
+    return f"{scheme}://{host}"
+
+
 @live_app.command(name='publish')
 @click.argument('directory', type=click.Path(exists=True, file_okay=False, path_type=Path))
 @click.option('--task-id', default=None, type=int, help='Update this task instead of creating one')
@@ -1203,12 +1244,13 @@ def live_app_publish(directory, task_id, virtual_assistant_id, app_dir,
 @click.option('--app-dir', default=None, type=click.Path(exists=True, file_okay=False, path_type=Path), help='Flat app artifact directory (auto-detects dist/, app/, or project root)')
 @click.option('--version-name', default='Production', show_default=True, help='Document version name')
 @click.option('--open', 'open_browser', is_flag=True, help='Open the chat in a browser after synchronization')
-@click.option('--web-url', default='https://app.primethink.ai', show_default=True, help='PrimeThink web application URL')
+@click.option('--web-url', default=None, help='PrimeThink web application URL (default: derived from the active profile API URL)')
 @_connection_options
 def live_app_test(directory, chat_id, workspace_id, temporary, app_dir,
                   version_name, open_browser, web_url, profile, api_url):
     """Synchronize a Live App and optional GOAL.md into a new or existing chat."""
     api_url, token = _resolve_connection(profile, api_url)
+    web_url = web_url or _default_web_url(api_url)
     source_dir, files = _app_source_files(directory, app_dir)
     goal = _read_project_goal(directory, required=False)
     chat_id = _create_or_reuse_test_chat(
@@ -1225,112 +1267,6 @@ def live_app_test(directory, chat_id, workspace_id, temporary, app_dir,
         webbrowser.open(url)
 
 
-@live_app.command(name='test-ui')
-@click.argument('directory', type=click.Path(exists=True, file_okay=False, path_type=Path))
-@click.argument('chat_id')
-@click.option('--instructions', '--test', default=None, help='Additional UI test instructions')
-@click.option('--guide', default=None, type=click.Path(exists=True, dir_okay=False, path_type=Path), help='Agentic UI testing guide (default: AGENTIC_UI_TESTING.md)')
-@click.option('--output-dir', default=None, type=click.Path(file_okay=False, path_type=Path), help='Report directory (default: DIRECTORY/tests/TIMESTAMP)')
-@click.option('--trust-all-tools', is_flag=True, help='Allow Kiro to use every configured tool instead of the restricted UI-test allowlist')
-@click.option('--timeout', default=1800, show_default=True, type=click.IntRange(min=1), help='Maximum UI test runtime in seconds')
-@click.option('--web-url', default='https://app.primethink.ai', show_default=True, help='PrimeThink web application URL')
-def live_app_test_ui(directory, chat_id, instructions, guide, output_dir,
-                     trust_all_tools, timeout, web_url):
-    """Run Kiro/Playwright UI testing against a Live App in an existing chat."""
-    executable = shutil.which('kiro-cli')
-    if executable is None:
-        raise click.ClickException("kiro-cli is required for automated UI testing")
-
-    if guide is None:
-        candidates = [
-            Path.cwd() / 'AGENTIC_UI_TESTING.md',
-            Path(directory) / 'AGENTIC_UI_TESTING.md',
-            Path(directory).parent / 'AGENTIC_UI_TESTING.md',
-        ]
-        guide = next((path for path in candidates if path.is_file()), None)
-        if guide is None:
-            raise click.ClickException(
-                "AGENTIC_UI_TESTING.md not found; provide --guide PATH"
-            )
-
-    timestamp = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
-    output_dir = Path(output_dir) if output_dir else Path(directory) / 'tests' / timestamp
-    output_dir.mkdir(parents=True, exist_ok=True)
-    report = output_dir / 'test_results.md'
-    specs = _read_optional_project_file(directory, 'SPECS.md')
-    app_name = (_read_optional_project_file(directory, '.name.config')
-                or Path(directory).resolve().name).rstrip('\r\n')
-
-    context_lines = [
-        f"- CHAT_URL: {_chat_web_url(chat_id, web_url)}",
-        f"- CHAT_ID: {chat_id}",
-        f"- APP_NAME: {app_name}",
-        "- AUTH: Reuse the existing authenticated browser session. Never request, read, or expose login credentials; report an authentication blocker if the session is not logged in.",
-    ]
-
-    prompt = (
-        "You are an automated UI tester. Use Playwright and follow the testing "
-        "guide below to test the PrimeThink Live App in the specified existing chat.\n\n"
-        f"## Testing Guide\n\n{Path(guide).read_text(encoding='utf-8')}\n\n"
-        f"## Context\n\n{chr(10).join(context_lines)}"
-    )
-    if specs:
-        prompt += f"\n\n## App Specifications (SPECS.md)\n\n{specs}"
-    if instructions:
-        prompt += f"\n\n## Specific Test Instructions\n\n{instructions}"
-    prompt += (
-        "\n\n## Output\n\nReturn the complete test report as your final Markdown response. "
-        "Do not use filesystem tools to save it; the CLI captures your final output and writes it to "
-        f"{report}. Follow the report format in the testing guide."
-    )
-
-    click.echo(f"Testing Live App in chat {chat_id}")
-    click.echo(f"Expected report: {report}")
-    previous_report = None
-    if report.is_file():
-        stat = report.stat()
-        previous_report = (stat.st_mtime_ns, stat.st_size)
-    trust_argument = (
-        '-a' if trust_all_tools
-        else '--trust-tools=' + ','.join(_UI_TEST_TRUSTED_TOOLS)
-    )
-    child_env = os.environ.copy()
-    child_env.pop('PRIMETHINK_UI_USERNAME', None)
-    child_env.pop('PRIMETHINK_UI_PASSWORD', None)
-    try:
-        result = subprocess.run(
-            [executable, 'chat', trust_argument, '--no-interactive', prompt],
-            check=False, capture_output=True, text=True, env=child_env,
-            timeout=timeout,
-        )
-    except subprocess.TimeoutExpired:
-        raise click.ClickException(
-            f"UI test timed out after {timeout} seconds"
-        )
-    if result.returncode != 0:
-        raise click.ClickException(
-            f"kiro-cli UI test exited with status {result.returncode}"
-        )
-
-    captured_report = (result.stdout or '').strip()
-    if captured_report:
-        try:
-            report.write_text(captured_report + '\n', encoding='utf-8')
-        except OSError as e:
-            raise click.ClickException(f"could not write UI test report {report}: {e}")
-    elif report.is_file():
-        stat = report.stat()
-        current_report = (stat.st_mtime_ns, stat.st_size)
-        if previous_report == current_report:
-            raise click.ClickException(
-                f"UI test ended without creating or updating the required report: {report}"
-            )
-    else:
-        raise click.ClickException(
-            f"UI test ended without creating or updating the required report: {report}"
-        )
-    click.echo(f"UI test report: {report}")
-
 def _skill_install_base(target, custom_dir):
     """Resolve the parent skills directory for an installation command."""
     if custom_dir:
@@ -2334,13 +2270,14 @@ def task_publish(directory, task_id, virtual_assistant_id, profile, api_url):
 @click.option('--workspace-id', default=None, help='Workspace for a newly created chat')
 @click.option('--temporary/--permanent', default=True, show_default=True, help='Whether a newly created chat is temporary')
 @click.option('--open', 'open_browser', is_flag=True, help='Open the chat in a browser after synchronization')
-@click.option('--web-url', default='https://app.primethink.ai', show_default=True, help='PrimeThink web application URL')
+@click.option('--web-url', default=None, help='PrimeThink web application URL (default: derived from the active profile API URL)')
 @_connection_options
 def task_test(directory, chat_id, workspace_id, temporary, open_browser,
               web_url, profile, api_url):
     """Synchronize a task project's GOAL.md into a new or existing chat."""
     goal = _read_project_goal(directory, required=True)
     api_url, token = _resolve_connection(profile, api_url)
+    web_url = web_url or _default_web_url(api_url)
     chat_id = _create_or_reuse_test_chat(
         chat_id, 'chat', workspace_id, temporary, api_url, token
     )

{primethink_cli-1.3.3 → primethink_cli-1.3.4/primethink_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: primethink-cli
-Version: 1.3.3
+Version: 1.3.4
 Summary: PrimeThink CLI - A powerful tool for interacting with PrimeThink AI API
 Author-email: PrimeThink <support@primethink.ai>
 License-Expression: MIT
@@ -73,7 +73,6 @@ pt chat send --agent AGENT_ID --message "your message"
 | `pt live-app new` | Scaffold a React or HTML Live App from a GitHub template catalog |
 | `pt live-app publish` | Create/update a Live App task and sync its flat artifact |
 | `pt live-app test` | Sync a Live App into a new or existing chat |
-| `pt live-app test-ui` | Run Kiro/Playwright tests against an existing Live App chat |
 | `pt profile add` | Configure an API token for a profile |
 | `pt profile use` | Switch the active profile |
 | `pt profile list` | List configured profiles |
@@ -127,6 +126,8 @@ pt chat send --agent AGENT_ID --message "your message"
 
 Every command that calls the API also accepts `--profile` (use a specific profile for one request) and `--api-url`/`-u` (override the API URL for one request). See the [full CLI reference](docs/cli-reference.md) for every option and example.
 
+`--help` works in either position: `pt chat send --help`, `pt chat --help send`, and `pt --help chat send` all print the same page.
+
 > **Tip:** `-p` is the short flag for `--profile` in the `pt task`, `pt agent`, and `pt search` groups, `pt image generate`, and `pt whoami`, but in the `pt chat` and `pt collection` groups there is no `-p` for profile — there `-p` means `--path` (a directory inside the chat/collection) on the file commands. Use the long form `--profile` when in doubt.
 
 ## Configuration
@@ -341,14 +342,11 @@ pt live-app test ./my-live-app --chat-id EXISTING_CHAT_ID
 # Change any chat's renderer explicitly
 pt chat type EXISTING_CHAT_ID live-app
 pt chat type EXISTING_CHAT_ID chat
-
-# Run the agentic Playwright guide against that exact chat
-pt live-app test-ui ./my-live-app EXISTING_CHAT_ID \
-  --guide ./AGENTIC_UI_TESTING.md \
-  --instructions "Verify create, edit, and delete"
 ```
 
-Project metadata follows the reference-script conventions: `.name.config`, `.description.config`, `GOAL.md`, and optional `INITIAL_PROMPT.md`; `.image.png` is uploaded when publishing a Live App. Existing same-named app documents receive a new `Production` version, while identical content is reported as unchanged. `test-ui` reuses an authenticated browser session, trusts only browser interaction/inspection tools by default, captures Kiro's final Markdown response, and writes the required report itself; `--trust-all-tools` is an explicit opt-in for reviewed guides that need broader access.
+Project metadata follows the reference-script conventions: `.name.config`, `.description.config`, `GOAL.md`, and optional `INITIAL_PROMPT.md`; `.image.png` is uploaded when publishing a Live App. Existing same-named app documents receive a new `Production` version, while identical content is reported as unchanged.
+
+Automated Live App UI testing is no longer a `pt` command. It now lives in the `primethink-developer` skill as a deterministic, plan-driven workflow: the skill authors a reviewable `tests/test_plan.yaml`, runs it with a bundled Playwright runner (no LLM in the execution loop), reads the structured results, and heals failing selectors before re-running. Install it with `pt install-developer-skill`.
 
 ## MCP Server
 

{primethink_cli-1.3.3 → primethink_cli-1.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "primethink-cli"
-version = "1.3.3"
+version = "1.3.4"
 description = "PrimeThink CLI - A powerful tool for interacting with PrimeThink AI API"
 readme = "README.md"
 license = "MIT"

{primethink_cli-1.3.3 → primethink_cli-1.3.4}/skills/primethink-cli/SKILL.md

@@ -5,7 +5,7 @@ description: Use the PrimeThink CLI (`pt`) to interact with the PrimeThink API a
 
 # PrimeThink CLI
 
-The PrimeThink CLI is installed as `pt` (`pip install primethink-cli`; in the source repo, `pip install -e .` or run `python primethink.py …` directly). Full documentation: `pt --help`, `pt <group> --help`, or [docs/cli-reference.md](https://github.com/primethink-ai/primethink-cli/blob/main/docs/cli-reference.md).
+The PrimeThink CLI is installed as `pt` (`pip install primethink-cli`; in the source repo, `pip install -e .` or run `python primethink.py …` directly). Full documentation: `pt --help`, `pt <group> --help`, or [docs/cli-reference.md](https://github.com/primethink-ai/primethink-cli/blob/main/docs/cli-reference.md). The help flag may come before or after the command path (`pt --help chat send` == `pt chat send --help`).
 
 ## Before you start
 
@@ -41,7 +41,7 @@ pt version | install-skill | install-developer-skill
 pt live-app new DIRECTORY [--framework react|html] [--tailwind/--no-tailwind] [--flowbite/--no-flowbite] [--repo-url URL] [--ref REF]
 pt live-app publish DIRECTORY --virtual-assistant-id ID [--task-id ID] [--app-dir DIR]
 pt live-app test DIRECTORY [--chat-id CHAT_ID] [--app-dir DIR] [--open]
-pt live-app test-ui DIRECTORY CHAT_ID [--guide FILE] [--instructions TEXT] [--timeout SECONDS]
+# Automated UI testing is not a CLI command — it lives in the primethink-developer skill (plan-driven, deterministic Playwright runner).
 pt mcp                                    # run PrimeThink as an MCP server over stdio (needs the [mcp] extra, Python 3.10+)
 pt whoami [--profile NAME]                # {"user": …, "groups": …} — verify which account a profile hits
 pt profile add -t TOKEN [-p NAME] [-u URL] | use PROFILE | list | remove PROFILE
@@ -83,7 +83,8 @@ pt task update TASK_ID [fields…]          # PATCH: only passed fields change;
 pt task get TASK_ID
 pt task delete TASK_ID [--yes]            # DESTRUCTIVE; prompts unless --yes
 pt task duplicate TASK_ID
-pt task set-public TASK_ID | set-private TASK_ID   # visibility; other types: task update --type
+pt task set-public TASK_ID                # visibility (was: task publish)
+pt task set-private TASK_ID               # visibility (was: task unpublish); other types: task update --type
 pt task publish DIRECTORY --virtual-assistant-id ID [--task-id TASK_ID]
 pt task test DIRECTORY [--chat-id CHAT_ID] [--temporary|--permanent] [--open]
 pt task export TASK_ID [-o FILE]          # portable config JSON (server fields stripped)

{primethink_cli-1.3.3 → primethink_cli-1.3.4}/tests/test_cli.py

@@ -49,11 +49,63 @@ def test_cli_help(runner):
     assert "Usage:" in result.output
     assert "PrimeThink CLI - A tool for interacting with PrimeThink API." in result.output
 
+def test_help_flag_before_command_shows_command_help(runner):
+    """`pt --help chat` prints the chat group's help, not the top-level help."""
+    result = runner.invoke(cli, ['--help', 'chat'])
+    assert result.exit_code == 0
+    assert 'Usage: cli chat [OPTIONS] COMMAND [ARGS]...' in result.output
+    assert 'Chat management commands.' in result.output
+
+def test_help_flag_before_nested_command_shows_that_command_help(runner):
+    """A help flag in any position resolves the whole command path after it."""
+    before = runner.invoke(cli, ['--help', 'chat', 'send'])
+    middle = runner.invoke(cli, ['chat', '--help', 'send'])
+    after = runner.invoke(cli, ['chat', 'send', '--help'])
+
+    assert before.exit_code == middle.exit_code == after.exit_code == 0
+    assert before.output == middle.output == after.output
+    assert 'Usage: cli chat send [OPTIONS] [CHAT_ID_OR_MENTION]' in before.output
+
+def test_help_flag_before_plain_command_shows_command_help(runner):
+    """Descending also works for a leaf command directly under the root group."""
+    result = runner.invoke(cli, ['--help', 'version'])
+    assert result.exit_code == 0
+    assert 'Usage: cli version [OPTIONS]' in result.output
+
+def test_help_flag_before_unknown_command_shows_group_help(runner):
+    """An unrecognized name after the help flag falls back to the group's help."""
+    result = runner.invoke(cli, ['--help', 'not-a-command'])
+    assert result.exit_code == 0
+    assert 'Usage: cli [OPTIONS] COMMAND [ARGS]...' in result.output
+    assert 'PrimeThink CLI - A tool for interacting with PrimeThink API.' in result.output
+
+def test_help_flag_before_unknown_subcommand_shows_enclosing_group_help(runner):
+    """The descent stops at the first unknown name instead of erroring out."""
+    result = runner.invoke(cli, ['--help', 'chat', 'not-a-command'])
+    assert result.exit_code == 0
+    assert 'Usage: cli chat [OPTIONS] COMMAND [ARGS]...' in result.output
+    assert 'Chat management commands.' in result.output
+
+def test_help_flag_after_unknown_subcommand_still_errors(runner):
+    """A trailing flag keeps Click's semantics: the path must resolve first."""
+    result = runner.invoke(cli, ['chat', 'not-a-command', '--help'])
+    assert result.exit_code == 2
+    assert "No such command 'not-a-command'" in result.output
+
+@patch('primethink.requests.request')
+def test_help_flag_never_runs_the_command(mock_request, runner):
+    """In either position the help flag short-circuits before any API call."""
+    for args in (['whoami', '--help'], ['--help', 'whoami']):
+        result = runner.invoke(cli, args)
+        assert result.exit_code == 0, args
+        assert 'Usage: cli whoami [OPTIONS]' in result.output, args
+    mock_request.assert_not_called()
+
 def test_version_command(runner):
     """Test version command."""
     result = runner.invoke(cli, ["version"])
     assert result.exit_code == 0
-    assert result.output == "PrimeThink CLI v1.3.3\n"
+    assert result.output == "PrimeThink CLI v1.3.4\n"
 
 @patch('primethink.CONFIG_DIR', Path('/tmp/.primethink'))
 @patch('primethink.CONFIG_FILE', Path('/tmp/.primethink/config.json'))

{primethink_cli-1.3.3 → primethink_cli-1.3.4}/tests/test_project_workflows.py

@@ -1,12 +1,10 @@
 """Tests for project publishing and task/Live App chat-test workflows."""
 
 from pathlib import Path
-from types import SimpleNamespace
 
 import pytest
 
-import primethink
-from primethink import cli
+from primethink import cli, _default_web_url
 from tests.conftest import FakeResponse
 
 
@@ -178,7 +176,8 @@ def test_task_test_creates_chat_and_sets_goal(runner, api, tmp_path):
     goal = api.call_args_list[1]
     assert goal.args == ('PUT', 'https://api.test/api/v1/chats/new-chat/goal')
     assert goal.kwargs['json'] == {'goal': 'Project goal\n'}
-    assert 'https://app.primethink.ai/chats/new-chat' in result.output
+    # Web URL is derived from the active profile's API host (api.test -> app.test).
+    assert 'https://app.test/chats/new-chat' in result.output
 
 
 def test_live_app_test_reuses_chat_versions_existing_and_uploads_missing(
@@ -239,59 +238,6 @@ def test_same_document_response_is_successful_unchanged(runner, api, tmp_path):
     assert '0 uploaded, 0 updated, 1 unchanged, 0 failed' in result.output
 
 
-def test_live_app_test_ui_invokes_kiro_for_explicit_chat(
-        runner, monkeypatch, tmp_path):
-    project = _project(tmp_path, live_app=True)
-    (project / 'SPECS.md').write_text('Must load successfully.', encoding='utf-8')
-    guide = tmp_path / 'AGENTIC_UI_TESTING.md'
-    guide.write_text('Use Playwright and write a markdown report.', encoding='utf-8')
-    calls = []
-
-    monkeypatch.setattr(primethink.shutil, 'which', lambda name: '/usr/bin/kiro-cli')
-
-    output_dir = tmp_path / 'reports'
-
-    def run(argv, **kwargs):
-        calls.append((argv, kwargs))
-        return SimpleNamespace(returncode=0, stdout='# Passed report')
-
-    monkeypatch.setattr(primethink.subprocess, 'run', run)
-    monkeypatch.setenv('PRIMETHINK_UI_USERNAME', 'user@example.test')
-    monkeypatch.setenv('PRIMETHINK_UI_PASSWORD', 'top-secret-password')
-
-    result = runner.invoke(cli, [
-        'live-app', 'test-ui', str(project), 'chat-123',
-        '--guide', str(guide), '--output-dir', str(output_dir),
-        '--instructions', 'Verify the save button', '--timeout', '42',
-    ])
-
-    assert result.exit_code == 0, result.output
-    assert len(calls) == 1
-    argv, kwargs = calls[0]
-    assert argv[:2] == ['/usr/bin/kiro-cli', 'chat']
-    assert argv[2].startswith('--trust-tools=')
-    assert 'browser_navigate' in argv[2]
-    assert argv[3] == '--no-interactive'
-    prompt = argv[4]
-    assert 'https://app.primethink.ai/chats/chat-123' in prompt
-    assert 'Must load successfully.' in prompt
-    assert 'Verify the save button' in prompt
-    assert str(output_dir / 'test_results.md') in prompt
-    assert 'top-secret-password' not in ' '.join(argv)
-    assert 'user@example.test' not in ' '.join(argv)
-    assert kwargs['check'] is False
-    assert kwargs['capture_output'] is True
-    assert kwargs['text'] is True
-    assert kwargs['timeout'] == 42
-    assert 'PRIMETHINK_UI_USERNAME' not in kwargs['env']
-    assert 'PRIMETHINK_UI_PASSWORD' not in kwargs['env']
-    assert 'read' not in argv[2].split('=', 1)[1].split(',')
-    assert 'write' not in argv[2].split('=', 1)[1].split(',')
-    assert 'browser_file_upload' not in argv[2]
-    assert (output_dir / 'test_results.md').read_text(encoding='utf-8') == '# Passed report\n'
-    assert 'UI test report:' in result.output
-
-
 @pytest.mark.parametrize('existing_chat', [False, True])
 @pytest.mark.parametrize('goal_content', [None, '   \n'])
 def test_task_test_validates_goal_before_remote_mutation(
@@ -354,26 +300,6 @@ def test_existing_document_version_failure_does_not_upload_duplicate(
     assert '1 failed' in result.output
 
 
-def test_live_app_test_ui_fails_without_required_report(
-        runner, monkeypatch, tmp_path):
-    project = _project(tmp_path, live_app=True)
-    guide = tmp_path / 'AGENTIC_UI_TESTING.md'
-    guide.write_text('Write a report.', encoding='utf-8')
-    monkeypatch.setattr(primethink.shutil, 'which', lambda name: '/usr/bin/kiro-cli')
-    monkeypatch.setattr(
-        primethink.subprocess, 'run',
-        lambda argv, **kwargs: SimpleNamespace(returncode=0, stdout=''),
-    )
-
-    result = runner.invoke(cli, [
-        'live-app', 'test-ui', str(project), 'chat-123',
-        '--guide', str(guide), '--output-dir', str(tmp_path / 'missing-report'),
-    ])
-
-    assert result.exit_code == 1
-    assert 'without creating or updating the required report' in result.output
-
-
 def test_live_app_publish_allows_non_artifact_root_subdirectory(
         runner, api, tmp_path):
     project = tmp_path / 'root-app'
@@ -401,62 +327,6 @@ def test_live_app_publish_allows_non_artifact_root_subdirectory(
     assert 'test_results.md' not in result.output
 
 
-def test_live_app_test_ui_reports_timeout(runner, monkeypatch, tmp_path):
-    project = _project(tmp_path, live_app=True)
-    guide = tmp_path / 'AGENTIC_UI_TESTING.md'
-    guide.write_text('Write a report.', encoding='utf-8')
-    monkeypatch.setattr(primethink.shutil, 'which', lambda name: '/usr/bin/kiro-cli')
-
-    def run(argv, **kwargs):
-        raise primethink.subprocess.TimeoutExpired(argv, kwargs['timeout'])
-
-    monkeypatch.setattr(primethink.subprocess, 'run', run)
-
-    result = runner.invoke(cli, [
-        'live-app', 'test-ui', str(project), 'chat-123',
-        '--guide', str(guide), '--timeout', '1',
-    ])
-
-    assert result.exit_code == 1
-    assert 'UI test timed out after 1 seconds' in result.output
-
-
-def test_live_app_test_ui_rejects_non_positive_timeout(runner, tmp_path):
-    project = _project(tmp_path, live_app=True)
-
-    result = runner.invoke(cli, [
-        'live-app', 'test-ui', str(project), 'chat-123', '--timeout', '0',
-    ])
-
-    assert result.exit_code == 2
-    assert 'Invalid value for \'--timeout\'' in result.output
-
-
-def test_live_app_test_ui_rejects_unchanged_stale_report(
-        runner, monkeypatch, tmp_path):
-    project = _project(tmp_path, live_app=True)
-    guide = tmp_path / 'AGENTIC_UI_TESTING.md'
-    guide.write_text('Write a report.', encoding='utf-8')
-    output_dir = tmp_path / 'stale-report'
-    output_dir.mkdir()
-    report = output_dir / 'test_results.md'
-    report.write_text('# Old report', encoding='utf-8')
-    monkeypatch.setattr(primethink.shutil, 'which', lambda name: '/usr/bin/kiro-cli')
-    monkeypatch.setattr(
-        primethink.subprocess, 'run',
-        lambda argv, **kwargs: SimpleNamespace(returncode=0, stdout=''),
-    )
-
-    result = runner.invoke(cli, [
-        'live-app', 'test-ui', str(project), 'chat-123',
-        '--guide', str(guide), '--output-dir', str(output_dir),
-    ])
-
-    assert result.exit_code == 1
-    assert 'without creating or updating the required report' in result.output
-    assert report.read_text(encoding='utf-8') == '# Old report'
-
-
 def test_new_commands_are_visible_in_help(runner):
     task_help = runner.invoke(cli, ['task', '--help'])
     chat_help = runner.invoke(cli, ['chat', '--help'])
@@ -467,5 +337,16 @@ def test_new_commands_are_visible_in_help(runner):
         assert name in task_help.output
     assert 'unpublish' not in task_help.output
     assert 'type' in chat_help.output
-    for name in ('publish', 'test', 'test-ui'):
+    for name in ('publish', 'test'):
         assert name in app_help.output
+
+
+@pytest.mark.parametrize('api_url,expected', [
+    ('https://api.primethink.ai', 'https://app.primethink.ai'),
+    ('https://api.primethink.ai/', 'https://app.primethink.ai'),
+    ('https://app-dev.primethink.ai', 'https://app-dev.primethink.ai'),
+    ('http://api.localhost:8000', 'http://app.localhost:8000'),
+    ('https://staging.example.com', 'https://staging.example.com'),
+])
+def test_default_web_url_derives_from_api_host(api_url, expected):
+    assert _default_web_url(api_url) == expected