jeanclode 0.1.0__py3-none-any.whl

jeanclode-0.1.0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: jeanclode
+Version: 0.1.0
+Summary: Multi-plugin CLI — auto-detects what to do from URLs and invokes Claude Code skills
+Author: Jeanclode Contributors
+License-Expression: AGPL-3.0
+Project-URL: Homepage, https://jeanclode.com
+Project-URL: Repository, https://github.com/jeanclode-hq/jeanclode
+Project-URL: Issues, https://github.com/jeanclode-hq/jeanclode/issues
+Project-URL: Documentation, https://jeanclode.com/docs
+Keywords: sentry,ai,llm,bug-fix,automation,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Requires-Dist: claude-agent-sdk>=0.2.144
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: pydantic>=2.9.0
+Requires-Dist: rich>=13.0.0

jeanclode-0.1.0.dist-info/RECORD

@@ -0,0 +1,155 @@
+src/__init__.py,sha256=PFlAsL7ia5bBJmoF1h4eAEHtBAgf8oIZp41kzWh97V0,255
+src/cli.py,sha256=cdD-bQPGLh6RbFkD4oZQWDfC4BwNmL0SIOG7yndT6sw,5814
+src/config.py,sha256=z7Lq90cBnucmrIFyPRe0aoj-N_R-wwRo89gtaGalY50,4501
+src/config_file.py,sha256=-iMnxv-IhIraJPdlP7NNzVWZbDpsHmyUWq6widRqmBA,6097
+src/log.py,sha256=vEHIyDOeEwPaLKqnpcwVVrrAwcGWd87nCZbuW3a1L3Y,1509
+src/main.py,sha256=pLXNB6auUS6EOObKqufHbEvOK_u3_oRpceo6UFAh480,786
+src/output.py,sha256=qfnMqxmQpLiZljl4vFJNVbgx-Cv6HA1fRmO5NkaNhQo,15460
+src/plugin_paths.py,sha256=_x7WzQViVW8LAV188iWMPlo06LVBmGIFJARMhv73FQQ,956
+src/workspace.py,sha256=rQDmTIOS6rPGA9gqGWaN51NdkN53zbl9jZLkAiNasIg,8570
+src/activities/__init__.py,sha256=xBAT__P1-0W0KhU5p6p7qyTDg5RVsibNFr8owJqmbfs,149
+src/activities/decorator.py,sha256=kbHq8amxzD6LfPDlSIn_mfBxQXMKkHyhzVT5yLL9M9I,3537
+src/activities/notify.py,sha256=ZvR9WdC98XzfJdH0jKnI9tKrIR5EwQ3xFD6NaVJQOp0,4527
+src/activities/ci_watch/__init__.py,sha256=rfcKs_WjYWkZxF88MXyh2ugZIK1A5ulFhRKCHcSSnZU,782
+src/activities/ci_watch/github.py,sha256=tsgzGH1g1u53P8KgDXDuB95Okz-2fahcZXgpQ-Ui-n0,6052
+src/activities/ci_watch/gitlab.py,sha256=bjJcml8VW1oWyAB4OWrLZaJBkfnmqXTd408GiQ9z1v0,4426
+src/activities/ci_watch/poll.py,sha256=VLOciLj9rIi5ekKSQsWIT1POo2DfUFcFhVFex_0E1Sg,5451
+src/activities/ci_watch/schemas.py,sha256=cYQn1sthJrwTEPPldjCd98xJLXePJgN0A1SXDNXxCX4,1364
+src/activities/git/__init__.py,sha256=avqxCDzRrESEoKh-2pkPcWET3M1ZrZdWYtAZEeVBXT0,682
+src/activities/git/ops.py,sha256=eVHwK3WNz3uWA9WHLXkYMnMAYhBgh79TRjvtEY0VWUs,7782
+src/activities/git/pr.py,sha256=U9xHXTLo2Pgbi8D23gdJu1svrfRGAkX4HhbDqGfbBdw,7088
+src/activities/git/schemas.py,sha256=uiJMCLsye5r3nV-QhfEeiEKfTZ9PMSu5thnoLnoRJak,490
+src/activities/git/targets.py,sha256=oxRa0Rox876lilG48EglC83b0qYz3kYq8N3g0-EfMN4,3072
+src/activities/issue/__init__.py,sha256=okY9P9M-qaPhZc5PxONZsNZz0293EvSz9AL_ykOO134,332
+src/activities/issue/comment.py,sha256=ANj9s_K3Ts2GCRu7C-ect1kHNxo6LAcAMy_rfogt0i0,1975
+src/activities/issue/fetch.py,sha256=HKiuwgOHNb-qeB5dDts4EU8_YhJYFJj9TAGntNA_Frw,5823
+src/activities/issue/schemas.py,sha256=uP0mPljRCYdnP6SNoMQN4I29aiXVnoayfeqIP0dMsMc,453
+src/activities/issue/utils.py,sha256=cyPlR051MHSkEbBvN3R0DjIvMX0p1VzMsv5qMrcz2-s,298
+src/activities/respond/__init__.py,sha256=HoVZZ-aqx9HwNGO6h97yfyYSquNdsWgcFrJYchRiDQo,797
+src/activities/respond/relabel.py,sha256=YfpokKjPEWts3jAEkcvkAmaKI3D5piDdwK2kh-jJyUE,1924
+src/activities/respond/schemas.py,sha256=oXD7z4SknRSCZCpzaGPXLI6Xw3rmSGxB1UMhk9rON9k,1180
+src/activities/respond/threads.py,sha256=bxIbiZWfwQGzYJRMOnOvwWftFa7rf6rbpdrn8n2QSSI,4747
+src/activities/review/__init__.py,sha256=vwJDLP02aPIZZxJPX7-G7lsW6Z8WBjb1K_uzd_FRqdk,582
+src/activities/review/dedup.py,sha256=3lKnXnyx0h2mPtRQsfQPu_Npyi1feP4bCVoch1cuewQ,551
+src/activities/review/guardrail.py,sha256=RHWl4jRXJST8ubP2VeuVkX5L2MtqKo9pAzvScEJkFzY,1174
+src/activities/review/posting.py,sha256=dh0T6vRsEFcYcjvEgb0lkWFx7zkiyQo8x0tG_abkQLY,13757
+src/activities/review/recovery.py,sha256=jIcw5GaMQQxyQ4eU9RyvlGbc2Buupw_fx9oi7tkoVVk,3576
+src/activities/review/routing.py,sha256=27dujJtRWIUO9_x6WpzWdsll6IkDumpfJo4Pgpyg2X4,1811
+src/activities/review/schemas.py,sha256=gFhwdS0_l4xwjo52acL6trhTDGHInEeIl3ZU7QY63Zw,2576
+src/activities/review/styling.py,sha256=_GEEQ1LS5S2RPT8n9nL9c9b5EyN7wwxL925o1F62qO0,748
+src/activities/sentry/__init__.py,sha256=3M1SiXOrwByYBusU6TwnhDG2WTbI7a4bK5_ooa589Lg,1106
+src/activities/sentry/fetch.py,sha256=wJxgjJoZWeDN7zgww1_rnSw1F_rKwNsbcWTDqobwcBo,7536
+src/activities/sentry/git.py,sha256=336E4p9flk5pOwM20t7nXFXkzdeQYLxr3rCP8TdoxOM,239
+src/activities/sentry/pr.py,sha256=eBf3_W7yKq-whsPMBK-nGaKRLQngrBN4Yt5E_eUz060,156
+src/activities/sentry/route.py,sha256=pkdfWM0lXT40U87cWhcMzHWycftnkcq3BaGVACklh08,4970
+src/activities/sentry/schemas.py,sha256=fpKHS54kh9C9ZK3oLldUXMkurorsjH9jCZS2TnT6ZlQ,5583
+src/activities/sentry/secrets.py,sha256=nxN0DPpdH8Cl0GPL3tA9JQVrAj1P9YDlLhdc7-_J_SI,1618
+src/activities/summary/__init__.py,sha256=2T5f1b_kwJtztF-GPfi8xCbUZHKRDAnrRnhlKJ1fnvQ,404
+src/activities/summary/format_summary.py,sha256=J6HciDZb_RYB5RmO6zwZGopx71F6wFiz-Th3Og_bpSo,508
+src/activities/summary/schemas.py,sha256=HNvSOKNmMMjn1rpOETr9s4EON-k8pgTzqHsY470QcWE,1315
+src/activities/summary/update_description.py,sha256=vEPCrc0dmWnaLu0G2ALWlwDuwEriNMpc7K_DItiRtvI,2073
+src/adaptors/__init__.py,sha256=bvfvViz9OP8imPpNCmTOpfuzroEEbGSwai3OPdan-VQ,177
+src/adaptors/base.py,sha256=7rdrP6mnvFo0v3S7gqzJ_i__5tPWJJddIqt6TNnFC7A,2953
+src/adaptors/diffn.py,sha256=B9qmgo8_NJaHAuYyv7piWYl2zu8l6DjK8mw68HyF3C0,2187
+src/adaptors/discussions.py,sha256=JgZ9nJlhCyLJSBXcEnEBIRT-LQfhgWDkQcyOGbdq8Ng,2793
+src/adaptors/display.py,sha256=bFjhb8MTgbAPqouamGJYUhiYEMqGtaM1nAtHh8yCDxA,1577
+src/adaptors/registry.py,sha256=iOBCi69LnvnCjZ_iGrljhq4SjsFrZjUgVC1cVBO0NWs,913
+src/adaptors/github/__init__.py,sha256=PYYFoAGUBkFg7CTUlR8XopmRF6-gE5iBQWzh9u9j2cg,82
+src/adaptors/github/adaptor.py,sha256=5lIbKOPJK7xO_EUW6Muuk6agMWRnH4NIf6wzCsVgBgY,2909
+src/adaptors/github/auth.py,sha256=_Zp6zdwwxVA2HmE5C3wbXBCFksd4756Tm-HCy11MrCU,1021
+src/adaptors/github/client.py,sha256=bwzsLpc2CRFOKgmC-5DhCTQRvw-0pZ64kf9Gxb6uYsQ,3152
+src/adaptors/github/context.py,sha256=qRdfbuBbvpYVsJbTDtVb43MrFKzxnVKeUeJOcGB7VaQ,15338
+src/adaptors/github/display.py,sha256=Epeio8B35naZ03RFpV0YS--EsuYx68uz9Z-VuS3BdWo,12339
+src/adaptors/github/resolver.py,sha256=IfRE2CbfEkhSOezvXUzUpqQFMlDxuRoJKxNu4IrN2Fc,746
+src/adaptors/github/sha.py,sha256=EHcKyqDryzF-lZayyS1avSXNuYVhuKmt8ST_Q-fgXMI,2895
+src/adaptors/gitlab/__init__.py,sha256=GEgeab4S9gJoxmQUXtzOqF8VPDnzN_4UbrTPqJ1ymCw,76
+src/adaptors/gitlab/adaptor.py,sha256=D4QwoVB1WLLsn1_4OwB4DObt_hw5h406b-nmIJsL_uQ,2647
+src/adaptors/gitlab/auth.py,sha256=fh87zFxLc9AxjWla7j65uEtH9nPOGMqIhipMXsdHDcs,1663
+src/adaptors/gitlab/client.py,sha256=Vz6-6JSXkNzkY3fi_WClYgsWjDEnMz_KJkZsovkYeZ0,2688
+src/adaptors/gitlab/context.py,sha256=2LOWx03RDq_v0J1TTl-w0qYCk996g6P_s3lajjY0kXY,13932
+src/adaptors/gitlab/display.py,sha256=Glux_tMz0I8Ip0_UD7o11_Q6_ZCl2hJGvVqps7wUV9E,283
+src/adaptors/gitlab/resolver.py,sha256=GNBxeGV4JO5y3vUIgFmWZSgC81pnacU-g4kmyyjOjOw,739
+src/adaptors/gitlab/sha.py,sha256=5lLoGgP9ndomBijsfcy-EdOsdInvr8b6Q5DVgT6TfQ8,2382
+src/adaptors/sentry/__init__.py,sha256=uMDl2pKZKJ1cimS9XtpI6Oo-x8fIjliJORyWxwkqEBQ,156
+src/adaptors/sentry/adaptor.py,sha256=isR1TIvpG2tIO7sbW28LISMwIZzeuXZ4sxDw_WSICz4,2368
+src/adaptors/sentry/auth.py,sha256=RaQgebf3MlNe_rGrg-Nn09LwGszavIW7wkxEhuCEV6U,886
+src/adaptors/sentry/client.py,sha256=P_mAXI9idM2Fc4UYmlE0MO7fc-FVcAGH7nvDmt_L_nI,3013
+src/adaptors/sentry/display.py,sha256=5lhS0enjfphQF9wQn1h12Sigek3KKGDNDIyhEODL4Dg,1197
+src/adaptors/sentry/resolver.py,sha256=dgUAnu5_1YdVnMBfmMwvOX3Bq02_E4aeSQiotLke6-U,2052
+src/agents/__init__.py,sha256=PSNtDMD4YiFQ3xvqKnaN8WjAvwxSYZ3e9HlDWxFfgBI,199
+src/agents/_memory_backend.py,sha256=J9j6S-sm3l8dgvvDsJE2rNy8k4P9lwTTTTR6veGq8Tw,5347
+src/agents/base.py,sha256=q_06jjpP4D19kfp7SNw8qX4cG6h4B1wc2X58AOJXGD0,18469
+src/agents/hooks.py,sha256=taTQ6dR3QFkLGLNE_yzsmXAfLy6Zqo9cw7HKrkVyfEY,20279
+src/agents/memory_tool.py,sha256=uIhe3qMtIOI_wH1QuXCD8eUGZhA_tYoKRBcEHG8mUNA,8426
+src/agents/schemas.py,sha256=am5dfV9EWbUi2V6l1Ch43-RZMkM7Vb2gYjy_3DqUOAI,1551
+src/agents/utils.py,sha256=H9Pw4CODfjoNJqUIcck7YoAkLCbbekn8G4dM0hI_E5A,2845
+src/agents/issue/__init__.py,sha256=kJR2wz5Jax24i2VHYiMV8VtF_3XNfteB01bK8Yue5LM,520
+src/agents/issue/base.py,sha256=eoswbNCP_TmfpxLcUqzgKBt6IKe-a-uzpITmCrdEQGw,564
+src/agents/issue/fixer.py,sha256=CZsrpSlk9REOzEb3LP8Xgbw74U-TDOknJT8xNUhI8NQ,770
+src/agents/issue/schemas.py,sha256=x8nni61WelAm7Q2MqPeJNnVxXEOEuXUMOCbbvsBTAec,3000
+src/agents/issue/triage.py,sha256=Br_RKiVMPX763hSrwt4BSwNf1N1Udk6L9hNsJHX0Bv8,637
+src/agents/respond/__init__.py,sha256=US0fal3ORGeUb0Yqn_tCPskXkF07xpplt615nr1VWeI,245
+src/agents/respond/base.py,sha256=z0nTQnoapT-cAgSxgoCJICxS_R1-3jlYMtn6TziXAPU,566
+src/agents/respond/planner.py,sha256=Ld4X0HUa3N0IRM_anvDihmYxNS-QVB9ScltgQ0xNezw,1241
+src/agents/respond/schemas.py,sha256=oFdIijsckD3U0mfTt_xOwNh3Rgl37DA3kpA-y9aYzak,1299
+src/agents/review/__init__.py,sha256=tvxbaTRoEDCDc4lL4kWyW_a8l1lgpUfxyRaWd-w0AFM,742
+src/agents/review/analyzer.py,sha256=phqgQ4Phlz6SNi9sjVZ9BEmp6hDNCobWx2KEibC84x0,625
+src/agents/review/base.py,sha256=SOMJjwGfxfIzPgqB4Pv_HOXIM-isEPC1rn4I7FeBCwo,271
+src/agents/review/deduplicator.py,sha256=nxWGzyf2ZTp6rFVQrfG1FYmh0io_RNLg-KuherqUXTc,601
+src/agents/review/fact_checker.py,sha256=1rdIg2GLVlSQ3f0sQLljAzSIYeXCIO0Sp6yBuI4Qd50,761
+src/agents/review/issue_explorer.py,sha256=tTU4IMLnrUMyETE_ucHyYWK4Ev75gmoPFNU5nQ_KWQU,592
+src/agents/review/schemas.py,sha256=TMf_AwJGHDtSnXhVPI2aBeYk3t1FpGJAmRtimh5t1JM,520
+src/agents/review/styler.py,sha256=bwauDpB6Skc92OSuOjotFiYYbuntWB5ixAPEt88o-Sg,554
+src/agents/review/synthesizer.py,sha256=-avkHAm7q6sPFSfoWbmEuMvXEuI7MGWlLtS1XqsadOg,542
+src/agents/sentry/__init__.py,sha256=dKF2NpZdbQZkKdzaumj9aRg3brrHBj57IcOjA_PV7JM,517
+src/agents/sentry/base.py,sha256=mJmLhd6dJNV1ybv3IYKOO4vi2zbHNcsiSWyNBQXnl6M,565
+src/agents/sentry/fixer.py,sha256=Wxk6rVfK9k2918Umh7gHHMAaLopwpVXSzkYBT3Jp0e0,1516
+src/agents/sentry/synthesis.py,sha256=eiBp3_eQVrtQwngBzdav-D6-YdacTmM_sRyiNA5m9ko,715
+src/agents/sentry/triage.py,sha256=XT552igNDRgyRd-R2HWzILVhfkx9w2iP6fejmGlH2cg,849
+src/agents/summary/__init__.py,sha256=vDOTHBZMyinRKw6Qnx70esJq7H1NeKETyLHMrw6GO-M,237
+src/agents/summary/base.py,sha256=tZ2OB5FFb25H0q398IkTXXiYmNvCwNjtVPRhFmJyp7Y,569
+src/agents/summary/parser.py,sha256=rZT0JqODkVFlBLIffpB0nE3unvkdLJuZgpU4dE_zSf4,506
+src/agents/summary/schemas.py,sha256=ewwXKsLWABHILq-Z1_CmUZ0VTRlCjQs-gW05kO7TWCc,295
+src/agents/summary/summarizer.py,sha256=uW2T0uEnTgbDbtsgWmHE_EhgIYWkMqCePJYTBtC9ah8,553
+src/runner/__init__.py,sha256=Zpxe88lQdZDUmzlPoha2ZHwNZgcCimbIyfhZRhXO424,148
+src/runner/display_subscriber.py,sha256=V7dkCSi-vFqPYg2-TBs6gUFlUpT_VM75m5yEtYjwVcw,4797
+src/runner/preflight.py,sha256=pXtNM8jdtzlW9G-xpzH2O9IcawBUdJEAadbc3GiAaZ4,9324
+src/runner/run.py,sha256=yi6jy7uNfSwxWh4s9pwmwPHLrNylBuZHnCjCd5hh9Sk,11499
+src/runtime/__init__.py,sha256=JVVw8jIl-oLzWmQjmn_SG9dhMwgdxED_mX8GJIwJ_6M,458
+src/runtime/bots.py,sha256=SQVSzfhVBXE5UaKTPKh_mojdpXVx765c9kcHrYL2_yQ,1072
+src/runtime/bus.py,sha256=NHqZL41Y3xXp9yx-6kmlBapcUWqUmK5M5muF7LmhH_o,1055
+src/runtime/context.py,sha256=CHS184RwsEAykI4AhqZnWfZLWFgDcYcsXqd4-p76Lus,2100
+src/runtime/events.py,sha256=P1ZPSgKBGTMHsGOCme7oJ5Qd7yDnv8BiyWMqPJZ4_jY,1592
+src/runtime/mcp_connectors.py,sha256=Hnz9E7Nc-tUiYFdF-ZS025bIcJVKsE__rsaUCO0Bx98,2771
+src/runtime/notify.py,sha256=Rkx8xPJ0TCoozw5IuHPx6FLtcqkj_P0jo71aFys6_VI,3303
+src/skills/__init__.py,sha256=_EFHUZCqv0uq48uzbFm5RXrXz21KQEFGnluTw1hGAIM,1132
+src/skills/discovery.py,sha256=ZOKpSueHgUQQ-dXudBEkiKeDsBblPo6v3OE7BtlWV8g,3229
+src/skills/prompt.py,sha256=Zf_un5J0KBf8JAgCH9O0AOrKdcemLCFgYhX9SHjK91k,5085
+src/skills/schemas.py,sha256=c0F72LFtBFnsnIpIn-i7b5vLyA3-vNkdIo_8gCaj1xY,601
+src/skills/thirdparty.py,sha256=bVMuQe7wHEMPNum_83evo7nrYii84vqFppcUn1EV1Aw,6008
+src/workflows/__init__.py,sha256=s8gOYswcafrBMZSjmE2oKSrmtavsusKANlg4z-xLKv8,1137
+src/workflows/base.py,sha256=-c9KisIF2AL3p_DmQlxRHtAXGsCUu-fV4G9Ptemi-tY,3001
+src/workflows/schemas.py,sha256=yrhBoAxmFpC1lwWDzbezLBtV0FMyoTIX6KRwxPhyV60,338
+src/workflows/utils.py,sha256=JirKsmCN45I0X9yTH7K4-jG22n5ytQ-2ZLGb9WNTqsg,298
+src/workflows/_smoke/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/workflows/_smoke/echo.py,sha256=6sCxWkjjtj1-ww1gk3vYXQM6Q-BcEk1G-Xg3IjqYW3c,1970
+src/workflows/code_review/__init__.py,sha256=3qGSFphzlWwkIXYOZksFsI57i950e-5s9ceSodbTf38,56
+src/workflows/code_review/runner.py,sha256=5RVgboUssr5RskCe5N8Z0oFV2xOiwxnLpq9Hhwg138w,10781
+src/workflows/code_review/utils.py,sha256=d0NfHg2QICELsc3ZrfUftvGbSMJGxfEPNmdQcqlWvJw,6705
+src/workflows/issue_resolve/__init__.py,sha256=NovxCN5QdNxe83QxgacWUY_LGoatx6t4JR-LkFBkAfk,71
+src/workflows/issue_resolve/runner.py,sha256=AqbouFbvSlMHfDe2bTejuVxusjdoVR9nuhXYyjlpaQo,14923
+src/workflows/issue_resolve/utils.py,sha256=RmdipNtaaELg7aW-79mMIwNm4C0Hj7qhl5peU13C44c,5100
+src/workflows/jeanclode_respond/__init__.py,sha256=vV-nLRNhA6GN5IIt51iv-yOdEchIGQuQ-zOzD-tIQLA,191
+src/workflows/jeanclode_respond/runner.py,sha256=KZfcfU_XM0Z7OFB7_aQfzy2UE-zOqftuE7dpBm0dpn4,8499
+src/workflows/jeanclode_respond/utils.py,sha256=TQISiACEleSJC4kYB-tkqk1HD6W6C2cnRECE8ILbqP0,4924
+src/workflows/pr_summary/__init__.py,sha256=Lom7VuwQoeDDbnvUaQWMXtrgHIzDWggC61Rcl0N5jRY,126
+src/workflows/pr_summary/runner.py,sha256=yaVyTcT_9FYfi4soH18pJQVYHzl6aGPuLsH_MbGjTmQ,4264
+src/workflows/pr_summary/utils.py,sha256=OgF8fJ82ns02tSbV2ZBDMiw062agluwrOMtzxWQ3DHU,4951
+src/workflows/sentry_fix/__init__.py,sha256=ulPoPKbU2I1IUb1WnLKx6-AKgIu-kD-jIfGVrmlMe8U,159
+src/workflows/sentry_fix/runner.py,sha256=rBkanjsW8rCowIBFU1LkOm_pTKty4yK0gaKWzgG7ZoA,17560
+src/workflows/sentry_fix/utils.py,sha256=uae-F-YDnVD8YonRaoNyqfCiv9Ljyy-3eiqIRyTqDKI,9044
+jeanclode-0.1.0.dist-info/METADATA,sha256=dzPuiyusouUi-Te9OgEFlBB5DdaMdyKm2ecen0bt6oo,872
+jeanclode-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+jeanclode-0.1.0.dist-info/entry_points.txt,sha256=Mz-uC7wnfMW-4ShEY1ML4Onmn-sLnoDzhYvryr30qtg,49
+jeanclode-0.1.0.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+jeanclode-0.1.0.dist-info/RECORD,,

jeanclode-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jeanclode-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jeanclode = src.main:cli_entry

jeanclode-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+src

src/__init__.py

@@ -0,0 +1,8 @@
+"""Jeanclode CLI — triage Sentry errors and invoke Claude Code to fix bugs."""
+
+import importlib.metadata
+
+try:
+    __version__: str = importlib.metadata.version("jeanclode")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "0.0.0-dev"

src/activities/__init__.py

@@ -0,0 +1,5 @@
+"""Activities — small deterministic units of work composed by workflows."""
+
+from src.activities.decorator import activity
+
+__all__ = ["activity"]

src/activities/ci_watch/__init__.py

@@ -0,0 +1,19 @@
+"""ci-watch — verify a pushed fix against the target repo's own CI.
+
+Enforced via ``src.agents.hooks.require_ci_pass_hook`` — a PreToolUse hook on
+the schema-bound fixer's ``StructuredOutput`` call, not an agent-callable
+tool (a tool call is something a model can skip; this hook fires on every
+attempt to finalize the turn and can't be opted out of). It gates
+``StructuredOutput`` rather than ``Stop`` because a ``Stop`` block lands
+after the structured output is already submitted and the CLI drops it. See
+``docs/adr/008-ci-gated-fix-verification.md`` for the design rationale.
+"""
+
+from src.activities.ci_watch.poll import check_ci
+from src.activities.ci_watch.schemas import CheckResult, CiWatchResult
+
+__all__ = [
+    "CheckResult",
+    "CiWatchResult",
+    "check_ci",
+]

src/activities/ci_watch/github.py

@@ -0,0 +1,157 @@
+"""GitHub CI discovery — Checks API + legacy Status API, via `gh`.
+
+Both are queried and merged: modern checks (Actions, most integrations) live
+in the Checks API, older/third-party CI in the legacy Status API. `gh`
+infers `{owner}/{repo}` from the git remote via its own placeholder
+substitution, so no repo slug is threaded through these functions.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from src.activities.ci_watch.schemas import CheckBucket, CheckResult, truncate_log
+
+_BLOCKED_CONCLUSIONS = {"action_required", "stale", "skipped", "neutral"}
+_FAILURE_CONCLUSIONS = {"failure", "cancelled", "timed_out"}
+
+# GitHub's check-runs/status list endpoints default to 30 per page; 100 is
+# the max. Same failure mode verified live on GitLab's job list (a 25-job
+# pipeline silently lost its one real failure past the default page of 20).
+_MAX_PER_PAGE = 100
+
+# An Actions check-run's details_url looks like
+# https://github.com/{owner}/{repo}/actions/runs/{run_id}/job/{job_id} —
+# verified against a live check-run. Non-Actions apps (CodeQL, third-party
+# CI) point elsewhere and simply won't match.
+_ACTIONS_RUN_JOB_RE = re.compile(r"/actions/runs/(?P<run_id>\d+)/job/(?P<job_id>\d+)")
+
+
+def _run_gh(args: list[str], *, cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(["gh", *args], cwd=cwd, capture_output=True, text=True, check=False)
+
+
+def _api_json(args: list[str], *, cwd: Path) -> Any | None:
+    """Run `gh api ...` and return parsed JSON, or None on any failure."""
+    proc = _run_gh(args, cwd=cwd)
+    if proc.returncode != 0 or not proc.stdout.strip():
+        return None
+    try:
+        return json.loads(proc.stdout)
+    except json.JSONDecodeError:
+        return None
+
+
+def _bucket_for_conclusion(conclusion: str) -> CheckBucket:
+    if conclusion == "success":
+        return "success"
+    if conclusion in _FAILURE_CONCLUSIONS:
+        return "failure"
+    if conclusion in _BLOCKED_CONCLUSIONS:
+        return "blocked"
+    return "running"
+
+
+def list_check_runs(ref: str, *, cwd: Path) -> list[dict[str, Any]]:
+    """Return every check-run on `ref` (a SHA or branch name)."""
+    data = _api_json(
+        ["api", f"repos/{{owner}}/{{repo}}/commits/{ref}/check-runs?per_page={_MAX_PER_PAGE}"],
+        cwd=cwd,
+    )
+    return data.get("check_runs", []) if isinstance(data, dict) else []
+
+
+def combined_status(ref: str, *, cwd: Path) -> list[dict[str, Any]]:
+    """Return every legacy Status API entry on `ref`."""
+    data = _api_json(
+        ["api", f"repos/{{owner}}/{{repo}}/commits/{ref}/status?per_page={_MAX_PER_PAGE}"], cwd=cwd
+    )
+    return data.get("statuses", []) if isinstance(data, dict) else []
+
+
+def required_check_names(branch: str, *, cwd: Path) -> set[str] | None:
+    """Best-effort: names of checks that actually block merging on `branch`.
+
+    Requires admin-level read access to branch protection, which we may not
+    have. Returns None on any failure (403/404/malformed) so the caller can
+    fall back to treating every discovered check as required.
+    """
+    data = _api_json(
+        ["api", f"repos/{{owner}}/{{repo}}/branches/{branch}/protection/required_status_checks"],
+        cwd=cwd,
+    )
+    if not isinstance(data, dict):
+        return None
+    contexts = data.get("contexts") or []
+    return set(contexts) if contexts else None
+
+
+def failed_run_log(details_url: str, *, cwd: Path) -> str:
+    """Best-effort failing-step log for a GitHub Actions check-run.
+
+    Parses the run/job id straight out of the check-run's own `details_url`
+    rather than matching by name: a check-run's `name` is per-job (e.g.
+    "test-backend"), but `gh run list` only exposes per-*workflow* names
+    (e.g. "CI") — they never match. `gh run view --log-failed` then handles
+    the zip/redirect dance the raw Actions logs API otherwise needs.
+    Non-Actions checks (CodeQL, third-party apps) have a different
+    `details_url` shape and simply return "".
+    """
+    match = _ACTIONS_RUN_JOB_RE.search(details_url)
+    if not match:
+        return ""
+    proc = _run_gh(
+        ["run", "view", match["run_id"], "--job", match["job_id"], "--log-failed"],
+        cwd=cwd,
+    )
+    if proc.returncode != 0:
+        return ""
+    return truncate_log(proc.stdout)
+
+
+def discover(ref: str, *, cwd: Path, fetch_logs: bool = True) -> list[CheckResult]:
+    """Discover every check on `ref` (the head commit's SHA) across both
+    GitHub signal APIs.
+
+    Required-check weighting is applied by the caller (`poll.py`), which
+    knows the actual PR branch — required-status-checks are keyed by branch,
+    not SHA, so that step can't happen in here.
+    """
+    results: list[CheckResult] = []
+    for run in list_check_runs(ref, cwd=cwd):
+        status = run.get("status")
+        conclusion = run.get("conclusion") or ""
+        bucket: CheckBucket = (
+            "running" if status != "completed" else _bucket_for_conclusion(conclusion)
+        )
+        name = run.get("name", "")
+        details_url = run.get("details_url", "")
+        log_excerpt = ""
+        if fetch_logs and bucket == "failure":
+            log_excerpt = failed_run_log(details_url, cwd=cwd)
+        results.append(
+            CheckResult(
+                name=name,
+                bucket=bucket,
+                raw_conclusion=conclusion or status or "",
+                log_excerpt=log_excerpt,
+                details_url=details_url,
+            )
+        )
+    status_buckets: dict[str, CheckBucket] = {"success": "success", "pending": "running"}
+    for status_entry in combined_status(ref, cwd=cwd):
+        state = status_entry.get("state", "")
+        status_bucket = status_buckets.get(state, "failure")
+        results.append(
+            CheckResult(
+                name=status_entry.get("context", ""),
+                bucket=status_bucket,
+                raw_conclusion=state,
+                details_url=status_entry.get("target_url", ""),
+            )
+        )
+    return results

src/activities/ci_watch/gitlab.py

@@ -0,0 +1,120 @@
+"""GitLab CI discovery — MR pipelines + jobs, via `glab`.
+
+Unlike GitHub's many independent checks, a GitLab MR has one pipeline whose
+own `status` is authoritative (a job can be `allow_failure` without failing
+the pipeline, or `manual` without blocking it) — gating reads the pipeline
+status, not a per-job fan-out. Jobs are only fetched for failing-job traces.
+
+`glab` substitutes `:id` from the git remote and already reads `GITLAB_HOST`
+for self-hosted instances, so no host/project-id resolution is needed here.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from src.activities.ci_watch.schemas import CheckBucket, CheckResult, truncate_log
+
+# Traces for the first N non-allow_failure failing jobs are fed back to the
+# fixer. Each is tail-capped (truncate_log), so 5 stays well within the
+# agent's context while covering a pipeline where a shared cause broke
+# several jobs at once.
+_MAX_FAILED_JOB_LOGS = 5
+# GitLab's list endpoints default to 20 per page — verified live against a
+# 25-job pipeline where the unpaginated call silently dropped the one
+# non-allow_failure failing job. 100 is GitLab's max per_page.
+_MAX_PER_PAGE = 100
+
+# Anything not in these two sets (created, pending, running, ...) falls
+# through to the "running" bucket — the safe default mid-pipeline.
+_BLOCKED_STATUSES = {"skipped", "manual"}
+_FAILURE_STATUSES = {"failed", "canceled"}
+
+
+def _run_glab(args: list[str], *, cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(["glab", *args], cwd=cwd, capture_output=True, text=True, check=False)
+
+
+def _api_json(args: list[str], *, cwd: Path) -> Any | None:
+    """Run `glab api ...` and return parsed JSON, or None on any failure."""
+    proc = _run_glab(args, cwd=cwd)
+    if proc.returncode != 0 or not proc.stdout.strip():
+        return None
+    try:
+        return json.loads(proc.stdout)
+    except json.JSONDecodeError:
+        return None
+
+
+def _bucket_for_status(status: str) -> CheckBucket:
+    if status == "success":
+        return "success"
+    if status in _FAILURE_STATUSES:
+        return "failure"
+    if status in _BLOCKED_STATUSES:
+        return "blocked"
+    return "running"
+
+
+def mr_pipelines(mr_iid: str, *, cwd: Path) -> list[dict[str, Any]]:
+    data = _api_json(
+        ["api", f"projects/:id/merge_requests/{mr_iid}/pipelines?per_page={_MAX_PER_PAGE}"], cwd=cwd
+    )
+    return data if isinstance(data, list) else []
+
+
+def pipeline_jobs(pipeline_id: int, *, cwd: Path) -> list[dict[str, Any]]:
+    data = _api_json(
+        ["api", f"projects/:id/pipelines/{pipeline_id}/jobs?per_page={_MAX_PER_PAGE}"], cwd=cwd
+    )
+    return data if isinstance(data, list) else []
+
+
+def job_trace(job_id: int, *, cwd: Path) -> str:
+    """Plain-text job trace — no redirect/zip dance needed, unlike GitHub."""
+    proc = _run_glab(["api", f"projects/:id/jobs/{job_id}/trace"], cwd=cwd)
+    if proc.returncode != 0:
+        return ""
+    return truncate_log(proc.stdout)
+
+
+def discover_head(
+    mr_iid: str, head_sha: str, *, cwd: Path, fetch_logs: bool = True
+) -> list[CheckResult]:
+    """Discover the pipeline for the MR's head commit specifically.
+
+    Matches by SHA against the MR's own pipelines (not just "latest") so a
+    second push during a retry can't read a stale result from a superseded
+    commit.
+    """
+    pipelines = mr_pipelines(mr_iid, cwd=cwd)
+    pipeline = next((p for p in pipelines if p.get("sha") == head_sha), None)
+    if pipeline is None:
+        return []
+    return _discover_from_pipeline(pipeline, cwd=cwd, fetch_logs=fetch_logs)
+
+
+def _discover_from_pipeline(
+    pipeline: dict[str, Any], *, cwd: Path, fetch_logs: bool
+) -> list[CheckResult]:
+    status = pipeline.get("status", "")
+    bucket = _bucket_for_status(status)
+    result = CheckResult(
+        name="pipeline",
+        bucket=bucket,
+        raw_conclusion=status,
+        details_url=pipeline.get("web_url", ""),
+    )
+    if fetch_logs and bucket == "failure":
+        jobs = pipeline_jobs(pipeline["id"], cwd=cwd)
+        failed_jobs = [
+            j for j in jobs if j.get("status") == "failed" and not j.get("allow_failure")
+        ][:_MAX_FAILED_JOB_LOGS]
+        excerpts = [
+            f"--- job: {j.get('name', '?')} ---\n{job_trace(j['id'], cwd=cwd)}" for j in failed_jobs
+        ]
+        result.log_excerpt = "\n\n".join(excerpts)
+    return [result]

src/activities/ci_watch/poll.py

@@ -0,0 +1,137 @@
+"""ci-watch gating state machine — dispatches to github.py / gitlab.py.
+
+One deterministic function, `check_ci`, used both from the fixer agent's
+Stop hook (`src.agents.hooks.require_ci_pass_hook`) and as the runner's own
+authoritative post-session gate. Calling it twice with the same inputs must
+always agree — that's the whole point of sharing one implementation.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import time
+from pathlib import Path
+from typing import Literal
+
+from src.activities.ci_watch import github, gitlab
+from src.activities.ci_watch.schemas import CheckResult, CiWatchResult
+from src.activities.git.pr import pr_id
+from src.activities.git.schemas import PRRef
+
+# A few short polls a few seconds apart before concluding "no CI configured"
+# — webhook delivery and runner scheduling both have real lag, so an empty
+# result immediately after push is not conclusive.
+_SETTLE_POLLS = 3
+_SETTLE_INTERVAL_SECONDS = 5.0
+
+# Bounded wait for still-running checks within a single ci-watch call. A
+# call that times out with checks still running is treated as a failure for
+# gating purposes, same as a real one — the caller just checks again later
+# rather than one call blocking indefinitely.
+_WAIT_TIMEOUT_SECONDS = 480.0
+_WAIT_POLL_INTERVAL_SECONDS = 15.0
+
+
+def _head_sha(cwd: Path) -> str:
+    return subprocess.run(
+        ["git", "rev-parse", "HEAD"], cwd=cwd, capture_output=True, text=True, check=True
+    ).stdout.strip()
+
+
+def _discover_head(pr: PRRef, head_sha: str, *, cwd: Path, fetch_logs: bool) -> list[CheckResult]:
+    if pr.platform == "github":
+        return github.discover(head_sha, cwd=cwd, fetch_logs=fetch_logs)
+    return gitlab.discover_head(pr_id(pr), head_sha, cwd=cwd, fetch_logs=fetch_logs)
+
+
+def _apply_required_weighting(pr: PRRef, checks: list[CheckResult], *, cwd: Path) -> None:
+    """GitHub only: mark non-required checks so gating can ignore their
+    failures. Best-effort — leaves every check `required=True` (the safe
+    default already set by the schema) if branch protection isn't readable.
+    """
+    if pr.platform != "github":
+        return
+    required = github.required_check_names(pr.branch, cwd=cwd)
+    if required is None:
+        return
+    for check in checks:
+        check.required = check.name in required
+
+
+def _summarize(checks: list[CheckResult], outcome: str, reason: str) -> str:
+    lines = [f"ci-watch: {outcome} — {reason}", ""]
+    for c in checks:
+        marker = "required" if c.required else "informational"
+        lines.append(f"- [{c.bucket}/{marker}] {c.name} ({c.raw_conclusion or 'n/a'})")
+        if c.log_excerpt:
+            lines.append(f"  log excerpt:\n{c.log_excerpt}")
+    return "\n".join(lines)
+
+
+def check_ci(pr: PRRef, *, cwd: Path) -> CiWatchResult:
+    """Resolve the head commit and discover every check on it, waiting for
+    completion.
+
+    This function only answers "is CI currently green" — it doesn't decide
+    whether a failure is this change's fault. Within the fixer's own Stop
+    hook that's what drives the fix-and-recheck loop (see
+    src.agents.hooks); after that hook's retry budget is spent, or from the
+    runner's own post-session call, a still-red result is informational
+    only — the PR gets labeled regardless.
+
+    Same function backs the fixer agent's Stop hook and the runner's own
+    post-session check (see module docstring).
+    """
+    head_sha = _head_sha(cwd)
+
+    checks = _discover_head(pr, head_sha, cwd=cwd, fetch_logs=False)
+    settled = 0
+    while not checks and settled < _SETTLE_POLLS:
+        time.sleep(_SETTLE_INTERVAL_SECONDS)
+        checks = _discover_head(pr, head_sha, cwd=cwd, fetch_logs=False)
+        settled += 1
+
+    if not checks:
+        return CiWatchResult(
+            outcome="finish",
+            reason="no CI configured on this commit",
+            summary_text="No CI checks found on this commit — nothing to verify against.",
+        )
+
+    deadline = time.monotonic() + _WAIT_TIMEOUT_SECONDS
+    while any(c.bucket == "running" for c in checks):
+        if time.monotonic() >= deadline:
+            break
+        time.sleep(_WAIT_POLL_INTERVAL_SECONDS)
+        checks = _discover_head(pr, head_sha, cwd=cwd, fetch_logs=False)
+
+    still_running = [c for c in checks if c.bucket == "running"]
+    any_failed = any(c.bucket == "failure" for c in checks)
+
+    # Only pay for failing-step logs and required-check weighting when
+    # there's actually something to explain — every green (or still-running)
+    # result skips both extra round trips.
+    if any_failed:
+        checks = _discover_head(pr, head_sha, cwd=cwd, fetch_logs=True)
+        _apply_required_weighting(pr, checks, cwd=cwd)
+
+    failing_required = [c for c in checks if c.bucket == "failure" and c.required]
+
+    outcome: Literal["finish", "failure"]
+    if still_running:
+        outcome = "failure"
+        reason = f"ci-watch's own wait timed out with {len(still_running)} check(s) still running"
+    elif failing_required:
+        outcome = "failure"
+        names = ", ".join(c.name for c in failing_required)
+        reason = f"{len(failing_required)} required check(s) failed: {names}"
+    else:
+        outcome = "finish"
+        reason = "all required checks passed (or nothing to verify against)"
+
+    return CiWatchResult(
+        outcome=outcome,
+        reason=reason,
+        checks=checks,
+        summary_text=_summarize(checks, outcome, reason),
+    )