Opendirectory – Où se trouve votre client idéal

Où se trouve votre client idéal

À partir d'un produit et d'un ICP, retrace les vrais messages de douleur de l'ICP jusqu'à leurs communautés sources. Ajoute les signaux de discussions concurrentielles. Découvre les canaux Slack/Discord/newsletter/podcast/conférence via DuckDuckGo. Note chaque canal par le nombre de signaux ICP, la taille, l'activité et la présence concurrentielle. Produis un playbook classé : preuve, tactique d'entrée, angle de contenu, anti-patrons – un par canal. Pas de supposition. Canaux tracés uniquement par signal.

---

Règle critique : Chaque nom de canal dans la sortie doit exister soit dans la réponse de l'API Reddit, soit dans les résultats de recherche DuckDuckGo de cette exécution. Chaque nombre de membres doit provenir de l'API about.json ou d'un extrait de recherche – jamais estimé. Chaque nombre de signaux ICP doit correspondre aux données brutes. Si un type de canal renvoie 0 résultats, signale 0 – n'invente pas de canaux.

---

Erreurs courantes

L'agent va vouloir...	Pourquoi c'est faux
Recommander des canaux génériques ("LinkedIn", "Twitter")	Chaque canal doit être spécifique avec un nom, un nombre de membres et une URL. "Groupe LinkedIn : DevOps pour les équipes Entreprise (45 000 membres)" – pas juste "LinkedIn".
Utiliser les mêmes canaux pour chaque ICP	Le traçage par signal est spécifique à l'ICP. Un ICP DevOps et un ICP Finance produisent des listes de canaux complètement différentes. Exécute le script à nouveau pour chaque ICP.
Inventer des nombres de membres ou des noms de communautés	Chaque nom de canal doit provenir des résultats DuckDuckGo ou de l'API Reddit. Chaque nombre de membres doit provenir de l'API ou d'un extrait de recherche. Si indisponible, écris "nombre de membres non trouvé".
Ignorer la couche concurrentielle	Là où les concurrents sont discutés = votre ICP évalue des alternatives = contexte de prospection le plus chaud. Exécute toujours la recherche concurrentielle, même si l'utilisateur ne l'a pas demandé.
Écrire des tactiques d'entrée qui sont des pitchs produits	"Publiez à propos de votre produit dans r/devops" n'est pas une tactique d'entrée. Les tactiques d'entrée nomment le type de fil spécifique, le format de contenu et la norme communautaire.
Traiter Reddit comme le seul type de canal	La sortie doit inclure au moins 3 types de canaux. Si seul Reddit est trouvé, cherche explicitement sur DuckDuckGo pour Slack/Discord/newsletter/conférence avant de t'arrêter.

---

Étape 1 : Vérification de la configuration

echo "GITHUB_TOKEN : ${GITHUB_TOKEN:-non défini – la couche concurrentielle s'exécute à 60 req/h sans authentification}"
echo ""
echo "Sources de données utilisées lors de cette exécution :"
echo "  Reddit public JSON   (pas d'auth, traçage par signal)"
echo "  Reddit about.json    (pas d'auth, métadonnées subreddit)"
echo "  HN Algolia API       (pas d'auth, traçage par signal)"
echo "  DuckDuckGo HTML      (pas d'auth, découverte de canaux)"
echo "  GitHub API           (${GITHUB_TOKEN:+authentifié, }optionnel pour enrichissement concurrentiel)"

Si GITHUB_TOKEN n'est pas défini : continue. Toute la découverte de canaux de base fonctionne sans lui.

---

Étape 2 : Analyse de l'ICP

Collecte à partir de la conversation :

• product – ce que fait le produit (une phrase)
• icp_role – qui est l'ICP (ex. "co-fondateurs techniques", "ingénieurs DevOps chez des Series A")
• icp_pain – leur problème principal (ex. "acquisition de clients", "fatigue d'alerte")
• category – mots-clés de catégorie de marché (ex. "gtm vente startup", "monitoring devops")
• competitors – noms de concurrents optionnels (ex. "Clay, Apollo, HubSpot")

Cascade ICP :

1. Si l'invite de l'utilisateur contient produit + icp_role + icp_pain : extrais-les directement et continue.
2. Si l'invite est légère (seulement catégorie ou seulement nom de produit) : vérifie docs/icp.md pour un profil ICP sauvegardé. Fusionne avec les détails de l'invite.
3. Si toujours insuffisant (icp_role ou icp_pain manquants) : pose ces 3 questions, une à la fois :
   • "Que fait votre produit en une phrase ?"
   • "Qui est votre client idéal ? (poste, type d'entreprise, taille d'équipe)"
   • "Quel est leur problème principal avant de trouver votre produit ?"
4. Sauvegarde l'ICP final dans docs/icp.md pour que d'autres compétences puissent le réutiliser.

Sauvegarde du fichier ICP si docs/icp.md ne contient pas déjà ce produit :

python3 << 'PYEOF'
import json, os

icp = {
    "product": "PRODUIT_ICI",
    "icp_role": "ROLE_ICP_ICI",
    "icp_pain": "DOULEUR_ICP_ICI",
    "competitors": ["COMP_1", "COMP_2"],
    "category": "CATÉGORIE_ICI"
}

os.makedirs("docs", exist_ok=True)
with open("/tmp/wcl-input.json", "w") as f:
    json.dump(icp, f, indent=2)

# Mettre à jour docs/icp.md
icp_md_path = "docs/icp.md"
new_block = f"""## {icp['product']}
- **Rôle ICP :** {icp['icp_role']}
- **Douleur ICP :** {icp['icp_pain']}
- **Concurrents :** {', '.join(icp['competitors']) if icp['competitors'] else 'aucun'}
- **Catégorie :** {icp['category']}
"""
existing = open(icp_md_path).read() if os.path.exists(icp_md_path) else ""
if icp['product'] not in existing:
    with open(icp_md_path, "a") as f:
        f.write(new_block)
    print(f"ICP sauvegardé dans {icp_md_path}")
else:
    print(f"ICP déjà présent dans {icp_md_path}")

print(f"Produit : {icp['product']}")
print(f"Rôle ICP : {icp['icp_role']}")
print(f"Douleur ICP : {icp['icp_pain']}")
print(f"Concurrents : {', '.join(icp['competitors']) if icp['competitors'] else 'aucun'}")
PYEOF

---

Étape 3 : Exécution du script autonome de collecte de données

Vérifie si le script existe :

ls scripts/fetch.py 2>/dev/null && echo "script disponible" || echo "non trouvé"

Exécute la découverte des canaux :

GITHUB_TOKEN="${GITHUB_TOKEN:-}" python3 scripts/fetch.py \
    "$(python3 -c "import json; d=json.load(open('/tmp/wcl-input.json')); print(d['category'])")" \
    --icp-role "$(python3 -c "import json; d=json.load(open('/tmp/wcl-input.json')); print(d['icp_role'])")" \
    --icp-pain "$(python3 -c "import json; d=json.load(open('/tmp/wcl-input.json')); print(d['icp_pain'])")" \
    --product "$(python3 -c "import json; d=json.load(open('/tmp/wcl-input.json')); print(d['product'])")" \
    --competitors "$(python3 -c "import json; d=json.load(open('/tmp/wcl-input.json')); print(','.join(d['competitors']))")" \
    --output /tmp/wcl-raw.json

Attends la fin (jusqu'à 5 minutes – les recherches Reddit + DuckDuckGo prennent environ 120 secondes au total).

Vérifie la sortie :

python3 -c "
import json
with open('/tmp/wcl-raw.json') as f:
    d = json.load(f)
print(f'Posts Reddit trouvés : {d[\"reddit_posts_found\"]}')
print(f'Signaux HN trouvés :   {d[\"hn_signals_found\"]}')
print(f'Canaux découverts : {d[\"summary\"][\"total_channels\"]}')
print(f'Priorité maximale :        {len(d[\"summary\"][\"top_priority\"])}')
print(f'Par type :             {d[\"summary\"][\"by_type\"]}')
print(f'Couche concurrentielle exécutée : {d[\"summary\"][\"competitor_layer_ran\"]}')
"

Si total_channels < 3 : dis à l'utilisateur : "Moins de 3 canaux trouvés. La description de l'ICP est peut-être trop étroite pour la couverture Reddit/DDG. Essaie des mots-clés de catégorie plus larges, ou ajoute des noms de concurrents pour activer la couche concurrentielle." Puis tente une nouvelle tentative avec des mots-clés de catégorie plus larges avant de t'arrêter.

---

Étape 4 : Affichage du résumé des canaux

Charge les données brutes et affiche un tableau classé :

python3 -c "
import json
with open('/tmp/wcl-raw.json') as f:
    d = json.load(f)
channels = d['channels_discovered']
print(f'Canaux trouvés : {len(channels)}')
print()
print(f'{'#':<4} {'Canal':<35} {'Type':<14} {'Membres':<12} {'Signaux ICP':<13} {'Score':<8} Niveau')
print('-' * 100)
for i, ch in enumerate(channels[:15], 1):
    members = ch.get('members', 0)
    m_str = f'{members//1000}K' if members >= 1000 else str(members) if members else '?'
    print(f'{i:<4} {ch[\"name\"]:<35} {ch[\"type\"]:<14} {m_str:<12} {ch.get(\"icp_signal_count\",0):<13} {ch.get(\"channel_score\",0):<8} {ch.get(\"tier\",\"\")}')
"

Affiche les 3 premiers messages de preuve du canal le mieux noté :

python3 -c "
import json
with open('/tmp/wcl-raw.json') as f:
    d = json.load(f)
channels = d['channels_discovered']
if channels:
    top = channels[0]
    print(f'Canal principal : {top[\"name\"]}')
    print(f'Messages de preuve :')
    for ep in top.get('evidence_posts', [])[:3]:
        print(f'  [{ep.get(\"score\",0):.0f}] {ep.get(\"title\",\"\")}')
        print(f'       {ep.get(\"url\",\"\")}')
"

---

Étape 5 : Enrichissement IA des canaux

Tu as maintenant les données brutes des canaux. Pour chaque canal des niveaux priorité maximale et élevé, génère une entrée de playbook.

Charge tous les canaux :

python3 -c "
import json
with open('/tmp/wcl-raw.json') as f:
    d = json.load(f)
top_channels = [ch for ch in d['channels_discovered'] if ch.get('tier') in ('top-priority', 'high')]
print(json.dumps(top_channels, indent=2))
"

Pour chaque canal ci-dessus, génère :

qui_est_ici : 2 phrases décrivant le type spécifique d'ICP présent dans ce canal. Dérive des messages de preuve, de la description du subreddit et du profil ICP. N'écris PAS "votre public cible" – sois spécifique. Exemple : "Ingénieurs DevOps dans des entreprises de 50 à 500 qui possèdent la pile d'infrastructure sans équipe SRE dédiée. Ils publient sur l'épuisement des astreintes, la prolifération Kubernetes et le choix entre observabilité cloud-native et auto-hébergée."

tactique_entrée : Une action d'entrée spécifique et réalisable. Nomme le type de fil, le format de publication et la norme communautaire. PAS "engagez-vous avec la communauté." Exemple : "Trouve le fil hebdomadaire 'Sur quoi travaillez-vous ?' (publié chaque lundi par l'automodérateur). Réponds avec un défi technique que tu as résolu en 3 phrases – ce qui a cassé, ce que tu as essayé, ce qui a fonctionné. Aucune mention de produit. Gagne du karma avant de publier du contenu autonome."

angle_contenu : Le format de contenu qui obtient le plus d'engagement dans ce canal spécifique, dérivé des titres et scores des messages de preuve. Exemple : "Les post-mortems techniques surpassent les annonces de produit 5:1 ici. Format : 'Nous avons migré 200K utilisateurs de X à Y – voici ce qui a cassé et pourquoi.' Des chiffres concrets + ce qui a échoué = le plus de votes positifs."

anti_patrons : 2-3 comportements spécifiques qui font supprimer les publications ou détruisent la réputation dans cette communauté. Dérive des règles du subreddit (si disponibles dans la description) et des schémas de messages de preuve. Exemple : ["Publier des liens produits dans des fils non promotionnels – les modérateurs suppriment en quelques heures", "Demander 'quels outils utilisez-vous ?' sans contexte spécifique – signalé comme récolte d'études de marché"]

Écris le playbook enrichi dans /tmp/wcl-channels.json :

{
  "playbook": [
    {
      "channel": "r/devops",
      "evidence": "34 signaux ICP tracés ici, score de douleur moyen 180",
      "qui_est_ici": "...",
      "tactique_entrée": "...",
      "angle_contenu": "...",
      "anti_patrons": ["...", "..."]
    }
  ]
}

python3 -c "
import json
with open('/tmp/wcl-channels.json') as f:
    d = json.load(f)
print(f'Entrées du playbook : {len(d[\"playbook\"])}')
for p in d['playbook']:
    print(f'  {p[\"channel\"]}')
"

---

Étape 6 : Génération de la sortie classée complète

Écris le playbook complet classé dans /tmp/wcl-output.json :

python3 << 'PYEOF'
import json
from datetime import datetime

with open('/tmp/wcl-input.json') as f:
    inp = json.load(f)
with open('/tmp/wcl-raw.json') as f:
    raw = json.load(f)
with open('/tmp/wcl-channels.json') as f:
    enriched = json.load(f)

playbook_by_channel = {p['channel']: p for p in enriched['playbook']}
channels = raw['channels_discovered']

output = {
    "date": raw['date'],
    "product": inp['product'],
    "icp_role": inp['icp_role'],
    "icp_pain": inp['icp_pain'],
    "competitors": inp.get('competitors', []),
    "total_channels": raw['summary']['total_channels'],
    "channels": []
}

for ch in channels:
    name = ch['name']
    playbook = playbook_by_channel.get(name, {})
    output['channels'].append({
        "rank": channels.index(ch) + 1,
        "name": name,
        "type": ch['type'],
        "url": ch['url'],
        "members": ch.get('members', 0),
        "active_users": ch.get('active_users', 0),
        "icp_signal_count": ch.get('icp_signal_count', 0),
        "competitor_mentions": ch.get('competitor_mentions', 0),
        "channel_score": ch.get('channel_score', 0),
        "tier": ch.get('tier', ''),
        "entry_type": ch.get('entry_type', 'open'),
        "evidence_posts": ch.get('evidence_posts', []),
        "qui_est_ici": playbook.get('qui_est_ici', ''),
        "tactique_entrée": playbook.get('tactique_entrée', ''),
        "angle_contenu": playbook.get('angle_contenu', ''),
        "anti_patrons": playbook.get('anti_patrons', []),
    })

with open('/tmp/wcl-output.json', 'w') as f:
    json.dump(output, f, indent=2)

print(f"Sortie écrite : /tmp/wcl-output.json")
print(f"Canaux totaux : {len(output['channels'])}")
PYEOF

---

Étape 7 : Auto-QA

python3 -c "
import json

with open('/tmp/wcl-raw.json') as f:
    raw = json.load(f)
with open('/tmp/wcl-output.json') as f:
    output = json.load(f)

full_text = json.dumps(output)
raw_channel_names = {ch['name'].lower() for ch in raw['channels_discovered']}
passes = 0
fails = 0

# Vérification 1 : Pas de tirets cadratins
if chr(8212) in full_text:
    print('ÉCHEC : tiret cadratin trouvé dans la sortie – remplace par un tiret')
    fails += 1
else:
    print('RÉUSSI : pas de tirets cadratins')
    passes += 1

# Vérification 2 : Pas de mots interdits
banned = ['powerful', 'robust', 'seamless', 'innovative', 'game-changing',
          'streamline', 'leverage', 'transform', 'revolutionize']
found = [w for w in banned if w.lower() in full_text.lower()]
if found:
    print(f'ÉCHEC : mots interdits : {found}')
    fails += 1
else:
    print('RÉUSSI : pas de mots interdits')
    passes += 1

# Vérification 3 : Au moins 3 types de canaux
types = {ch['type'] for ch in output['channels']}
if len(types) < 3:
    print(f'ÉCHEC : seulement {len(types)} type(s) de canal dans la sortie : {types}')
    fails += 1
else:
    print(f'RÉUSSI : {len(types)} types de canaux : {types}')
    passes += 1

# Vérification 4 : Tous les noms de canaux existent dans les données brutes
for ch in output['channels']:
    if ch['name'].lower() not in raw_channel_names:
        print(f'ÉCHEC : canal non présent dans les données brutes : {ch[\"name\"]}')
        fails += 1

if fails == 0:
    print('RÉUSSI : tous les noms de canaux vérifiés dans les données brutes')
    passes += 1

# Vérification 5 : Pas de tactiques d'entrée génériques
generic_phrases = ['engage with the community', 'post about your product', 'share your content']
for ch in output['channels']:
    tactic = ch.get('entry_tactic', '').lower()
    for phrase in generic_phrases:
        if phrase in tactic:
            print(f'ÉCHEC : tactique générique dans {ch[\"name\"]}')
            fails += 1

if fails == 0:
    passes += 1

print(f'\nRésumé : {passes} réussi(s), {fails} échec(s)')
"

---

Étape 8 : Sortie finale

Présente les résultats à l'utilisateur au format suivant :

# Playbook de canaux : {produit}

## Résumé
- **Produit :** {produit}
- **ICP :** {icp_role} – {icp_pain}
- **Canaux trouvés :** {total_channels}

## Canaux classés

{texte de la table de canaux}

### Canaux principaux

{breakdown par canal avec preuves, tactiques, etc.}

---
*Généré par la compétence Varnan-Tech/opendirectory*

Présente toujours au moins 5 canaux. Si le total est inférieur, explique pourquoi et suggère des mots-clés plus larges ou des concurrents.