34 Commits

Author SHA1 Message Date
9ee51f797e fix(gitgram): close block-bypass via group chat creation
Some checks failed
CI / Test: Gitgram Web (push) Has been cancelled
CI / Test: AITM API Server (push) Has been cancelled
CI / Typecheck: Backend + Web (push) Has been cancelled
CI / Lint: Backend + Web (push) Has been cancelled
Integration Tests / Gitgram: API Integration Tests (push) Has been cancelled
Integration Tests / AITM: API Integration Tests (push) Has been cancelled
Integration Tests / AITM: Core E2E Tests (push) Has been cancelled
Integration Tests / Integration Test Gate (push) Has been cancelled
License Check / Block GPL / noncommercial imports in product trees (push) Has been cancelled
Test Gate / Gitgram: Backend Tests (Jest) (push) Has been cancelled
Test Gate / AITM: Core Tests (Vitest) (push) Has been cancelled
Test Gate / AITM: API Server Tests (Vitest) (push) Has been cancelled
Test Gate / Test Gate (all products) (push) Has been cancelled
CI / Test: Gitgram Backend (push) Has been cancelled
Gitgram Tests / Test: Gitgram Backend (Jest) (push) Failing after 1m5s
Gitgram Tests / E2E: Gitgram Backend (Jest + supertest) (push) Failing after 32s
Gitgram Tests / Typecheck: Gitgram Web (push) Failing after 41s
Gitgram Tests / E2E Smoke: Gitgram Web (Playwright) (push) Failing after 41s
sendMessage only checked hasBlockRelationship on the receiverId (DM)
branch; the chatId (group chat) branch skipped it entirely. A user
blocked by someone could route around the block by creating a
"group chat" whose only other member is the blocker and sending
through that chatId instead of receiverId.

createGroupChat now rejects chat creation if the creator has a block
relationship (either direction) with any proposed member.

Repro'd live against a disposable local Postgres+Redis: B blocks A,
A's direct message to B correctly 403s, but A's POST
/messages/chats + /messages{chatId} both succeeded (201) before this
fix. After the fix, chat creation 403s with "Cannot create a chat
with a blocked user"; unblocked group chat creation still works
(201). tsc --noEmit clean; full jest suite unchanged at the two
pre-existing failing files (messages.test.ts, messageService.test.ts,
identical 17/15 split confirmed via git stash against plain main).
2026-11-02 23:06:24 +03:00
1dbb156695 fix(backend): make npm run dev actually boot (ts-node/express-rate-limit type collision)
`npm run dev` (nodemon --exec ts-node) crashed on startup with 8 TS2769
errors ("RateLimitRequestHandler not assignable to Application") every
time -- the documented quick-start path in README.md never actually
worked.

Root cause: this is an npm workspaces monorepo. express-rate-limit is
only hoisted to the monorepo root node_modules, not nested under
gitgram/backend/node_modules. Its own .d.ts resolves `express` by
walking up node_modules from wherever the package physically lives, so
it lands on the root's hoisted express@4 (and @types/express-serve-
static-core@4.19.8) instead of this package's own pinned express@5.1.0
/ @types/express@5.0.5 -- producing a real-looking but spurious cross-
package type mismatch on every `app.use(limiter)` call.

`npx tsc` / `tsc --noEmit` (the actual build and CI gate) do not hit
this at all and stay green -- confirmed before and after this change.
Set `transpileOnly: true` for the dev-loop ts-node process (the
standard fix for this exact class of ts-node + monorepo hoisting
false positive), so `npm run dev` boots instead of crashing on typings
that aren't a real bug in this project's own code.

Verified for real, not just via tsc:
- Spun up throwaway local postgres+redis containers, ran
  `prisma migrate deploy` (4/4 migrations clean), booted the backend
  with `npm run dev`'s actual command -- it now boots and serves
  /health with a live DB connection; it previously hard-crashed before
  a single request.
- Re-ran the full messaging + cross-tenant IDOR flow live end-to-end:
  registered 3 real users, created a real group chat (A+B), both
  members send/read successfully (201/200), and a non-member (C)
  gets a real 403 on both GET /messages/chats/:chatId and
  POST /messages with that chatId -- the IDOR fix from 487e4312 still
  holds.
- Re-ran tests/messages.test.ts with and without this change (via git
  stash): identical 17 failed / 15 passed both times, proving this is
  the same pre-existing mocked-Prisma flakiness already documented in
  plans/back-catalog.md, not a regression from this fix.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-10-28 00:58:16 +03:00
0fc4f141c9 feat(talent-graphrag): wire a real LLM client (Relay-first, OpenRouter fallback)
explainTalentMatch's /explain endpoints 503'd because defaultRagAsk had no
real LLM client behind it. talentGraphLlmClient.ts tries Railyard Relay
(OpenAI-compatible, same tensorzero::model_name::anthropic:: pattern
bidstage-tenders already uses) first, falling back to a direct OpenRouter
call on any Relay failure or when Relay isn't configured.

Verified against real endpoints, not mocks: a real call through Relay
(claude-haiku-4-5-20251001) returned a grounded answer citing all 3 real
subgraph edges with zero hallucinated citations; a deliberately broken
Relay key correctly triggered the OpenRouter fallback path (confirmed via
a real 401 -> real fallback attempt -> real OpenRouter 402, no credits).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-10-27 19:04:59 +03:00
87f50d813e Merge remote-tracking branch 'origin/graph/gitgram-serving' into merge/graphrag-serving-2026-10-27 2026-10-27 18:54:33 +03:00
487e43129f fix(gitgram): fix broken messaging (Account/User id mismatch) + chat IDOR + SEO gap
Audited gitgram-ai end to end by actually running the backend against a
live Postgres instance (not just reading/trusting the existing Jest
suite, which mocks Prisma and therefore never hits real FK constraints
or real route wiring).

Critical, feature-breaking bug: Message.senderId/receiverId and
MessageReaction.userId are foreign keys into Account, but every
messaging controller function wrote/read req.userId (a User id) into
those columns directly. Verified live: every message send (1:1 DM and
group chat) failed with a Prisma foreign-key-constraint violation, and
group messages additionally violated the (until now) required
non-null receiverId column since group messages have no single
receiver. Messaging has never worked through this code path. Fixed by
resolving the caller's Account id once per request (matching the
`prisma.account.findFirst({ where: { userId } })` pattern already used
elsewhere in the codebase, e.g. followRequestController) and using it
consistently for every Message/MessageReaction read, write, and
ownership check, while keeping ChatMember/UserBlock/socket rooms on the
real User id they were already consistent with. Added a Prisma
migration making Message.receiverId nullable for group-only messages.
Verified against a live Postgres test database: registered 3 users,
created a group chat, sent and read 1:1 and group messages, reacted,
and marked conversations read -- all succeed now.

Cross-tenant IDOR (same bug class found on Scribase today): GET
/api/v1/messages/chats/:chatId had no membership check at all -- any
authenticated user could read any group chat's messages by chatId
alone (every sibling function in the same file -- getMessage,
reportMessage, assertMessageAccess -- already enforced membership, this
one endpoint was the outlier). Also hardened sendMessage so posting
into a chatId you don't belong to is rejected. Verified live: a
non-member now gets 403 on both reads and writes to a chat they're not
in; an actual member still gets 200.

Unrelated build blocker found while standing up the backend to test
this: gitgram/backend/tsconfig.json set `ignoreDeprecations: "6.0"`,
which the pinned typescript@^5.9.3 doesn't recognize -- `tsc`/`ts-node`
hard-error with TS5103 before compiling a single file. Backend could
not build or boot in dev mode at all. Fixed to "5.0".

SEO gap: gitgram/web (Next.js 14 app dir) had no robots.txt and no
sitemap anywhere, static or dynamic -- zero crawl directives, no
sitemap reference for search engines. Added app/robots.ts (disallows
authenticated-only surfaces, allows public ones) and app/sitemap.ts
(static public marketing/discovery routes).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-10-24 22:20:32 +03:00
8a9dd77a78 fix(auth): make account deletion actually work for all users
DELETE /auth/delete-account threw "User not found" for every OAuth-only
account (any user with no password always failed `!user.password`), and
both the web and mobile clients called /v1/compliance/account and
/compliance/account, routes that never existed - so account deletion
was broken for 100% of users on every surface, not just OAuth.

Password accounts still require re-entering their password; OAuth-only
accounts delete using the authenticated session as proof instead. Web
and mobile now check whether the account has a password before showing
the field, and call the real /auth/delete-account route. Backend keeps
a DELETE /auth/account alias for any already-shipped client builds.

70/70 backend auth tests pass, including 3 new cases for the
OAuth-without-password path and the password-missing/wrong-password
cases.
2026-10-24 04:58:48 +03:00
125baca2db fix(backend): wire mobile settings screen to notification preferences API
The mobile app's settingsService.getNotificationPreferences/
updateNotificationPreferences call GET/PUT /api/v1/settings/notifications,
but the backend never registered any /settings/* routes — only
/api/v1/notifications/preferences existed. Every load silently 404'd
(swallowed by a catch that just logs) and every Save showed a "Failed
to save settings" alert; no notification preference was ever read back
or persisted for any user.

Mount the existing, already-working notificationPreferencesRoutes router
at /api/v1/settings/notifications as well, so the mobile client actually
reaches the real controller/Prisma logic instead of hitting a dead path.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-10-18 00:36:20 +03:00
f30a83a7c1 fix(backend): support docker-compose fallback in e2e runner
run-e2e.sh hardcoded the Compose v2 plugin (`docker compose`), which is not
installed on every machine/CI image (some ship only the standalone
`docker-compose` binary). Detect whichever is available so the docker-backed
e2e core-loop suite (real Postgres + Redis) is runnable everywhere.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-09-06 12:17:09 +03:00
beefc08485 chore(backend): keep tsc typecheck green under node10 deprecation
TypeScript 6.x makes moduleResolution=node10 (the legacy "node" resolver) a
hard error (TS5107), so `tsc --noEmit` exited 2 and the backend typecheck gate
was red. Add "ignoreDeprecations": "6.0" as TS itself prescribes; node10/
CommonJS resolution semantics are retained intentionally until a deliberate
resolver bump. Typecheck now exits 0.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-09-06 12:13:41 +03:00
bab51cd428 test(backend): exclude e2e suite from default jest run
The default jest.config.js matched tests/e2e/*.e2e.test.ts, which are meant to
run only under jest.e2e.config.js against a real Postgres + Redis (npm run
test:e2e). Running them under the default (mocked) config made the parallel
suite non-deterministic: posts.e2e and snippets.e2e collided on shared DB state
and intermittently failed, while passing in isolation/serial.

Add testPathIgnorePatterns for tests/e2e so the default unit/integration run is
deterministic and needs no Docker datastores. The e2e suite still runs via its
own config. Default suite now green in parallel (57 suites / 1434 tests).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-09-06 12:13:32 +03:00
7589058b91 docs(talent): correct placement-path comments from Polar to Creem
The recruiter placement/unlock path charges and settles through Creem
(creemService + signed creemWebhooks checkout.completed), but the
talentBillingService header, its settlement section comment, and the
controller's requestUnlock JSDoc still described a Polar adapter / Polar
order webhook. Correct those comments so the money path reads
unambiguously as Creem.

Verified before changing: @polar-sh/sdk and POLAR_WEBHOOK_SECRET remain in
active use by subscriptionService, storeController, and polarWebhooks for
subscriptions and the creator store, so they are intentionally left in place.
Comment-only change; no behavior change.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-09-06 10:36:04 +03:00
2431ac08f9 feat(talent): backfill real contribution evidence via GraphQL at sync time
The talent graph's `github_activity` evidence was written only by the GitHub
App webhook, so a new user's contribution-trajectory evidence stayed empty
until an owner configured a webhook and it fired — an ops dependency, not real
first-run data. Backfill it from the GitHub GraphQL contributionsCollection.

- githubContributionsService: pure `mapContributionsToActivities` turns real
  commit/PR/review/issue contributions into RepositoryActivity rows, scoped to
  the user's managed repositories (RepositoryManager), attributed to their
  GitHub identity (actorLogin), deduped by a deterministic eventId that mirrors
  the webhook delivery-id discipline. `harvestContributionEvidence` fetches via
  octokit.graphql (no new dependency) and deduped-inserts with skipDuplicates.
  Injectable db + graphql client so it is unit tested without Postgres/GitHub.
- githubController.syncProjects: run the backfill after project sync, non-fatal
  (a harvest failure never breaks the primary sync), and report the counts.

This makes contribution evidence real and immediate after login with no
GitHub-App-webhook ops dependency and no fabricated seed data.

Tests: mapping (all 4 contribution types), managed-repo scoping, identity
attribution, deterministic-id dedupe, malformed/empty input, and the harvester
no-op / happy-path / graphql-failure paths. 20 new assertions across 10 tests.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-09-06 10:35:09 +03:00
757cd50d12 feat(talent): wire recruiter candidate-unlock UI to Creem revenue path
The recruiter placement/unlock backend was end-to-end (routes,
talentBillingService, Creem checkout + signed webhook settlement) but had
no frontend, so recruiters literally could not pay. This closes the only
fully dead-ended money surface.

Web (gitgram/web):
- talentGraphService: add listUnlocks, requestUnlock (idempotent, optional
  placement success-fee), and getCandidateContact mapping the existing
  owner-gated backend routes, with typed placement/contact envelopes.
- utils/talentUnlock: pure gating helpers (deriveUnlockState, findPlacement,
  interpretUnlockResult, formatFee) so the owner-only logic is unit tested
  without rendering.
- talent-network page: owner-only "Unlock candidate" action on each match
  card — opens the Creem checkout, reveals contact + full evidence once the
  entitlement is paid (poll via "check payment" and on-return via query
  params), with not-owner / pending / unlocked / already-unlocked states.

Backend (gitgram/backend):
- talentBillingController: point the checkout successUrl at the real
  /talent-network page (with opportunity + unlocked params) instead of a
  non-existent /talent/opportunities route, so payment return is not a 404.

Tests: unit-test the three service methods (idempotency header, success-fee
body, already-unlocked, 402-when-unpaid, id encoding) and the gating helper
(not-owner/unlockable/pending/unlocked, checkout-vs-reveal). 21 new tests.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-09-06 10:30:06 +03:00
72c0f8c12c feat(talent): wire recruiter placement/unlock revenue via Creem
The talent graph's recruiter monetization was designed (Opportunity → Pilot →
Proof funnel) but never wired to charge. This adds the placement/candidate-unlock
revenue engine on top of the existing talent graph, charged through Creem (a
merchant-of-record with Turkey-based-seller payout support — the portfolio
standard used by bidstage/CalDesk), not Polar/Stripe.

Revenue gate: a recruiter (opportunity owner) unlocks a matched candidate's
contact + full evidence. Gating mirrors the referral gate (owner-only, no
self-unlock, candidate must have real matching evidence). The fee is charged via
a Creem checkout whose custom_price is the exact computed fee, and settled by the
signed checkout.completed webhook, which records the entitlement + receipt.

- Fee math (pure, configurable): flat unlock access fee (TALENT_UNLOCK_FEE_CENTS,
  default $49) or a percentage placement success fee (rate + min/max clamps) when
  a placement amount is supplied.
- New TalentPlacement model + migration: entitlement/receipt with a compound
  unique key (opportunity, candidate, recruiter) for charge idempotency and a
  unique providerOrderId; provider defaults to creem.
- Creem adapter (createCreemCheckout) mirroring the reviewed bidstage lib/creem.ts,
  and a signed Creem webhook route (HMAC-SHA256, timing-safe) that settles
  placements. Amount is revalidated against the quoted fee before unlocking.
- Routes: POST/GET /talent-graph/opportunities/:id/unlocks and gated
  GET .../candidates/:candidateId/contact (402 until paid).
- Errors.paymentRequired (402) helper.
- Tests: fee math, gating, charge idempotency, and the signed webhook settlement
  path (75 tests). Secrets are env-only (CREEM_API_KEY, CREEM_WEBHOOK_SECRET,
  CREEM_PRODUCT_ID) — none committed.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-08-26 21:31:07 +03:00
76e7064cbe feat(graph): GraphRAG serving layer (subgraph retrieval + grounded query) 2026-08-25 19:32:13 +03:00
b46c487206 feat(graph): wire talent-graph validation gate into the service path (warn-only) 2026-08-25 18:35:08 +03:00
fd507e5efe feat(graph): typed talent-graph ontology + edge validation & extraction
Promote the talent graph's implicit structure to an explicit schema and add
the single guardrail that removes hallucinated structure: validate every
candidate edge against its edge type's domain/range and reject
type-incompatible ones.

- talentGraphOntology.ts: node types (developer, repo, org, skill,
  contribution) and edge types (contributed_to, member_of, has_skill,
  collaborated_with) with domain/range, symmetry and reflexivity rules.
  validateEdge / validateEdges vet untrusted edges, require provenance
  (source, observedAt, confidence) on every fact, dedup symmetric edges,
  and return typed rejection reasons. Pure, no I/O.
- talentGraphEdges.ts: extraction step — turns getTalentGraph's view into
  provenanced candidate edges, reusing canonicalizeSkill and the evidence
  source union aligned with TalentEvidence.kind.
- tests: 15 unit tests covering domain/range rejection, provenance
  validation, symmetric dedup, and extract-then-validate soundness.
2026-08-25 12:29:47 +03:00
d5042aae7f test: add SSRF URL normalizer coverage for talent-graph flow 2026-08-25 11:58:35 +03:00
a4e1464ce5 feat: need-coverage / gap-analysis service + endpoint 2026-08-25 03:42:36 +03:00
d9d62a7fad feat: talent-graph module (dossier + match) on hardened schema 2026-08-25 03:21:30 +03:00
9cbad2bde3 fix: harden Prisma schema foundation, resolve tsc error 2026-08-25 03:09:57 +03:00
043ea0bf9e fix(backend,docker): reconcile migration history (squash) + context7 in compose
Migration history reconciliation:
The autonomous-build migration history was corrupted — 20260109185732 dropped 13
tables still in the schema (Account, Advertisement, ScheduledPost, Chat,
Organization, Report, …) plus their enums/constraints without recreating them, so
a fresh `prisma migrate deploy` failed on the later repair/ALTER migrations
(ScheduledPost, Advertisement, AccountType, …). Squashed the 16 broken migrations
into a single clean 00000000000000_init generated from the current schema (93
tables, 19 enums, incl. MutedWord/MessageReaction/Post.contentLanguage). Verified:
fresh `migrate deploy` applies cleanly on an empty DB; the running DB was
re-baselined (resolve --applied init) and the backend boots healthy.

context7:
Switch the compose service from a broken raw node:20-alpine + read-only-volume +
npm-install setup to the package's upstream pnpm Dockerfile (build context =
context7 monorepo root), serving StreamableHTTP on container :8080 (host :3100);
point aitm-mcp's CONTEXT7_URL at :8080. Now Up/healthy.

Result: all 9 compose services healthy (gitgram backend+web, postgres, redis,
aitm-api/mcp/website, gitnexus, context7). E2e through containers still 201/200.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-29 04:21:52 +03:00
63133da446 fix(backend): correct marathon-additions migration to incremental DDL
Replace the accidental from-empty migration (which duplicated all 16 prior
migrations and would break a fresh `migrate deploy`) with a proper incremental
migration adding only the new objects: Post.contentLanguage, the MessageReaction
and MutedWord tables, their indexes, and the MessageReaction foreign keys.

Verified the DDL against the live schema. NOTE: a fresh full `migrate deploy`
still fails on a PRE-EXISTING migration-history drift —
20260514174000_repair_scheduled_posts_schema references "ScheduledPost" which no
earlier migration creates. That predates this work; the running stack baselines
the schema (applied + migrations marked resolved) to sidestep it. Reconciling the
older migration history with schema.prisma is separate follow-up.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-29 04:07:32 +03:00
2bbcceb77b fix(docker): run the full stack in compose — gitgram backend+web healthy
The whole stack now comes up healthy under one `docker compose` run (gitgram
backend+web + Postgres/Redis + aitm-api/mcp/website + gitnexus); only the
optional tools-profile context7 remains (pre-existing workspace-build issue).

gitgram/backend/Dockerfile: move to a glibc base (node:20-bookworm-slim). Alpine
musl lacks the glibc loader that @tensorflow/tfjs-node's native libtensorflow
needs (ERR_DLOPEN_FAILED), so NSFW detection now runs for real (no stubbing).
Full install WITH lifecycle scripts in the builder (downloads libtensorflow),
node_modules reused in the runtime stage so devDeps like swagger-ui-express are
present for the NODE_ENV=development compose run; openssl + ffmpeg + libgomp1
runtime libs; create writable /app/logs + /app/uploads for the non-root user.
prisma schema: binaryTargets -> debian/arm64 openssl-3 for the glibc runtime.
nsfwDetectionService: lazy-load tf + nsfwjs so a genuinely-unavailable native
lib degrades gracefully instead of crashing at import (still uses real tfjs).

gitgram/web/Dockerfile: npm ci -> npm install (workspace member's standalone
lockfile drifts after dependency additions).

Verified end-to-end through containers: register/login/post/feed 201/200,
web homepage + GitHub->Gitgram /caelum0x both 200.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-29 04:04:38 +03:00
91c8525546 fix(backend): normalize post type to PostType enum + add deploy migration
End-to-end smoke (real Postgres + Redis via docker-compose) caught a real bug
that mocked unit tests missed: createPost passed the request `type` straight to
prisma.post.create, so a client sending lowercase "text" (instead of the
uppercase PostType enum) threw PrismaClientValidationError 500. Now normalized
to the PostType enum (case-insensitive, falls back to POST).

Verified end-to-end: register→login→create post→comment→like→feed all succeed
against a live DB (3 posts / 1 comment / 1 user persisted).

Also adds prisma/migrations/20260629000000_marathon_additions (full schema incl.
MutedWord, Post.contentLanguage, MessageReaction) — resolves the deploy-time
migration that was infra-blocked from generating against the Neon pooler.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-29 01:21:35 +03:00
090086841f fix: completion verification — all 7 products build, test, and boot
Functional verify+fix across both products after the build-out/harvest marathon.
All 7 subprojects WORK (production build + tests + boot smoke).

- gitgram-backend: fix 2FA backup-code lifecycle + QR-secret privacy regression,
  messageController reaction-aggregation crash; +4 test-harness updates for new
  models. Build clean, 1356/1356 tests, /health 200
- gitgram-web: fix render-time location/router.replace crash in app/camera prerender;
  next/link test mock. Production build green (216 pages), 76/86 tests
- gitgram-mobile: add expo-haptics jest mock. tsc clean, 8/8 tests
- aitm-core: fix IPv4/IPv6 authz test + a2aVendored auth-allowlist classification.
  541/541 tests
- aitm-api: vitest timeout bump for cold-transform false timeouts. 728/728 tests, /health 200
- aitm-mcp: correct beads_mark_done test (PUT not PATCH). 176/176 tests, boots
- aitm-website: build green (93 pages)

Deploy note: backend needs a Prisma migration for MutedWord/Post.contentLanguage/
MessageReaction (schema validates; generate against a migration-capable Postgres).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-28 20:14:40 +03:00
84c98681c9 feat: round-8 external harvest (15 features; web scout exhausted)
Final harvest round — gitgram-web scout returned no remaining valuable features.

- gitgram-mobile (5): swipe-to-reply, date dividers, swipe-to-action chat UX (bluesky)
- aitm-mcp (6): transport arg aliasing for hallucinated arg names (context7), + tool envelopes
- aitm-api (3): beads search endpoint + comments/notes over the DAG (beads)
- gitgram-backend (1): re-process @mentions on comment edit (munia)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-28 19:30:15 +03:00
bfc29616b7 feat: round-7 external harvest (18 features, all products green)
- gitgram-web (4): external link-preview/unfurl cards, rich inline embed players
  (YouTube/Twitch/Spotify/Vimeo)
- gitgram-backend (1): natural-language feed filtering (preferredLangOnly) + Post.contentLanguage
- gitgram-mobile (4): notification grouping/aggregation, shared timeAgo util
- aitm-api (7): GitNexus graph-RAG query + context retrieval endpoints (flagship surface)
- aitm-mcp (2): beads_claim atomic claim-for-work tool + brief-deps projection

Note: gitgram-backend adds Post.contentLanguage — run prisma migrate at deploy.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-28 19:17:27 +03:00
50d986473e feat: round-6 external harvest (19 more features, all products green)
- gitgram-web (4): per-image alt-text accessibility, "New posts" load-latest pill
- gitgram-backend (1): per-user muted words/tags moderation (MutedWord model + matcher)
- gitgram-mobile (4): swipe-to-action list rows, soft-reset event bus (tap tab scroll-top)
- aitm-api (7): gitnexus api_impact blast-radius/risk endpoints (reuse vendored gitnexus)
- aitm-mcp (3): MCP handshake instructions, context-efficient beads output projections

Note: gitgram-backend adds MutedWord Prisma model — run prisma migrate at deploy.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-28 19:04:16 +03:00
46bf9b83bf feat: round-5 external harvest (22 features ported from external/ into 5 products)
Harvest valuable features from external/ reference repos, adapted to each
product's stack and wired in; all products typecheck clean.

- gitgram-web (5): clickable @mention/#hashtag linkify in rendered content
  (munia), + feed/notification/accessibility patterns; install @testing-library/dom
- gitgram-backend (3): feed thread dedup + muted-thread removal (bluesky),
  GitHub star/follow write-back via OAuth (gh-social)
- gitgram-mobile (4): double-tap-to-like + heart bounce (proximity), haptics layer
  (bluesky useHaptics), + gesture/feed UX
- aitm-api (4): beads ready/dependency-DAG endpoints + atomic claim (beads)
- aitm-mcp (6): beads_ready work-queue tool, context-efficient projections,
  transport arg aliasing (context7/pal-mcp/beads)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-28 18:48:46 +03:00
54ca6de161 feat: round-4 product build-out (50 more gaps closed, all 7 green ~94-100%)
Second deep audit→build→verify pass; all products typecheck clean.

- gitgram-web (100): fix feed pagination, reel drafts, 6 gaps
- gitgram-backend (99): add admin/moderator role checks to moderation routes;
  wire backend-e2e CI (Postgres+Redis services); 5 gaps
- gitgram-mobile (97): fix broken create-reel flow; 11 gaps
- aitm-core (98): dedupe vendored CLI command registrations; real vector search
  with local fallback; 7 gaps
- aitm-api (99): replace hash-based embeddings with real OpenAI/Voyage embeddings
  (+ checkpoints test_status migration 0008); 8 gaps
- aitm-mcp (99): add X-API-Key to workspace tool proxy calls; 8 gaps
- aitm-website (94): fix annual billing checkout; 5 gaps

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-28 14:44:42 +03:00
64fbe9f474 feat: round-3 deep product build-out (69 gaps closed, all 7 products green)
Deep-audit + build-out across all products to fully-usable state; all typecheck clean.

- gitgram-web (99): wire Store feature to real endpoints, close 9 gaps
- gitgram-backend (100): close 8 flow gaps, document infra-provisioning items
- gitgram-mobile (90): fix API base-URL/path mismatch (404s) + copy proximity
  components into components/proximity wired to real screens; 15 gaps, +react-native-svg
- aitm-core (95): wire natural-language CLI flow end-to-end; 11 gaps
- aitm-api (97): fix teams metadata runtime bug; copy a2a-js server/client/grpc
  into src/a2a and wire A2A route; crates.io package search; 8 gaps
- aitm-mcp (100): fix A2A client/server card mismatch; 9 gaps
- aitm-website (95): build missing docs routes; 9 gaps

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-28 13:54:57 +03:00
14b1fe6b2c feat: build out + functionally verify all 7 subprojects to working state
Autonomous multi-agent build/verify drive across gitgram + aitimemachine.
All 7 subprojects now build and run; agents fixed real defects throughout.

Backend (gitgram/backend):
- Migrate to Express 5 typing (ambient .d.ts shims for express-rate-limit,
  @apollo/server, @trpc/server that resolve Express 5 types under workspace
  hoisting); fix 2 real GraphQL typing defects; scope typeRoots to local types
- Fix startup crash (missing `buffer` pkg required by nsfwjs)
- Install ioredis + web-push; build clean, boots (HTTP 200), 1241/1266 tests

Web (gitgram/web): next build green (fix route-slug conflict, remove dead
lib/trpc.ts); document monorepo dual-React vitest harness limitation (71/86)

Mobile (gitgram/mobile): port proximity-unique features (org, starred,
reading-list, languages, snippets) onto modern expo-router + axios stack;
exclude standalone proximity/ from tsconfig + jest; typecheck clean, 8/8 tests

AITM core: fix CLI crash from duplicate command registrations (vendored merge);
secure 2 unauthenticated API routes; 520/520 tests
AITM api-server: fix ioredis construct + a2a SDK decls + test mocks; 715/715
AITM mcp: fix TS5076 syntax + slow gitnexus import; 63/63
AITM website: next build green (88 routes)

Root deps: fix broken @types/uuid stub (real v9), relax override to $@types/uuid

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-28 04:10:22 +03:00
49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-23 14:14:09 +03:00