Social-SBTI(Wizard Script)

This SKILL.md is a dialogue script. Each stage provides you with clear lines, input parsing, commands to run, and failure branches. Strictly follow the stage order, do not skip steps.

Phase 0 · Locate Skill Root Directory (First Thing)

When triggered, you must first locate yourself by running this:

bash

SBTI_HOME="$(
  for d in "$HOME/.claude/skills/social-sbti" \
           "$(pwd)/.claude/skills/social-sbti" \
           "$(pwd)/skills/social-sbti" \
           "$HOME/.claude/plugins/social-sbti/social-sbti"; do
    [ -f "$d/SKILL.md" ] && echo "$d" && break
  done
)"
export SBTI_HOME
echo "SBTI_HOME=$SBTI_HOME"

If the output is empty, tell the user that the skill is installed in a non-standard location, ask them to provide the path, then manually run

export SBTI_HOME=<path>

All subsequent commands must use

"$SBTI_HOME/bin/sbti" <subcmd>

, do not use relative paths.

Phase 1 · Welcome + Platform Selection

Lines (output as-is, compliance notice must be retained):

🎭 Social-SBTI Personality Profile (For entertainment only · Only analyze yourself or fully public figures)

Please select the platform to analyze:
  1. Jike
  2. X (Twitter)

Wait for user input:

Jike

Twitter

Parsing:

```
1
```
/
```
Jike
```
/
```
jike
```
→
```
PLATFORM=jike
```
```
2
```
/
```
x
```
/
```
X
```
/
```
twitter
```
→
```
PLATFORM=x
```

If user inputs a target name instead of platform selection: You can infer the platform from the target (e.g.,

@sama

looks like X,

AI产品黄叔

looks like Jike), then confirm once: "I understand you want to analyze @sama on X, is that correct?"

Next step: Phase 2

Phase 2 · Request Target

Lines (Jike):

Got it, analyzing Jike user. Please paste the user's Jike homepage URL or username.

Examples:
  https://web.okjike.com/u/E272054E-D904-4F13-A7EC-9ABD2CBF209E
  Or directly username

Lines (X):

Got it, analyzing X user. Please paste the user's X handle / homepage URL / user id.

Examples:
  @sama
  https://x.com/elonmusk
  44196397   (user id, most stable, not affected by name changes)

Wait for user input: Any string

Save:

TARGET=<user input>

Compliance confirmation (important): After getting the target, ask:

Confirm, is this your own account, or a fully public figure? This tool does not analyze ex-partners, colleagues, interviewers, investors, or blind date partners.

If user clearly indicates it's an ex-partner/colleague/private target → Reject immediately and stop here, guide them to change the target or give up.

Next step: Phase 3

Phase 3 · Health Check + Auto Fix

Run health check:

bash

"$SBTI_HOME/bin/sbti" doctor --fix --platform "$PLATFORM"

Parse doctor output:

All green (exit code 0): Skip to Phase 5 (Scraping)
Missing dependencies:
```
--fix
```
will automatically run pip install, run doctor again after installation to confirm
Missing credentials: Skip to Phase 4
Python version too low / other hard errors: Tell the user the specific reason and stop

Do not deceive yourself: Do not proceed to scraping if health check fails, otherwise it's a waste of time.

Phase 4 · Initial Credential Configuration (Execute only once)

4A · Jike Branch (Complete entirely in the conversation, do not let the user leave)

jike-auth

is an interactive QR code scanning tool: it outputs QR (ASCII QR code composed of unicode block characters) and progress information to stderr, and outputs tokens in JSON format to stdout after scanning. You need to run it in the background, then paste the QR from stderr into the conversation for the user to scan with their mobile App.

Line 1 (short, make space for QR):

First scan to get token, QR code will be displayed shortly.

Execution steps (strictly in order):

① Start jike-auth in the background, redirect stdout to inbox (tokens), stderr to background task output file (QR + progress):

bash

mkdir -p ~/.config/sbti && rm -f ~/.config/sbti/jike-tokens.json && \
"$SBTI_HOME/bin/sbti" jike-auth > ~/.config/sbti/jike-tokens.json

⚠️ Must use
sbti jike-auth
instead of bare
jike-auth
. The latter is usually not in PATH under macOS Homebrew Python —

pip install --user

puts binaries in

~/Library/Python/3.x/bin

, which is not picked up by the shell by default.

sbti jike-auth

will locate the correct binary itself and execv it, independent of PATH.

When calling Bash tools, Be sure to pass
run_in_background: true
, note down the returned task id and output file path.

② Wait 2-3 seconds for jike-auth to output the QR code, then use the

Read

tool to read the output file. You will see something like:

[+] Session: 642d995d-31a6-...
 ▄▄▄▄▄▄▄  ▄▄▄▄    ▄▄▄▄ ▄▄ ▄   ▄▄  ▄▄▄  ▄▄▄▄▄   ▄▄▄▄▄▄▄
 █ ▄▄▄ █  █  ██▀ ▀█▄▄█▀▀▀▀▄█ █▄███ ▄▄█▀▄█▀▄▀█  █ ▄▄▄ █
 ...about 25 lines of QR...
 ▄█▀█▀▄▄ ▄▄  █▄█ ▀▀▄▄▀▀▄█ ▀  ▀▀▄▄▀▀▀▀██▀█▄▀▀▀▀█   █▄▀
[*] Waiting for scan...

If you haven't seen

Waiting for scan...

yet, wait 1 more second and read again.

③ Paste the entire QR code as-is into the conversation (from the line

[+] Session:

to all block character lines before

Waiting for scan

). Wrap it in a code block, add blank lines before and after:

<Paste original stderr content here>

Then follow with:

👆 Please scan the above QR code with the Jike App. I will automatically continue after scanning, no need to switch back to tell me.

④ Wait for background task to end. Two ways:

Call
```
TaskOutput
```
tool with
```
block: true, timeout: 120000
```
(give user 2 minutes to scan)
Or
```
Read
```
```
~/.config/sbti/jike-tokens.json
```
every 3 seconds, once the file exists and is not empty, it means scanning is complete

⑤ Confirm tokens are in place:

bash

"$SBTI_HOME/bin/sbti" config jike --from-inbox

This will import jike-tokens.json into config.json and delete the original file. The output should be

✓ Jike tokens imported from inbox

⑥ Return to Phase 3 and run doctor again to confirm credentials are ✓, then proceed to Phase 5.

Failure branches:

Symptom	Handling
No scan after 2 minutes → task exits with code 1	Tell the user "Scan timed out, would you like to try again?", return to step ① after confirmation
jike-tokens.json exists but `config jike --from-inbox` reports format error	jike-auth crashed midway, `rm` the file and restart from step ①
Background task output file has no QR block characters for a long time	jike-auth may be stuck on network, `TaskStop` it, prompt user to check network and retry

⚠️ Do not degrade to "ask user to run jike-auth in another terminal". This skill promises to complete the entire process in the conversation, background + QR echo is the standard path.

4B · X Branch

Lines:

First time using X, need to get two fields from browser cookies:

1. Log in to https://x.com in your browser
2. Press F12 to open DevTools → Application → Cookies → https://x.com
3. Find these two cookies and copy their Values:
   - auth_token   (long string)
   - ct0           (long string, CSRF token)

Paste them directly, format doesn't matter, e.g.:
   auth_token = xxxxxx
   ct0 = yyyyyy

Wait for user reply: Two strings

Parsing: Extract the values of

auth_token

and

ct0

from the user's message

Execution:

bash

"$SBTI_HOME/bin/sbti" config x \
    --auth-token "<auth_token value>" \
    --ct0 "<ct0 value>"

Success: Cookies are saved to

~/.config/sbti/x_cookies.json

. Return to Phase 3 and run doctor again.

⚠️ Important reminder (after configuration):

X has strict risk control. The script has built-in self-rate-limiting, but it is recommended: ≤ 500 posts per run, no more than 10 different users per day, do not commit cookies to git. If rate-limited, stop and try again the next day.

Phase 5 · Scrape Posts

Execution:

bash

"$SBTI_HOME/bin/sbti" fetch "$PLATFORM" "$TARGET" --limit 200

This will write data to

./sbti-output/<name>_raw.json

(under the user's project root).

Parse return: The fetcher will print the final path, note it as

RAW_FILE

If failed:

Error	Handling
401 / token expired	Ask user to re-run jike-auth (Jike) or re-import cookies (X), return to Phase 4
404 user not found	Ask user to confirm if the URL / username is correct
429 / rate limited	Stop, ask user to come back after 30 minutes
Network error	Ask user to check network and retry

Do not fallback to asking user to manually paste posts. Scraping is the foundation of this skill.

Phase 6 · Claude's Own Scoring (This is your core work)

There are no commands to call here, you are the scoring LLM.

Steps

Read raw.json: Use
```
Read
```
tool to read
```
$RAW_FILE
```
, access the
```
posts[]
```
array.
Sample 150 posts:
- Total ≤ 150: Read all
- Total > 150: 60% recent (first 90 posts) + 40% older (last 60 posts)
Read rubric: Use
```
Read
```
tool to read
```
$SBTI_HOME/docs/SCORING_RUBRIC.md
```
. Score against the L/M/H anchors for each dimension.

Score 15 dimensions one by one (fixed order):

S1 S2 S3 E1 E2 E3 A1 A2 A3 Ac1 Ac2 Ac3 So1 So2 So3

Strictly adhere to hard constraints (from rubric):
- At least 1 real
```
post_id
```
  must be cited for each dimension (must come from raw.json, do not make up)
- If there is contradictory evidence → lower one level
- Confidence < 0.4 or no evidence → force fallback to M
Additional outputs:
- ```
overall_impression
```
  : 100-200 word overall impression
- ```
personality_description
```
  : 200-300 word "customized" description — must include specific facts about the target (occupation, projects, catchphrases, representative views), do not use generic copy
- ```
quotes
```
  : 4-6 real original quotes (copied from
```
content
```
  in raw.json)

Write scores.json:

json

{
  "profile": { "screen_name": "...", "platform": "jike|x",
               "bio": "...", "post_count": 200 },
  "personality_description": "...",
  "overall_impression": "...",
  "quotes": ["...", "...", "...", "..."],
  "scores": [
    {
      "dimension": "S1",
      "level": "H",
      "confidence": 0.9,
      "evidence": ["<real post_id>", "<real post_id>"],
      "reasoning": "No more than 40 words"
    }
    // ... total 15 entries
  ]
}

Path:

./sbti-output/<name>_scores.json

(same directory as raw.json, same

<name>

Optional field: If posts clearly mention "drinking/white liquor/toasting" frequently, add
```
"drunk": true
```
, which will trigger the DRUNK easter egg.

Pre-writing Self-check List

All 15 scores are present and in correct order
Each entry has ≥ 1 evidence post_id that actually exists in raw.json
Entries with confidence < 0.4 have fallen back to M
Quotes are real original text, not made up
personality_description includes specific facts

Note down the scores.json path:

SCORES_FILE=./sbti-output/<name>_scores.json

Phase 7 · Matching + Rendering

Execution:

bash

"$SBTI_HOME/bin/sbti" finalize "$SCORES_FILE"

This will complete the following in one go:

```
match.py
```
→ Match 27 personality templates, write back to scores.json with
```
pattern
```
+
```
personality
```
```
make_card.py
```
→ Generate HTML card
```
render_png.py
```
→ Use playwright to capture as PNG (skip if not installed, will give prompt)

If PNG generation fails: Continue, HTML is viewable on its own and has a "📸 Save as image" button.

Phase 8 · Display Results

Show results to user (follow this format):

Main result (ASCII box):

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  🎭 <screen_name>
  【<CODE>】· <Chinese Name>  <mascot>
  「<Slogan>」
  Matching degree: <XX>%
  Pattern string: <pattern>
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

15-dimensional profile (ASCII table, one dimension per line):

Self Model
  S1 Self-esteem & Confidence  H  — <reasoning>
  S2 Self-clarity  H  — <reasoning>
  S3 Core Values  H  — <reasoning>
Emotional Model
  E1 Attachment Security  H  — <reasoning>
  ...

Overall impression: Repeat the entire
```
overall_impression
```
paragraph

File paths:

📁 Outputs:
   sbti-output/<name>_scores.json  (Complete data)
   sbti-output/<name>-sbti.html    (Shareable card)
   sbti-output/<name>-sbti.png     (Screenshot, if playwright is ready)

Open commands:

open sbti-output/<name>-sbti.png
open sbti-output/<name>-sbti.html

Common Pitfalls (Learned from Practice)

"High execution ≠ confidence": High Ac3 does not mean high S1, some people are pushed by deadlines
"Sharp tongue ≠ cynicism": Chinese sarcastic expressions, do not take jokes as negative sentiment
"Active in communities ≠ high So1": Need to see if they initiate actively or respond passively
"Many reposts ≠ emotional investment": Reposts may just be information flow
"Self-deprecation ≠ low S1": "I'm really good + self-deprecation" is actually H
M is the safe zone: If unsure, score M, do not force it
Evidence must be real post_id: Do not write ids that do not exist in raw.json

Degradation Priority When Failing

When any step fails, handle in the following priority:

Retry — If it's a temporary error (network, short-term rate limit)
Fix root cause — Expired credentials, wrong URL, missing dependencies
Tell user the specific reason and stop — Do not fallback to "then I'll use the text you pasted" etc.

References

```
docs/SCORING_RUBRIC.md
```
— 15-dimensional L/M/H behavior anchors (must read when scoring)
```
docs/DISCLAIMER.md
```
— Compliance/rejection scripts
```
bin/sbti
```
— Only command entry, see
```
sbti --help
```
for subcommands
```
examples/huangshu_scores.json
```
— Complete scores.json format reference

social-sbti

NPX Install

Tags

SKILL.md Content (Chinese)

Social-SBTI(Wizard Script)

Phase 0 · Locate Skill Root Directory (First Thing)

Phase 1 · Welcome + Platform Selection

Phase 2 · Request Target

Phase 3 · Health Check + Auto Fix

Phase 4 · Initial Credential Configuration (Execute only once)

4A · Jike Branch (Complete entirely in the conversation, do not let the user leave)

4B · X Branch

Phase 5 · Scrape Posts

Phase 6 · Claude's Own Scoring (This is your core work)

Steps

Pre-writing Self-check List

Phase 7 · Matching + Rendering

Phase 8 · Display Results

Common Pitfalls (Learned from Practice)

Degradation Priority When Failing

References