sefrone-ai 1.0.0__tar.gz

sefrone_ai-1.0.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: sefrone_ai
+Version: 1.0.0
+Summary: A Python package to provide AI coding assistant helpers for sefrone projects
+Home-page: https://bitbucket.org/sefrone/sefrone_pypi
+Author: Sefrone
+Author-email: contact@sefrone.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+# Sefrone AI
+
+A Python package to provide AI coding assistant helpers for sefrone projects.
+
+It bundles a set of Sefrone workflow skills (`SKILL.md` files) and exports them into a
+target repository, either in Claude Code's layout (`.claude/skills`) or GitHub's layout
+(`.github/skills`).
+
+## Installation
+
+```bash
+pip install sefrone_ai
+```
+
+## Usage
+
+```python
+from sefrone_ai import SkillsManager
+
+# List the skills bundled with this package
+SkillsManager.list_bundled_skills()
+
+# Override skill files for a Claude Code style repo (<target>/.claude/skills/<skill>/SKILL.md)
+SkillsManager.export_claude_skills("path/to/target/repo", overwrite=True)
+
+# Override skill files for a GitHub style repo (<target>/.github/skills/<skill>/SKILL.md)
+SkillsManager.export_github_skills("path/to/target/repo", overwrite=True)
+
+# target_repo_dir is optional; omitting it exports into the current working directory
+SkillsManager.export_claude_skills(overwrite=True)
+```

sefrone_ai-1.0.0/README.md

@@ -0,0 +1,31 @@
+# Sefrone AI
+
+A Python package to provide AI coding assistant helpers for sefrone projects.
+
+It bundles a set of Sefrone workflow skills (`SKILL.md` files) and exports them into a
+target repository, either in Claude Code's layout (`.claude/skills`) or GitHub's layout
+(`.github/skills`).
+
+## Installation
+
+```bash
+pip install sefrone_ai
+```
+
+## Usage
+
+```python
+from sefrone_ai import SkillsManager
+
+# List the skills bundled with this package
+SkillsManager.list_bundled_skills()
+
+# Override skill files for a Claude Code style repo (<target>/.claude/skills/<skill>/SKILL.md)
+SkillsManager.export_claude_skills("path/to/target/repo", overwrite=True)
+
+# Override skill files for a GitHub style repo (<target>/.github/skills/<skill>/SKILL.md)
+SkillsManager.export_github_skills("path/to/target/repo", overwrite=True)
+
+# target_repo_dir is optional; omitting it exports into the current working directory
+SkillsManager.export_claude_skills(overwrite=True)
+```

sefrone_ai-1.0.0/sefrone_ai/__init__.py

@@ -0,0 +1,5 @@
+from .skills_manager import SkillsManager
+
+__all__ = [
+    "SkillsManager",
+]

sefrone_ai-1.0.0/sefrone_ai/skills/db-migration-workflow/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: db-migration-workflow
+description: "Create or update SQL migrations and keep schema bootstrap in sync. Use when: adding columns/tables, dropping columns/indexes, enforcing NOT NULL, backfilling existing data, or updating DbSchema/Schema/init.sql to match migrations."
+---
+
+# DB Migration Workflow
+
+Use this workflow for PostgreSQL schema changes in a repo that follows the `DbSchema/Migrations` + `DbSchema/Schema/init.sql` bootstrap convention (commonly under a `<Something>.Data/DbSchema/` project).
+
+## Locate the Schema Files First
+
+Before making any change, find this repo's actual paths — do not assume a project name:
+
+- Migrations folder: search for a directory named `Migrations` under a `DbSchema` folder (for example `<DataProject>/DbSchema/Migrations`).
+- Bootstrap file: search for `init.sql` under a `DbSchema/Schema` folder.
+- Post-bootstrap file: search for `after_init.sql` next to `init.sql` (may not exist in every repo — if absent, ask whether procedures/triggers live elsewhere).
+
+## Conventions
+
+- Create new migration files in the migrations folder found above; never edit/rewrite old migrations.
+- Use timestamped file names with purpose, for example: YYYYMMDDHHMMSS_update_store_table.sql.
+- Keep SQL style consistent with existing files: uppercase SQL keywords, snake_case column names, one logical change block per statement.
+- Keep init.sql for table declarations only.
+- Put procedures, functions, and triggers in after_init.sql (if the repo has one), not in init.sql.
+- On PostgreSQL 15+, prefer named UNIQUE NULLS NOT DISTINCT constraints over split partial unique indexes when the business rule is one logical uniqueness constraint across nullable columns.
+
+## Steps
+
+1. Identify the target table and current schema state in init.sql and the latest migrations.
+2. Create a new migration (do not rewrite old migrations).
+3. If removing indexed columns, drop related indexes first (prefer IF EXISTS when safe).
+4. For new required columns on existing tables, use safe rollout:
+   - Add column nullable first.
+   - Backfill existing rows.
+   - Set NOT NULL after backfill.
+5. If backfill depends on related data, guard failures with explicit exceptions.
+6. If no rows need backfill, skip update logic safely.
+7. Add/update indexes and foreign keys as needed.
+8. Update init.sql so fresh database bootstrap matches the final table schema.
+9. If the change adds or updates procedures, functions, or triggers, update after_init.sql to keep post-bootstrap database objects in sync.
+
+## Safety Patterns
+
+- Use DO $$ ... $$ blocks for conditional backfills.
+- Use EXISTS checks before heavy updates.
+- Use deterministic row selection for fallback values (for example ORDER BY created_at, id LIMIT 1).
+- Fail fast when required reference data is missing and nulls would violate constraints.
+
+## Common Patterns
+
+### Add nullable then enforce not null
+
+ALTER TABLE my_table
+    ADD COLUMN my_column UUID;
+
+UPDATE my_table
+SET my_column = ...
+WHERE my_column IS NULL;
+
+ALTER TABLE my_table
+    ALTER COLUMN my_column SET NOT NULL;
+
+### Drop index before dropping column
+
+DROP INDEX IF EXISTS idx_my_table_old_column;
+
+ALTER TABLE my_table
+    DROP COLUMN old_column;
+
+### Named uniqueness across nullable columns on PostgreSQL 15+
+
+ALTER TABLE my_table
+    ADD CONSTRAINT unique_my_table_scope_value
+    UNIQUE NULLS NOT DISTINCT (nullable_scope_id, value_id);
+
+Use this when the rule is one logical uniqueness constraint and nullable columns are part of the key.
+
+### Trigger and procedure placement
+
+Keep table DDL in init.sql.
+
+Keep CREATE FUNCTION and CREATE TRIGGER statements in after_init.sql.
+
+## Done Criteria
+
+- New migration file exists with timestamped name.
+- init.sql reflects the same final table shape.
+- Backfill path is safe for existing production data.
+- NOT NULL is only enforced after data is valid.

sefrone_ai-1.0.0/sefrone_ai/skills/decompile-package-workflow/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: decompile-package-workflow
+description: "Decompile any .NET NuGet package or assembly to inspect source-like code. Use when package behavior is unclear, debugging third-party internals, validating DTO/model mappings, or tracing package logic."
+---
+
+# Decompile Package Workflow
+
+Use this workflow when you need to inspect code inside any NuGet package or .NET assembly (`.dll` / `.nupkg`) — third-party or internal.
+
+## Required Tools
+
+- Primary decompiler: `ilspycmd` (installed globally)
+- Fallback IL viewer: `dotnet-ildasm` (installed globally)
+
+Verify tools:
+
+```powershell
+ilspycmd --version
+dotnet-ildasm --version
+```
+
+## Inputs You Need
+
+- Package ID (for example `Newtonsoft.Json`) and version, OR path to a local `.dll`/`.nupkg`.
+- Output folder for decompiled files.
+
+## Find Package Files
+
+Global NuGet cache path:
+
+```powershell
+$pkgRoot = Join-Path $env:USERPROFILE ".nuget/packages"
+$pkgPath = Join-Path $pkgRoot "<package-id-lowercase>/<version>"
+Get-ChildItem $pkgPath -Recurse -Include *.dll
+```
+
+Notes:
+
+- NuGet package folder names are lowercase.
+- Prefer `lib/<tfm>/` assemblies (for example `lib/net8.0/`).
+
+## Fast Decompile (Single Assembly)
+
+To print decompiled C# to terminal:
+
+```powershell
+ilspycmd "<path-to-assembly>.dll"
+```
+
+To dump C# into a folder as a compilable project:
+
+```powershell
+ilspycmd -p --nested-directories -o "<output-folder>" "<path-to-assembly>.dll"
+```
+
+To decompile one specific type only:
+
+```powershell
+ilspycmd -t "Namespace.TypeName" "<path-to-assembly>.dll"
+```
+
+To list available types before selecting one:
+
+```powershell
+ilspycmd -l c "<path-to-assembly>.dll"
+```
+
+## Decompile From .nupkg
+
+If you have a `.nupkg` file directly:
+
+```powershell
+ilspycmd -d -o "<output-folder>" "<path-to-package>.nupkg"
+```
+
+This extracts package assemblies so you can then run `ilspycmd -p` on the extracted `.dll` files.
+
+## Fallback Workflow (IL Only)
+
+If C# decompilation is not possible, inspect IL:
+
+```powershell
+dotnet-ildasm "<path-to-assembly>.dll"
+```
+
+Use this for quick inspection of method signatures and control flow.
+
+## Investigation Tips
+
+- Decompile referenced dependencies too when method bodies are thin wrappers.
+- Confirm Target Framework Moniker (TFM) and pick the matching assembly (for example `net8.0` vs `netstandard2.0`).
+- Decompiled output can differ from original source formatting and local variable names.
+- Prefer behavioral verification (tests/log tracing) before concluding package behavior.
+
+## Safety and Compliance
+
+- Decompiled code may include proprietary logic. Keep usage limited to debugging, compatibility, and internal maintenance.
+- Do not publish or redistribute decompiled third-party source.
+
+## Done Criteria
+
+- Decompiled output exists in an output folder for the target assembly.
+- Relevant type/method has been located and inspected.
+- Findings are documented in task notes with assembly version and TFM used.

sefrone_ai-1.0.0/sefrone_ai/skills/e2e-scenario-flow-workflow/SKILL.md

@@ -0,0 +1,207 @@
+---
+name: e2e-scenario-flow-workflow
+description: "Create or update API E2E YAML scenarios using flow-based business journeys (not single-endpoint tests). Use when adding end-to-end coverage in a repo's e2e/Scenarios/<Domain> folders that use the sefrone_api_e2e Python framework, including setup, action, verification, and cleanup across multiple steps and runners."
+---
+
+# E2E Scenario Flow Workflow
+
+Use this workflow when writing or updating E2E tests in a repo built on the `sefrone_api_e2e` Python package (`ApiE2ETestsManager` / `E2EScenariosManager`).
+
+Goal: build scenario files that validate a business flow end-to-end, not isolated endpoint checks.
+
+## Locate This Repo's Setup First
+
+- Scenario files are YAML files under `e2e/Scenarios/<Domain>/` — discover the actual domain folder names in this repo (for example `Auth`) instead of assuming any specific one.
+- Find the build/runner script (commonly `build.py`) that imports from `sefrone_api_e2e` and registers `ApiE2ETestsManager`/`E2EScenariosManager` — it tells you exactly which runners are available beyond the default REST runner (an `EmailMockRunner` is common; others like a webhook mock runner may or may not be registered).
+
+## Framework Facts
+
+- `ApiE2ETestsManager.run_all_tests(...)` loads scenarios in filename sort order within each folder.
+- Tests are fail-fast: if one scenario fails, later scenarios are marked skipped.
+- Values saved in one step are namespaced as `<scenario_file_stem>.<key>` in global store.
+- Cross-scenario references must use `{$stored.<scenario_file_stem>.<key>}`.
+- Default runner is `RestApiRunner` for HTTP and `randomize` steps.
+- Extra runners are registered in the build/runner script and can be selected with `runner:`.
+
+## Runner Routing Rules
+
+- Do not set `runner:` for normal HTTP steps (`method`, `endpoint`) or `randomize`; default `rest` handles them.
+- Use `runner: email` for `check_email` steps (or rely on auto-detection if no `method` key) — requires an email mock runner to be registered.
+- For any other mock runner (e.g. webhook), use its registered `runner:` name and confirm it's actually wired up in this repo's build/runner script before relying on it.
+- If introducing a new runner-specific step type, ensure the runner is registered and that step payload uniquely matches that runner.
+
+## Required Scenario Style
+
+Every new scenario should represent one business journey with explicit phases:
+
+1. Setup/context
+2. Main action(s)
+3. Side-effect verification (state changes, webhooks, emails, balances, counters)
+4. Negative or boundary checks within the same journey when relevant
+5. Teardown/cleanup if entities were created
+
+Avoid "single endpoint smoke" scenarios unless the user explicitly asks for endpoint-only coverage.
+
+## Authoring Rules
+
+- Always include `name` and `base_url` at scenario level.
+- Prefer deterministic step names that describe intent, not just endpoint names.
+- Use `retry` on steps that depend on eventual consistency or startup latency.
+- Use `save` to capture IDs/tokens/quote IDs and reuse later in the same flow.
+- Add assertions for business outcomes, not only response shape.
+- Use `skip_if` for feature-gated behavior or environment-dependent flows.
+- Keep created data unique using `randomize`.
+- Validate key response structure with `expect.body` types and validate behavior with `assertions`.
+- Prefer cleanup steps (`DELETE`, unlink, disable) so reruns remain stable.
+
+## Expression and Template Rules
+
+- Env vars: `$var(NAME)`
+- Relative date: `$date(0)`, `$date(+1,end)`, `$date(-1,start)`
+- Stored value: `{$stored.key}` for same scenario, `{$stored.other_scenario.key}` for cross-scenario
+- Template read from response/email/webhook:
+  - `{{body.response.id}}`
+  - `{{body.response.items[0].id}}`
+  - `{{body.response.items.count()}}`
+- Assertion operators supported: `==`, `!=`, `>`, `<`, `>=`, `<=`, `in`, `not in`, `include`
+
+## Scenario Design Checklist
+
+Before finalizing a scenario, verify:
+
+- Flow starts from required auth/context and reaches a real business end state.
+- At least one step saves a value used in a later step.
+- Assertions prove behavior (state transitions, identity consistency, side-effects).
+- Failure-prone asynchronous checks use `retry`.
+- Feature flags are respected through `skip_if` when needed.
+- Data created by scenario is cleaned up or intentionally reusable and uniquely named.
+
+## Flow Template (Copy and Adapt)
+
+```yaml
+name: "<Domain> - <Business Flow Name>"
+base_url: "http://localhost:$var(API_PUBLIC_PORT)"
+skip_if:
+  - "<feature> not in {$stored.0_check_features.enabled_features}"
+
+steps:
+  - name: "Login admin"
+    retry:
+      attempts: 10
+      delay_seconds: 5
+    method: "POST"
+    endpoint: "/api/v1/apiAuth/account/$var(AUTH_PROJECT_NAME)/login"
+    send_as: "json"
+    body:
+      device: "e2e_test_device"
+      pseudo: "$var(DEFAULT_USERNAME)"
+      password: "$var(DEFAULT_PASSWORD)"
+    expect:
+      status: 200
+      body:
+        response:
+          token: string
+    save:
+      login_token: "{{body.response.token}}"
+
+  - name: "Generate unique suffix"
+    randomize:
+      seed_id: 8
+
+  - name: "Create entity"
+    method: "POST"
+    endpoint: "/api/v1/<Entity>/create"
+    request_headers:
+      - x-api-token: "{$stored.login_token}"
+    send_as: "json"
+    body:
+      name: "E2E {$stored.seed_id}"
+      isActive: true
+    expect:
+      status: 200
+      body:
+        errorCode: number
+        message: string
+
+  - name: "List entities and save id"
+    method: "GET"
+    endpoint: "/api/v1/<Entity>/list"
+    request_headers:
+      - x-api-token: "{$stored.login_token}"
+    expect:
+      status: 200
+      body:
+        response:
+          - id: string
+            isActive: boolean
+    save:
+      entity_id: "{{body.response[0].id}}"
+    assertions:
+      - "{{body.response[0].isActive}} == True"
+
+  - name: "Trigger business action"
+    method: "POST"
+    endpoint: "/api/v1/<Flow>/execute"
+    request_headers:
+      - x-api-token: "{$stored.login_token}"
+    send_as: "json"
+    body:
+      entityId: "{$stored.entity_id}"
+    expect:
+      status: 200
+      body:
+        response:
+          state: string
+    assertions:
+      - "{{body.response.state}} == 'accepted'"
+
+  - name: "Verify side effect (optional webhook)"
+    runner: webhook
+    check_webhook:
+      path: "/webhook/<path>"
+      secret_key: "<secret>"
+      clear_after: true
+    retry:
+      attempts: 20
+      delay_seconds: 2
+    assertions:
+      - "{{webhook.raw_body}} != ''"
+
+  - name: "Cleanup entity"
+    method: "DELETE"
+    endpoint: "/api/v1/<Entity>/delete/{$stored.entity_id}"
+    request_headers:
+      - x-api-token: "{$stored.login_token}"
+    expect:
+      status: 200
+```
+
+## Cross-Scenario Strategy
+
+Use cross-scenario references only when flow prerequisites are expensive and already covered elsewhere.
+
+Example (file stem is whatever this repo actually names its scenario files, e.g. `0_check_features`, `1_normal_auth_flow`):
+
+- `{$stored.1_setup_account.login_token}`
+- `{$stored.3_create_entity.entity_id}`
+
+When adding a new dependent scenario:
+
+- Ensure filename ordering guarantees prerequisite scenario runs first.
+- Reuse stable keys from prerequisite scenario `save` blocks.
+- Add comments at top of file to document dependencies.
+
+## What To Avoid
+
+- One request + status 200 only tests that do not validate outcome.
+- Repeating setup login in every step instead of reusing saved token.
+- Missing cleanup for created resources when delete endpoint exists.
+- Using brittle assertions against full raw messages when a structured assertion is possible.
+- Mixing unrelated business domains in one scenario file.
+
+## Done Criteria
+
+- Scenario models a complete business flow from setup to verifiable end state.
+- YAML uses this framework's templating, save, assertion, and skip patterns correctly.
+- Runner usage matches step type (`rest`, `email`, `webhook`).
+- Scenario is rerunnable and deterministic in local and pipeline environments.

sefrone_ai-1.0.0/sefrone_ai/skills/personal-info-workflow/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: personal-info-workflow
+description: "Implement or modify a PersonalInfo document process flow built on the Sefrone.Api.PersonalInfo NuGet package. Use when: adding a new process type, changing document templates, modifying process-status side effects (emails, downstream entity setup), altering access-blocking rules, or wiring a new ISupportPersonalInfoConfigurator method."
+---
+
+# Personal Info Workflow
+
+Use this skill whenever work involves the KYC / onboarding document process that lives behind `ISupportPersonalInfoConfigurator` from the `Sefrone.Api.PersonalInfo` NuGet package.
+
+---
+
+## Locate This Repo's Implementation First
+
+This interface is implemented exactly once per consuming app, under whatever name that app chose (commonly `<App>AuthConfigurator`). Before changing anything:
+
+```
+grep -rl "ISupportPersonalInfoConfigurator" --include=*.cs
+```
+
+The file that has `class ... : ISupportPersonalInfoConfigurator` (or lists it among implemented interfaces) is the **single integration point** — do **not** create a second implementation. It is registered by the framework via DI, typically as part of an `IServiceConfigurator` registration.
+
+From there, trace what it delegates to (a process-handling/domain service is the common pattern):
+
+```
+ISupportPersonalInfoConfigurator   (package: Sefrone.Api.PersonalInfo)
+        ↑
+<App>AuthConfigurator              (implements the interface)
+        │  often delegates business logic to
+        ↓
+I<...>ProcessHandlingService       (app-specific service interface, if present)
+```
+
+If the app doesn't split out a separate service, the configurator class itself contains all the logic below.
+
+---
+
+## ISupportPersonalInfoConfigurator — Method Map
+
+These methods come straight from the package interface (`Sefrone.Api.PersonalInfo/Abstract/ISupportPersonalInfoConfigurator.cs`) — read each implementation in this repo's configurator to learn the app-specific behavior, then update accordingly:
+
+### `GetProcessTemplates(projectId)` → `IList<ApiPersonalInfoDocumentProcessTemplate>`
+Returns all enabled process types for this app (e.g. different KYC categories). Find where these templates are built (often a static factory class) to see the existing pattern before adding a new one.
+
+### `GetDocumentProcessTemplate(projectId, processType)` → `ApiPersonalInfoDocumentProcessTemplate`
+The interface has a default implementation that delegates to `GetProcessTemplates`. If the configurator overrides this with its own switch/lookup, **that override and `GetProcessTemplates` must stay in sync** — adding a process type to one without the other is a common bug.
+
+### `GetWorkspaceRequiredFor(projectId)` → `bool`
+Whether workspaces are required for processes under this project. Often a flat `true`/`false`, but check for per-project-type logic.
+
+### `GetCountries(projectId, workspaceId)` → `IList<CountryTemplate>`
+Country restrictions for the process, if any. An empty list means no restriction is enforced.
+
+### `GetSearchTextAsync(process)` → `Task<string>`
+Builds the searchable text for a process (commonly assembled from name/display fields read off `process` via `GetFieldValue`).
+
+### `AddDocumentProcessMetadataAsync(process)` → `Task<DocumentProcessResponse>`
+Enriches `process.Metadata` with app-specific data (e.g. linked account info). Guard against `process.Id` being `null` for in-progress (unsaved) processes before calling any service that requires an ID.
+
+### `EnrichDocumentProcessOwnResponseAsync(process, response)` → `Task<DocumentProcessOwnSummaryResponse>`
+The right place for blocking guards before a user can start a new process (e.g. "too many active entities", "existing entity is inactive"). Look for existing `Blocked` responses with translation keys to follow the established naming convention.
+
+### `ProcessChangedAsync(change, process, account)`
+Fires on process status transitions. The package's `ApiPersonalInfoChangeType` constants are: `ProcessStatusPendingSubmit`, `ProcessStatusInReview`, `ProcessStatusApproved`, `ProcessStatusBlocked`. Check what this app's implementation does per type — common side effects are sending a notification email and/or creating/updating a downstream domain entity on approval.
+
+### `InfoChangedAsync(change, info, account)`
+Fires on personal info changes (address, phone, etc.), independent of document processes. Often a no-op unless the app needs to react to profile changes.
+
+---
+
+## Document Template Structure
+
+Each `ApiPersonalInfoDocumentProcessTemplate` contains an ordered list of `ApiPersonalInfoDocumentTemplate` steps, each either a `DataFields` step (form fields) or a `File` step (upload, with allowed extensions and a max size).
+
+**Field value access convention** — `process.GetFieldValue(documentNumber, contentNumber)` reads a specific field by its 1-based position in the template. When adding fields, append rather than reorder — existing code likely reads fields by these fixed positions.
+
+---
+
+## Adding a New Process Type — Checklist
+
+1. **Declare the type** — find where this app declares its `ApiPersonalInfoDocumentProcessType` constants (a static class wrapping `Init(...)`) and add the new one there, following the existing naming/source-value pattern.
+
+2. **Create the template** — find the factory that builds existing templates and add a new method following the same pattern. Number documents sequentially starting at 1.
+
+3. **Register the template** in the configurator:
+   - Add it to `GetProcessTemplates`.
+   - If `GetDocumentProcessTemplate` is overridden with a manual switch, add a branch there too.
+
+4. **Extract fields** — if there's a dedicated extraction helper (mapping process type → field indices), add a case for the new type there.
+
+5. **Handle status changes** — if the new type needs different side effects on approval/review/block, update the process-status handler found earlier.
+
+6. **Update blocking rules** — if `EnrichDocumentProcessOwnResponseAsync` needs type-specific guards, add them there.
+
+7. **Add translation keys** — `*TitleKey` / `*DescriptionKey` / `*LabelKey` strings are looked up via `Sefrone.Localization`. Add corresponding entries wherever this repo keeps its translation files.
+
+---
+
+## Permissions
+
+Check how this app maps personal-info permissions to account types — look for the permission constants and the permission map referenced by the configurator (or its DI registration). When adding a process type that needs a separate permission level, follow the same pattern: add the permission constant, then wire it into both the general and account-type-specific permission maps.
+
+---
+
+## Common Pitfalls
+
+- If the app's process-handling logic wraps DB work in a unit-of-work/transaction, make sure every code path commits or rethrows — don't return early from a status-change handler with an open transaction.
+- The `GetDocumentProcessTemplate` override (if any) and the `GetProcessTemplates` list **must stay in sync** — the interface default calls `GetProcessTemplates`, so a manual override that forgets a type silently diverges from it.
+- `process.Id` can be `null` for in-progress (unsaved) processes; guard before calling any service that takes a process ID.
+- Process-type and similar enum-like values in this package are usually backed by strings — use the existing `.Value` accessor pattern when constructing `ApiPersonalInfoDocumentProcessType`, not a raw string literal.

sefrone_ai-1.0.0/sefrone_ai/skills_manager.py

@@ -0,0 +1,75 @@
+import shutil
+from pathlib import Path
+
+
+class SkillsManager:
+    """Exports bundled SKILL.md files to a consumer-specified repo."""
+
+    # Path to bundled skill resources relative to this file
+    _BUNDLED_SKILLS_DIR = Path(__file__).parent / "skills"
+
+    @staticmethod
+    def __export_skills(destination_root, overwrite=False):
+        """
+        Copy all bundled skills (each a <skill-name>/SKILL.md pair) to *destination_root*.
+
+        Args:
+            destination_root (str | Path): Directory skills are written under. Created if missing.
+            overwrite (bool): If True, existing SKILL.md files are overwritten. Default is False.
+
+        Returns:
+            list[str]: Names of skills that were exported.
+        """
+        dest_root = Path(destination_root)
+
+        exported = []
+        for skill_dir in sorted(SkillsManager._BUNDLED_SKILLS_DIR.iterdir()):
+            skill_file = skill_dir / "SKILL.md"
+            if not skill_dir.is_dir() or not skill_file.exists():
+                continue
+
+            target_dir = dest_root / skill_dir.name
+            target_file = target_dir / "SKILL.md"
+
+            if target_file.exists() and not overwrite:
+                print(f"[SKIP] {skill_dir.name}/SKILL.md already exists (use overwrite=True to replace)")
+                continue
+
+            target_dir.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(skill_file, target_file)
+            print(f"[OK  ] Exported {skill_dir.name}/SKILL.md -> {target_file}")
+            exported.append(skill_dir.name)
+
+        return exported
+
+    @staticmethod
+    def export_claude_skills(target_repo_dir=None, overwrite=False):
+        """Override skill files for Claude-style repos (<target_repo_dir>/.claude/skills).
+
+        If target_repo_dir is not provided, defaults to the current working directory.
+        """
+        repo_dir = Path(target_repo_dir) if target_repo_dir else Path.cwd()
+        return SkillsManager.__export_skills(
+            repo_dir / ".claude" / "skills",
+            overwrite
+        )
+
+    @staticmethod
+    def export_github_skills(target_repo_dir=None, overwrite=False):
+        """Override skill files for GitHub-style repos (<target_repo_dir>/.github/skills).
+
+        If target_repo_dir is not provided, defaults to the current working directory.
+        """
+        repo_dir = Path(target_repo_dir) if target_repo_dir else Path.cwd()
+        return SkillsManager.__export_skills(
+            repo_dir / ".github" / "skills",
+            overwrite
+        )
+
+    @staticmethod
+    def list_bundled_skills():
+        """Return a list of bundled skill names."""
+        src = SkillsManager._BUNDLED_SKILLS_DIR
+        if not src.is_dir():
+            return []
+        return sorted(p.name for p in src.iterdir() if p.is_dir() and (p / "SKILL.md").exists())

sefrone_ai-1.0.0/sefrone_ai.egg-info/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: sefrone_ai
+Version: 1.0.0
+Summary: A Python package to provide AI coding assistant helpers for sefrone projects
+Home-page: https://bitbucket.org/sefrone/sefrone_pypi
+Author: Sefrone
+Author-email: contact@sefrone.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+# Sefrone AI
+
+A Python package to provide AI coding assistant helpers for sefrone projects.
+
+It bundles a set of Sefrone workflow skills (`SKILL.md` files) and exports them into a
+target repository, either in Claude Code's layout (`.claude/skills`) or GitHub's layout
+(`.github/skills`).
+
+## Installation
+
+```bash
+pip install sefrone_ai
+```
+
+## Usage
+
+```python
+from sefrone_ai import SkillsManager
+
+# List the skills bundled with this package
+SkillsManager.list_bundled_skills()
+
+# Override skill files for a Claude Code style repo (<target>/.claude/skills/<skill>/SKILL.md)
+SkillsManager.export_claude_skills("path/to/target/repo", overwrite=True)
+
+# Override skill files for a GitHub style repo (<target>/.github/skills/<skill>/SKILL.md)
+SkillsManager.export_github_skills("path/to/target/repo", overwrite=True)
+
+# target_repo_dir is optional; omitting it exports into the current working directory
+SkillsManager.export_claude_skills(overwrite=True)
+```

sefrone_ai-1.0.0/sefrone_ai.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+setup.py
+sefrone_ai/__init__.py
+sefrone_ai/skills_manager.py
+sefrone_ai.egg-info/PKG-INFO
+sefrone_ai.egg-info/SOURCES.txt
+sefrone_ai.egg-info/dependency_links.txt
+sefrone_ai.egg-info/top_level.txt
+sefrone_ai/skills/db-migration-workflow/SKILL.md
+sefrone_ai/skills/decompile-package-workflow/SKILL.md
+sefrone_ai/skills/e2e-scenario-flow-workflow/SKILL.md
+sefrone_ai/skills/personal-info-workflow/SKILL.md

sefrone_ai-1.0.0/sefrone_ai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sefrone_ai-1.0.0/sefrone_ai.egg-info/top_level.txt

@@ -0,0 +1 @@
+sefrone_ai

sefrone_ai-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sefrone_ai-1.0.0/setup.py

@@ -0,0 +1,26 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="sefrone_ai",
+    version="1.0.0",
+    author="Sefrone",
+    author_email="contact@sefrone.com",
+    description="A Python package to provide AI coding assistant helpers for sefrone projects",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://bitbucket.org/sefrone/sefrone_pypi",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: Other/Proprietary License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+    package_data={
+        "sefrone_ai": ["skills/*/SKILL.md"]
+    },
+    include_package_data=True,
+)