aiblueprint-cli 1.0.3 → 1.1.0

package/claude-code-config/commands/run-tasks.md

@@ -1,50 +1,105 @@
 ---
-description: Run a task (issue)
+allowed-tools: Bash(gh :*), Bash(git :*)
+argument-hint: <issue-number|issue-url|file-path>
+description: Execute GitHub issues or task files with full EPCT workflow and PR creation
 ---
 
-## Get task
+You are a task execution specialist. Complete issues systematically using EPCT workflow with GitHub integration.
 
-For the given "$ARGUMENTS" you need to get the information about the tasks you need to do :
+**You need to always ULTRA THINK.**
 
-- If it's a file path, get the path to get the instructions and the feature we want to create
-- If it's an issues number or URL, fetch the issues to get the information (with `gh cli`) (update the issue with a label "processing")
+## 0. GET TASK
 
-Use the workflow `EPCT` to make this task.
+**Goal**: Retrieve task requirements from $ARGUMENTS
 
-## Explore
+- **File path**: Read file for task instructions
+- **Issue number/URL**: Fetch with `gh issue view`
+- **Add label**: `gh issue edit --add-label "processing"` for issues
 
-First, use parallel subagents to find and read all files that may be useful for implementing the ticket, either as examples or as edit targets. The subagents should return relevant file paths, and any other info that may be useful.
+## 0.2. CHECK ACTUAL BRANCH
 
-## Plan
+**Goal**: Ensure safe branch for development
 
-Next, think hard and write up a detailed implementation plan. Don't forget to include tests, lookbook components, and documentation. Use your judgement as to what is necessary, given the standards of this repo.
+- **Check current branch**: `git branch --show-current`
+- **If on main branch**:
+  - Create and switch to new branch: `git checkout -b feature/task-name`
+- **If on custom branch**:
+  - Check for existing commits: `git log --oneline origin/main..HEAD`
+  - **If commits exist**: Ask user "This branch has existing commits. Continue with this branch? (y/n)"
+  - **If user says no**: Create new branch: `git checkout -b feature/task-name`
+- **CRITICAL**: Never work directly on main branch
 
-If there are things you are not sure about, use parallel subagents to do some web research. They should only return useful information, no noise.
+## 1. EXPLORE
 
-If there are things you still do not understand or questions you have for the user, pause here to ask them before continuing.
+**Goal**: Find all relevant files for implementation
 
-⚠️ If there is an issues link, please add a comment inside the issues with your plan. So we can discuss it and understand your plan.
+- Launch **parallel subagents** to search codebase (`explore-codebase` agent)
+- Launch **parallel subagents** for web research (`websearch` agent) if needed
+- Find files to use as **examples** or **edit targets**
+- **CRITICAL**: Think deeply before starting agents - know exactly what to search for
 
-## Code
+## 2. PLAN
 
-When you have a thorough implementation plan, you are ready to start writing code. Follow the style of the existing codebase (e.g. we prefer clearly named variables and methods to extensive comments). Make sure to run our autoformatting script when you're done, and fix linter warnings that seem reasonable to you.
+**Goal**: Create detailed implementation strategy
 
-## Test
+- Write comprehensive plan including:
+  - Core functionality changes
+  - Test coverage requirements
+  - Documentation updates
+- **For GitHub issues**: Post plan as comment with `gh issue comment`
+- **STOP and ASK** user if anything remains unclear
 
-If there is tests in the project, create tests and run them. In any case, run linter and TypeScript to verify that you code work correctly.
+## 3. CODE
 
-If your changes touch the UX in a major way, use the browser to make sure that everything works correctly. Make a list of what to test for, and use a subagent for this step.
+**Goal**: Implement following existing patterns
 
-If your testing shows problems, go back to the planning stage and think ultra-hard.
+- Follow existing codebase style:
+  - Prefer clear variable/method names over comments
+  - Match existing patterns
+- **CRITICAL RULES**:
+  - Stay **STRICTLY IN SCOPE** - change only what's needed
+  - NO comments unless absolutely necessary
+  - Run formatters and fix reasonable linter warnings
 
-## Create pull request
+## 4. TEST
 
-After the change is made, create a pull request with the changes and commit your changes following commitizen format.
+**Goal**: Verify your changes work correctly
 
-Make the merge of the pull request actually close the issues.
+- **First check package.json** for available scripts:
+  - Look for: `lint`, `typecheck`, `test`, `format`, `build`
+  - Run relevant commands like `npm run lint`, `npm run typecheck`
+- Run **ONLY tests related to your feature**
+- **STAY IN SCOPE**: Don't run entire test suite
+- **CRITICAL**: All linting and type checks must pass
+- For UX changes: Use browser agent for specific functionality
+- If tests fail: **return to PLAN phase**
 
-## Write up your work
+## 5. CREATE PR
 
-When you are happy with your work, write up a short report that could be used as the PR description. Include what you set out to do, the choices you made with their brief justification, and any commands you ran in the process that may be useful for future developers to know about with the link of the pull request.
+**Goal**: Submit changes for review
 
-Add in the issue a comment about the things you did.
+- Commit with conventional format using `git commit`
+- Create PR with `gh pr create --title "..." --body "..."`
+- Link to close issue: Include "Closes #123" in PR body
+- Return PR URL to user
+
+## 6. UPDATE ISSUE
+
+**Goal**: Document completion
+
+- Comment on issue with `gh issue comment` including:
+  - Summary of changes made
+  - PR link
+  - Any decisions or trade-offs
+
+## Execution Rules
+
+- Use parallel execution for speed
+- Think deeply at each phase transition
+- Never exceed task boundaries
+- Test ONLY what you changed
+- Always link PRs to issues
+
+## Priority
+
+Correctness > Completeness > Speed. Complete each phase before proceeding.

package/claude-code-config/commands/watch-ci.md

@@ -1,22 +1,43 @@
 ---
-allowed-tools: mcp__wait-timer__wait, Bash(gh :*), Bash(git :*), Read, LS, Grep, Task
-description: Watch CI pipeline after commit and auto-fix errors intelligently.
+allowed-tools: Bash(gh :*), Bash(git :*), Bash(sleep :*)
+description: Monitor CI pipeline and automatically fix failures until green
 ---
 
-After a commit is pushed:
+You are a CI monitoring specialist. Watch pipelines and fix failures automatically until all checks pass.
 
-1. Wait 30 seconds for GitHub Actions to start
-2. Find the latest GitHub Actions run for current branch
-3. Watch the run until completion
-4. If the run fails:
-   - Download and analyze log artifacts
-   - Identify common CI errors (vector dimensions, Inngest auth, database issues, TypeScript errors)
-   - Auto-correct the errors found
-   - Commit the fixes and push
-   - Recursively restart this process until CI passes
-5. Clean up downloaded artifacts
-6. Report final CI status
+## Workflow
 
-## Commands
+1. **WAIT**: `sleep 30` - Give GitHub Actions time to start
 
-- `gh run watch <run-id>` : to watch the run
+2. **FIND RUN**: Get latest workflow run
+   - `gh run list --branch $(git branch --show-current) --limit 1`
+   - Extract run ID from output
+
+3. **MONITOR**: Watch run until completion
+   - `gh run watch <run-id>` - Monitor in real-time
+   - Check status with `gh run view <run-id>`
+
+4. **ON FAILURE**: Fix and retry
+   - **Analyze**: `gh run view <run-id> --log-failed` to get error logs
+   - **Identify**: Parse errors to understand root cause
+   - **Download**: `gh run download <run-id>` if artifacts needed
+   - **Fix**: Make targeted code changes
+   - **Commit**: Stage and push fixes with descriptive message
+   - **Loop**: Return to step 1 (max 3 attempts)
+
+5. **ON SUCCESS**: Report completion
+   - Clean up any downloaded artifacts
+   - Display final status: `gh run view <run-id>`
+   - List all commits made during fixing
+
+## Execution Rules
+
+- **STAY IN SCOPE**: Only fix CI-related errors
+- Max 3 fix attempts before requesting help
+- Commit messages must describe the CI fix
+- Always verify fix worked before moving on
+- Clean up artifacts after completion
+
+## Priority
+
+Fix accuracy > Speed > Minimal commits. Ensure CI is truly green.

package/claude-code-config/hooks/hook-post-file.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env bun
+// @ts-nocheck
+
+interface HookInput {
+  session_id: string;
+  transcript_path: string;
+  cwd: string;
+  hook_event_name: string;
+  tool_name: string;
+  tool_input: {
+    file_path: string;
+    content: string;
+  };
+  tool_response: {
+    filePath: string;
+    success: boolean;
+  };
+}
+
+interface HookOutput {
+  hookSpecificOutput: {
+    hookEventName: string;
+    additionalContext: string;
+  };
+}
+
+// Check for debug mode
+const DEBUG = process.argv.includes("--debug");
+
+function log(message: string, ...args: unknown[]) {
+  if (DEBUG) {
+    console.log(message, ...args);
+  }
+}
+
+async function runCommand(
+  command: string[],
+): Promise<{ stdout: string; stderr: string; success: boolean }> {
+  try {
+    const proc = Bun.spawn(command, {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const success = (await proc.exited) === 0;
+
+    return { stdout, stderr, success };
+  } catch (error) {
+    return { stdout: "", stderr: String(error), success: false };
+  }
+}
+
+async function main() {
+  log("Hook started for file processing");
+
+  // Lire l'input JSON depuis stdin
+  const input = await Bun.stdin.text();
+  log("Input received, length:", input.length);
+
+  let hookData: HookInput;
+  try {
+    hookData = JSON.parse(input);
+  } catch (error) {
+    log("Error parsing JSON input:", error);
+    process.exit(0);
+  }
+
+  const filePath = hookData.tool_input?.file_path;
+  if (!filePath) {
+    log("Unable to extract file path from input");
+    process.exit(0);
+  }
+
+  // Vérifier que c'est un fichier .ts ou .tsx uniquement
+  if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx")) {
+    log(`Skipping ${filePath}: not a TypeScript file`);
+    process.exit(0);
+  }
+
+  log("Processing file:", filePath);
+
+  // Vérifier que le fichier existe
+  const file = Bun.file(filePath);
+  if (!(await file.exists())) {
+    log("File not found:", filePath);
+    process.exit(1);
+  }
+
+  // 1. Exécuter Prettier
+  log("Running Prettier formatting");
+  const prettierResult = await runCommand([
+    "bun",
+    "x",
+    "prettier",
+    "--write",
+    filePath,
+  ]);
+  if (!prettierResult.success) {
+    log("Prettier failed:", prettierResult.stderr);
+  }
+
+  // 2. ESLint --fix
+  log("Running ESLint --fix");
+  await runCommand(["bun", "x", "eslint", "--fix", filePath]);
+
+  // 3. Run ESLint check and TypeScript check in parallel
+  log("Running ESLint and TypeScript checks in parallel");
+  const [eslintCheckResult, tscResult] = await Promise.all([
+    runCommand(["bun", "x", "eslint", filePath]),
+    runCommand(["bun", "x", "tsc", "--noEmit", "--pretty", "false"]),
+  ]);
+
+  const eslintErrors = (
+    eslintCheckResult.stdout + eslintCheckResult.stderr
+  ).trim();
+
+  const tsErrors = tscResult.stderr
+    .split("\n")
+    .filter((line) => line.includes(filePath))
+    .join("\n");
+
+  // Construire le message d'erreurs
+  let errorMessage = "";
+
+  if (tsErrors || eslintErrors) {
+    errorMessage = `Fix NOW the following errors AND warning detected in ${filePath
+      .split("/")
+      .pop()}:\\n`;
+
+    if (tsErrors) {
+      errorMessage += `\\n TypeScript errors:\\n${tsErrors}\\n`;
+    }
+
+    if (eslintErrors) {
+      errorMessage += `\\n ESLint errors:\\n${eslintErrors}\\n`;
+    }
+  }
+
+  log("Error message", errorMessage);
+
+  // Sortir le résultat
+  if (errorMessage) {
+    const output: HookOutput = {
+      hookSpecificOutput: {
+        hookEventName: "PostToolUse",
+        additionalContext: errorMessage,
+      },
+    };
+
+    log("Output", JSON.stringify(output, null, 2));
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.error(`No errors detected in ${filePath.split("/").pop()}`);
+  }
+}
+
+main().catch((error) => {
+  log("Error in hook:", error);
+  process.exit(1);
+});

package/claude-code-config/scripts/statusline-ccusage.sh

@@ -18,6 +18,10 @@ current_dir=$(echo "$input" | jq -r '.workspace.current_dir // empty')
 cwd=$(echo "$input" | jq -r '.cwd // empty')
 output_style=$(echo "$input" | jq -r '.output_style.name // empty')
 
+# Extract cost data from Claude Code Status hook
+session_cost_usd=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
+session_duration_ms=$(echo "$input" | jq -r '.cost.total_duration_ms // 0')
+
 # Get current git branch with error handling
 if git rev-parse --git-dir >/dev/null 2>&1; then
     branch=$(git branch --show-current 2>/dev/null || echo "detached")
@@ -64,8 +68,11 @@ else
     branch="no-git"
 fi
 
-# Get basename of current directory
-dir_name=$(basename "$current_dir")
+# Use full path but replace home directory with ~
+dir_path="$current_dir"
+if [[ "$dir_path" == "$HOME"* ]]; then
+    dir_path="~${dir_path#$HOME}"
+fi
 
 # Get today's date in YYYYMMDD format
 today=$(date +%Y%m%d)
@@ -97,21 +104,38 @@ format_time() {
     fi
 }
 
+format_duration_ms() {
+    local ms=$1
+    local minutes=$((ms / 60000))
+    format_time "$minutes"
+}
+
 # Initialize variables with defaults
 session_cost="0.00"
 session_tokens=0
 daily_cost="0.00"
 block_cost="0.00"
 remaining_time="N/A"
+session_duration=""
 
-# Get current session data using ccusage session --id
+# Use Claude Code cost data if available, otherwise fallback to ccusage
+if [ "$session_cost_usd" != "0" ] && [ "$session_cost_usd" != "null" ]; then
+    session_cost="$session_cost_usd"
+    if [ "$session_duration_ms" != "0" ] && [ "$session_duration_ms" != "null" ]; then
+        session_duration=$(format_duration_ms "$session_duration_ms")
+    fi
+fi
+
+# Always get session tokens from ccusage when session_id is available
 if command -v ccusage >/dev/null 2>&1 && [ -n "$session_id" ] && [ "$session_id" != "empty" ]; then
     # Use the new ccusage session --id functionality to get session data
     session_data=$(ccusage session --id "$session_id" --json 2>/dev/null)
     
     if [ $? -eq 0 ] && [ -n "$session_data" ] && [ "$session_data" != "null" ]; then
-        # Extract cost and tokens from the JSON response
-        session_cost=$(echo "$session_data" | jq -r '.totalCost // 0')
+        # If we don't have cost from Claude Code, get it from ccusage
+        if [ "$session_cost" = "0.00" ] || [ "$session_cost" = "0" ]; then
+            session_cost=$(echo "$session_data" | jq -r '.totalCost // 0')
+        fi
         # Calculate only input + output tokens (exclude cache tokens for meaningful display)
         session_tokens=$(echo "$session_data" | jq -r '.entries | map(.inputTokens + .outputTokens) | add // 0')
     fi
@@ -144,13 +168,21 @@ formatted_daily_cost=$(format_cost "$daily_cost")
 formatted_block_cost=$(format_cost "$block_cost")
 formatted_tokens=$(format_tokens "$session_tokens")
 
-# Build the status line with colors (light gray as default)
-status_line="${LIGHT_GRAY}🌿 $branch ${GRAY}|${LIGHT_GRAY} 💄 $output_style ${GRAY}|${LIGHT_GRAY} 📁 $dir_name ${GRAY}|${LIGHT_GRAY} 🤖 $model_name ${GRAY}|${LIGHT_GRAY} 💰 \$$formatted_session_cost ${GRAY}/${LIGHT_GRAY} 📅 \$$formatted_daily_cost ${GRAY}/${LIGHT_GRAY} 🧊 \$$formatted_block_cost"
+# Build the first line: branch / style / folder / model
+first_line="${LIGHT_GRAY}🌿 $branch ${GRAY}|${LIGHT_GRAY} 💄 $output_style ${GRAY}|${LIGHT_GRAY} 📁 $dir_path ${GRAY}|${LIGHT_GRAY} 🤖 $model_name${RESET}"
+
+# Build the second line: pricing and tokens
+session_cost_display="\$$formatted_session_cost"
+if [ -n "$session_duration" ]; then
+    session_cost_display="$session_cost_display ${GRAY}($session_duration)${LIGHT_GRAY}"
+fi
+
+second_line="${LIGHT_GRAY}💰 $session_cost_display ${GRAY}|${LIGHT_GRAY} 📅 \$$formatted_daily_cost ${GRAY}|${LIGHT_GRAY} 🧊 \$$formatted_block_cost"
 
 if [ "$remaining_time" != "N/A" ]; then
-    status_line="$status_line ($remaining_time left)"
+    second_line="$second_line ($remaining_time left)"
 fi
 
-status_line="$status_line ${GRAY}|${LIGHT_GRAY} 🧩 ${formatted_tokens} ${GRAY}tokens${RESET}"
+second_line="$second_line ${GRAY}|${LIGHT_GRAY} 🧩 ${formatted_tokens} ${GRAY}tokens${RESET}"
 
-printf "%b\n" "$status_line"
+printf "%b\n%b\n" "$first_line" "$second_line"