@muskanmeet/invoicing-design-system 0.1.0

package/.local/skills/package-management/.fingerprint

@@ -0,0 +1 @@
+fac6fec647956a59a82cc83b069fdda3

package/.local/skills/package-management/SKILL.md

@@ -0,0 +1,264 @@
+---
+name: package-management
+description: Install and manage language packages, system dependencies, and programming language runtimes.
+---
+
+# Package Management Skill
+
+Manage project dependencies and programming language runtimes. Use this skill instead of running shell commands like `npm install`, `pip install`, or `apt install`.
+
+## When to Use
+
+Use this skill when you need to:
+
+- Install language-specific packages (npm, pip, cargo, etc.)
+- Install system-level dependencies (ffmpeg, jq, imagemagick, etc.)
+- Install programming language runtimes (Python, Node.js, etc.)
+- Remove packages from the project
+- Check available versions of a programming language
+
+## When NOT to Use
+
+- Searching for available packages (use web search instead)
+- Configuring package settings (edit config files directly)
+- Running package scripts (use bash tool)
+
+## Modules (Replit Terminology)
+
+"Modules" is a Replit-specific term for language toolchains that can be installed into the NixOS environment. Use `listAvailableModules()` to see what's available.
+
+**Installation priority order:**
+
+1. Modules via this skill (preferred)
+2. Nix system dependencies via `installSystemDependencies()`
+3. Language package managers (pip, npm, cargo, etc.) via `installLanguagePackages()`
+
+If confused about package installation in Nix or language package managers, use web search.
+
+If a package install fails with HTTP 403 from `package-firewall.replit.local`, treat it as a likely security block and do not retry the same install.
+
+**After installing a module:**
+
+- Update `.gitignore` with the language's standard ignore patterns
+- Never add Replit config files to `.gitignore`
+
+**After removing a module:**
+
+- Consider removing any corresponding workflows that depend on it
+
+## Available Functions
+
+### listAvailableModules(langName=None)
+
+List available language toolchains that can be installed.
+
+**Parameters:**
+
+- `langName` (str, optional): Language name to filter by (e.g., "python", "nodejs", "rust"). If not provided, returns all available modules.
+
+**Returns:** Dict with `success`, `message`, `langName`, and `modules` list
+
+Each module contains: id, name, version, description
+
+**Example:**
+
+```javascript
+// List all available modules
+const modules = await listAvailableModules();
+// Returns: {modules: [{id: "python-3.11", ...}, {id: "nodejs-20", ...}, ...]}
+
+// Find available Python versions
+const pythonModules = await listAvailableModules({ langName: "python" });
+// Returns: {modules: [{id: "python-3.11", name: "Python", version: "3.11", ...}, ...]}
+
+// Find available Node.js versions
+const nodeModules = await listAvailableModules({ langName: "nodejs" });
+```
+
+### installProgrammingLanguage(language)
+
+Install a programming language runtime and its package manager.
+
+**Parameters:**
+
+- `language` (str, required): Language identifier like "python-3.11", "nodejs-20"
+
+**Returns:** Dict with `success`, `message`, `language`, and `installedModuleId` keys
+
+**Example:**
+
+```javascript
+// First, check available versions
+const modules = await listAvailableModules({ langName: "python" });
+console.log(modules);  // See available Python versions
+
+// Install specific version
+const result = await installProgrammingLanguage({ language: "python-3.11" });
+
+// Install Node.js 20
+const result2 = await installProgrammingLanguage({ language: "nodejs-20" });
+```
+
+### uninstallProgrammingLanguage(moduleId)
+
+Remove an installed programming language runtime.
+
+**Parameters:**
+
+- `moduleId` (str, required): Module ID from `listAvailableModules`
+
+**Returns:** Dict with `success`, `message`, `moduleId`, and `wasInstalled`
+
+**Example:**
+
+```javascript
+// Remove Python 3.10
+const result = await uninstallProgrammingLanguage({ moduleId: "python-3.10" });
+```
+
+### installLanguagePackages(language, packages)
+
+Install language-specific packages like npm, pip, or cargo packages.
+
+**Parameters:**
+
+- `language` (str, required): Programming language: "nodejs", "python", "bun", "go", "rust"
+- `packages` (list[str], required): List of packages to install
+
+**Returns:** Dict with `success`, `message`, `packages`, and `output` keys
+
+**Example:**
+
+```javascript
+// Install npm packages
+const result = await installLanguagePackages({
+    language: "nodejs",
+    packages: ["express", "lodash"]
+});
+console.log(result.message);
+
+// Install pip packages
+const result2 = await installLanguagePackages({
+    language: "python",
+    packages: ["requests", "flask"]
+});
+```
+
+**IMPORTANT — required parameter rules:**
+
+- `language` is **required** — you must always include it
+- Valid language values: `"nodejs"`, `"python"`, `"bun"`, `"go"`, `"rust"`
+  - Use `"nodejs"` for JavaScript/TypeScript projects — NEVER use `"js"`, `"node"`, or `"javascript"`
+  - Use `"python"` for Python projects — NEVER use `"py"` or `"pip"`
+- `packages` must be an **array of strings** — NEVER a single string, NEVER an array of objects
+  - Correct: `packages: ["express"]`
+  - Wrong: `packages: "express"`
+  - Wrong: `packages: [{name: "express"}]`
+
+### uninstallLanguagePackages(language, packages)
+
+Remove language-specific packages.
+
+**Parameters:**
+
+- `language` (str, required): Programming language
+- `packages` (list[str], required): List of packages to uninstall
+
+**Returns:** Dict with `success`, `message`, and `packages` keys
+
+**Example:**
+
+```javascript
+const result = await uninstallLanguagePackages({
+    language: "nodejs",
+    packages: ["lodash"]
+});
+```
+
+### installSystemDependencies(packages)
+
+Install system-level dependencies via Nix.
+
+**Parameters:**
+
+- `packages` (list[str], required): Nixpkgs attribute paths (NOT apt package names)
+
+**Returns:** Dict with `success`, `message`, and `packages` keys
+
+**Important:** Use Nix package names, not apt/debian names:
+
+- X11 libraries need 'xorg.' prefix: `xorg.libxcb`, `xorg.libX11`
+- `ca-certificates` is `cacert` in Nix
+- `libxcb` is `xorg.libxcb` in Nix
+
+**Example:**
+
+```javascript
+// Install system dependencies
+const result = await installSystemDependencies({
+    packages: ["jq", "ffmpeg", "imagemagick"]
+});
+
+// Install X11 libraries (note the xorg. prefix)
+const result2 = await installSystemDependencies({
+    packages: ["xorg.libxcb", "xorg.libX11"]
+});
+```
+
+### uninstallSystemDependencies(packages)
+
+Remove system-level dependencies.
+
+**Parameters:**
+
+- `packages` (list[str], required): Nixpkgs attribute paths to uninstall
+
+**Returns:** Dict with `success`, `message`, and `packages` keys
+
+**Example:**
+
+```javascript
+const result = await uninstallSystemDependencies({ packages: ["jq"] });
+```
+
+## Best Practices
+
+1. **Use language packages for project dependencies**: These are tracked in package files (package.json, requirements.txt)
+2. **Use system dependencies for OS-level tools**: Things like ffmpeg, imagemagick, or native libraries
+3. **Use Nix package names**: Not apt/debian names. Check nixpkgs for correct names
+4. **Install language runtimes when needed**: If `python` or `node` commands fail, install the runtime first
+5. **Check versions first**: Use `listAvailableModules` before `installProgrammingLanguage`
+
+## Example Workflow
+
+```javascript
+// Check available Python versions
+const modules = await listAvailableModules({ langName: "python" });
+console.log(modules);
+
+// Set up a Python Flask project
+await installProgrammingLanguage({ language: "python-3.11" });
+await installLanguagePackages({
+    language: "python",
+    packages: ["flask", "gunicorn", "sqlalchemy"]
+});
+
+// Set up a Node.js project with native dependencies
+await installProgrammingLanguage({ language: "nodejs-20" });
+await installLanguagePackages({
+    language: "nodejs",
+    packages: ["sharp", "canvas"]
+});
+await installSystemDependencies({
+    packages: ["pkg-config", "cairo", "pango", "libjpeg"]
+});
+
+// Clean up old language version
+await uninstallProgrammingLanguage({ moduleId: "python-3.10" });
+```
+
+## Automatic Behaviors
+
+- Installing packages automatically creates/updates project files (package.json, requirements.txt, etc.)
+- Package installations reboot all workflows to pick up new dependencies
+- Language runtime installations include popular package managers (pip, npm, etc.)

package/.local/skills/post_merge_setup/.fingerprint

@@ -0,0 +1 @@
+9390cd21a4644688669a96beaf25d373

package/.local/skills/post_merge_setup/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: post_merge_setup
+description: Maintain the post-merge setup script that runs automatically after task merges.
+---
+
+# Post-Merge Setup
+
+After a task is merged, two things run automatically:
+
+1. Setup script — installs dependencies, runs migrations, rebuilds.
+2. Workflow reconciliation — stops workflows removed from `.replit` and restarts already running workflows.
+
+If either step fails, the agent will be alerted about the issue, and should fix it immediately.
+
+## What Runs Automatically
+
+The system runs the configured post-merge script from the project root with bash.
+Stdin is closed (`/dev/null`), so commands that prompt for input will get EOF and fail immediately. The full Nix environment is available on PATH.
+
+If the script does not exist, setup fails and you are asked to create it.
+
+The script has a configurable timeout. If the script takes longer, it is killed and setup fails with a timeout error.
+
+After the script, workflow reconciliation syncs running workflows with the current `.replit` config.
+
+## Available Commands
+
+### Get the post-merge config
+
+```javascript
+const config = await getPostMergeConfig();
+console.log(config);
+// { scriptPath: "...", timeoutMs: ... }
+```
+
+Returns the configured script path and timeout from `.replit`. If not yet configured, both fields will be `null`.
+
+### Set post-merge config
+
+```javascript
+await setPostMergeConfig({ scriptPath: "scripts/post-merge.sh", timeoutMs: 180000 });
+```
+
+Sets the post-merge script path and/or timeout. Both parameters are optional — only provided values are updated. Note: `scriptPath` must be set (either already configured or provided in the same call) before setting `timeoutMs` alone, because `.replit` requires `path` in the `[postMerge]` section. Use `timeoutMs` when:
+
+- The script timed out — if the script naturally takes a long time (large `npm install`, slow migrations), increase the timeout so it succeeds on the next merge. Estimate a reasonable value from the script's expected runtime and add a buffer (e.g. if `npm install` takes 3s, set timeout to 5000 ms).
+- The script hangs — if the script hangs due to a bug (e.g. waiting for input), fix the script first, then consider lowering the timeout to catch future hangs early.
+
+### Run post-merge setup
+
+```javascript
+const result = await runPostMergeSetup();
+console.log(result);
+```
+
+Runs the post-merge script and workflow reconciliation. Returns `{ success, setupError, reconciliationError, scriptPath, stdoutPath, stderrPath, durationMs, timeoutMs }`.
+
+- `setupError` / `reconciliationError`: what failed
+- `scriptPath`: path to the post-merge script that was executed
+- `stdoutPath` / `stderrPath`: full log file paths
+- `durationMs` / `timeoutMs`: how long it ran and the configured timeout
+
+The tail of the stdout/stderr log files (last 10 lines with line numbers) is automatically opened into your context after the call.
+
+## Fixing Failures
+
+When setup fails:
+
+1. **Check the log files** opened into your context after the call (last 10 lines of stdout/stderr with line numbers). The `scriptPath` in the result tells you which script was executed.
+2. **Fix the script** — create it if missing, update it if broken.
+3. **If it timed out**, increase the timeout with `setPostMergeConfig({ timeoutMs: ... })` based on how long the script actually needs.
+4. **Retry** with `runPostMergeSetup()` to confirm the fix works.
+
+If workflow reconciliation fails, use the workflows skill to check and restart affected workflows.
+
+Common failure causes:
+
+- Missing script -> use the `scriptPath` from the result (or call `getPostMergeConfig()`) to find the expected path, then create the script there.
+- Script timed out -> increase timeout with `setPostMergeConfig({ timeoutMs: ... })`, or optimize the script.
+- A command prompts for input (stdin is closed, so it gets EOF and fails) -> use non-interactive flags (`--yes`, `--force`, `-y`, etc.).
+- A dependency or migration command fails -> fix the command or the underlying config.
+
+## Writing the Post-Merge Script
+
+Use the `scriptPath` from the last `runPostMergeSetup()` result if available. Otherwise, call `getPostMergeConfig()` to find the script location.
+
+Example:
+
+```bash
+#!/bin/bash
+set -e
+
+pnpm install
+pnpm --filter @workspace/db run push-force
+```
+
+Guidelines:
+
+- Idempotent. Safe to run multiple times.
+- Non-interactive. Stdin is closed. Use `--yes` / `--force` flags.
+- Fail fast. Use `set -e`.
+- Keep it fast. Runs while the user waits. If it takes more than 2 minutes, consider optimizing or increasing the timeout.

package/.local/skills/project_tasks/.fingerprint

@@ -0,0 +1 @@
+ee079fb9b87e7c1400bb596eb44342c7