mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-16 05:00:53 +08:00
Compare commits
6
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
773fa9183a | ||
|
|
1cbab7cc39 | ||
|
|
bc75b5dc43 | ||
|
|
cddcd98f3b | ||
|
|
d42988b6a8 | ||
|
|
3975e58ce0 |
+8
-2
@@ -169,9 +169,12 @@ func (c *ChatAgent) Chat(ctx context.Context, agentKey, sessionID, message strin
|
||||
if c.guard != nil {
|
||||
opts.Hooks = c.guard.Hooks()
|
||||
}
|
||||
// The session id is the provider-side identity (session header, usage metering)
|
||||
// with or without persistence; Norma only puts it on ctx when it writes a transcript.
|
||||
opts.SessionID = sessionID
|
||||
ctx = transcript.WithSessionID(ctx, opts.SessionID)
|
||||
if c.tx != nil { // persist raw human↔AI conversation; one accumulating file per thread
|
||||
opts.Transcript = c.tx
|
||||
opts.SessionID = sessionID
|
||||
}
|
||||
// experimental feature: when enabled, noa takes over context compression (archive centralized under <workDir>/noa/<SessionID>, persistent).
|
||||
enableNoa(&opts, c.noaEnabledFn, c.workDir, "chat-"+sessionID, noaWarn("chat-"+sessionID))
|
||||
@@ -180,8 +183,11 @@ func (c *ChatAgent) Chat(ctx context.Context, agentKey, sessionID, message strin
|
||||
defer s.Close()
|
||||
// reload prior conversation so the agent has context across turns (each Chat is
|
||||
// a fresh session). First turn: no file yet → Resume loads nothing and proceeds.
|
||||
// A corrupt or unreadable transcript stops the turn before any model or tool call.
|
||||
if c.tx != nil {
|
||||
_ = s.Resume(sessionID)
|
||||
if err := resumeSession(s, opts.SessionID); err != nil {
|
||||
return "", err
|
||||
}
|
||||
}
|
||||
// re-unlock skill-gated MCPs from prior Skill() calls in the reloaded history so
|
||||
// revealed tools stay callable across the fresh session.
|
||||
|
||||
+13
-7
@@ -169,14 +169,17 @@ func (m *MainAgent) Chat(ctx context.Context, taskID int64, mainSeg int, as *db.
|
||||
if hooks != nil { // typed-nil guard: only set when concrete (avoids harness panic)
|
||||
opts.Hooks = hooks
|
||||
}
|
||||
// Segment 0 keeps the legacy "exp%d-main" name so existing transcripts still
|
||||
// load; each new session (seg>=1) gets its own file for a clean context. The id
|
||||
// is the provider-side identity (session header, usage metering) with or without
|
||||
// persistence; Norma only puts it on ctx when it writes a transcript.
|
||||
opts.SessionID = fmt.Sprintf("exp%d-main", ts.ID())
|
||||
if mainSeg > 0 {
|
||||
opts.SessionID = fmt.Sprintf("exp%d-main-s%d", ts.ID(), mainSeg)
|
||||
}
|
||||
ctx = transcript.WithSessionID(ctx, opts.SessionID)
|
||||
if m.tx != nil { // persist raw human↔AI conversation; one accumulating file per segment
|
||||
opts.Transcript = m.tx
|
||||
// Segment 0 keeps the legacy "exp%d-main" name so existing transcripts still
|
||||
// load; each new session (seg>=1) gets its own file for a clean context.
|
||||
opts.SessionID = fmt.Sprintf("exp%d-main", ts.ID())
|
||||
if mainSeg > 0 {
|
||||
opts.SessionID = fmt.Sprintf("exp%d-main-s%d", ts.ID(), mainSeg)
|
||||
}
|
||||
}
|
||||
// experimental feature: when enabled, noa takes over context compression (archive centralized under <workDir>/noa/<SessionID>, persistent).
|
||||
// the session id follows the same rule as the transcript (segment-aware), keeping archive and resume aligned.
|
||||
@@ -191,8 +194,11 @@ func (m *MainAgent) Chat(ctx context.Context, taskID int64, mainSeg int, as *db.
|
||||
// reload the prior conversation from the transcript so the agent has context
|
||||
// across turns (each Chat is a fresh session; without this it can't see earlier
|
||||
// messages). First turn: no file yet → Resume loads nothing and proceeds.
|
||||
// A corrupt or unreadable transcript stops the turn before any model or tool call.
|
||||
if m.tx != nil {
|
||||
_ = s.Resume(opts.SessionID)
|
||||
if err := resumeSession(s, opts.SessionID); err != nil {
|
||||
return "", err
|
||||
}
|
||||
}
|
||||
// C2: this session is fresh each turn; re-unlock skill-gated MCPs from prior
|
||||
// Skill() calls in the reloaded history so revealed tools stay callable.
|
||||
|
||||
+4
-1
@@ -567,9 +567,12 @@ func (p *Planner) Plan(ctx context.Context, taskID int64, as *db.AssetStore, ts
|
||||
if hooks != nil { // typed-nil guard: only set when concrete (avoids harness panic)
|
||||
opts.Hooks = hooks
|
||||
}
|
||||
// The session id is the provider-side identity (session header, usage metering)
|
||||
// with or without persistence; Norma only puts it on ctx when it writes a transcript.
|
||||
opts.SessionID = fmt.Sprintf("exp%d-planner", ts.ID())
|
||||
ctx = transcript.WithSessionID(ctx, opts.SessionID)
|
||||
if p.tx != nil { // persist raw LLM conversation; one accumulating file per task's planner
|
||||
opts.Transcript = p.tx
|
||||
opts.SessionID = fmt.Sprintf("exp%d-planner", ts.ID())
|
||||
}
|
||||
// Experimental: when on, noa takes over context compression (archives persist under <workDir>/noa/<SessionID>).
|
||||
noaSession := fmt.Sprintf("exp%d-planner", ts.ID())
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
package agent
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/Autumn-27/norma/agentcore"
|
||||
)
|
||||
|
||||
// resumeSession reloads the persisted conversation of session id into s. Norma's
|
||||
// transcript.Store.Load treats a missing file as a fresh session (no records, no
|
||||
// error); any other failure, such as a corrupt line or an unreadable path, is
|
||||
// returned so the caller stops before the first model or tool call instead of
|
||||
// appending a new conversation to the damaged file.
|
||||
func resumeSession(s *agentcore.Session, id string) error {
|
||||
if err := s.Resume(id); err != nil {
|
||||
return fmt.Errorf("restore Norma session %q: %w", id, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,305 @@
|
||||
package agent
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"iter"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
|
||||
"github.com/Autumn-27/artex/db"
|
||||
"github.com/Autumn-27/norma/llm"
|
||||
"github.com/Autumn-27/norma/transcript"
|
||||
)
|
||||
|
||||
// sessionProbe is a provider that answers every call with one text turn and
|
||||
// records the session id it saw on ctx plus the request messages.
|
||||
type sessionProbe struct {
|
||||
mu sync.Mutex
|
||||
ids []string
|
||||
msgs [][]llm.Message
|
||||
}
|
||||
|
||||
func (p *sessionProbe) Stream(ctx context.Context, req llm.CompletionRequest) iter.Seq2[llm.StreamEvent, error] {
|
||||
p.mu.Lock()
|
||||
p.ids = append(p.ids, transcript.SessionIDFrom(ctx))
|
||||
p.msgs = append(p.msgs, req.Messages)
|
||||
p.mu.Unlock()
|
||||
return func(yield func(llm.StreamEvent, error) bool) {
|
||||
if yield(llm.StreamEvent{Type: llm.SETextDelta, Text: "done"}, nil) {
|
||||
yield(llm.StreamEvent{Type: llm.SEMessageDelta, StopReason: "end_turn"}, nil)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (p *sessionProbe) Complete(ctx context.Context, req llm.CompletionRequest) (llm.Message, string, llm.Usage, error) {
|
||||
acc := llm.NewAccumulator()
|
||||
for ev, err := range p.Stream(ctx, req) {
|
||||
if err != nil {
|
||||
return llm.Message{}, "", llm.Usage{}, err
|
||||
}
|
||||
acc.Add(ev)
|
||||
}
|
||||
return acc.Message(), acc.StopReason, acc.Usage, nil
|
||||
}
|
||||
|
||||
func (p *sessionProbe) seen() []string {
|
||||
p.mu.Lock()
|
||||
defer p.mu.Unlock()
|
||||
return append([]string(nil), p.ids...)
|
||||
}
|
||||
|
||||
// jsonlFiles lists every .jsonl file under dir.
|
||||
func jsonlFiles(t *testing.T, dir string) []string {
|
||||
t.Helper()
|
||||
var out []string
|
||||
err := filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !d.IsDir() && strings.HasSuffix(path, ".jsonl") {
|
||||
out = append(out, path)
|
||||
}
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// damageTranscript makes the main transcript of id corrupt (a non-JSON line) or
|
||||
// unreadable (a directory). It returns the bytes a corrupt file must keep.
|
||||
func damageTranscript(t *testing.T, store *transcript.Store, id string, unreadable bool) string {
|
||||
t.Helper()
|
||||
path := store.MainPath(id)
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if unreadable {
|
||||
if err := os.Mkdir(path, 0o700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return ""
|
||||
}
|
||||
const original = "{corrupt transcript\n"
|
||||
if err := os.WriteFile(path, []byte(original), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return original
|
||||
}
|
||||
|
||||
// assertTranscriptUntouched checks that a damaged transcript was neither
|
||||
// rewritten nor appended to.
|
||||
func assertTranscriptUntouched(t *testing.T, store *transcript.Store, id, original string, unreadable bool) {
|
||||
t.Helper()
|
||||
path := store.MainPath(id)
|
||||
if unreadable {
|
||||
entries, err := os.ReadDir(path)
|
||||
if err != nil || len(entries) != 0 {
|
||||
t.Fatalf("unreadable transcript changed: entries=%v err=%v", entries, err)
|
||||
}
|
||||
return
|
||||
}
|
||||
b, err := os.ReadFile(path)
|
||||
if err != nil || string(b) != original {
|
||||
t.Fatalf("damaged transcript changed: %q err=%v", b, err)
|
||||
}
|
||||
}
|
||||
|
||||
func assertRestoreError(t *testing.T, err error, calls int) {
|
||||
t.Helper()
|
||||
if err == nil || !strings.Contains(err.Error(), "restore Norma session") || calls != 0 {
|
||||
t.Fatalf("err=%v provider calls=%d", err, calls)
|
||||
}
|
||||
}
|
||||
|
||||
var damageCases = []struct {
|
||||
name string
|
||||
unreadable bool
|
||||
}{{"corrupt", false}, {"unreadable-directory", true}}
|
||||
|
||||
func TestChatSessionIdentityWithoutTranscript(t *testing.T) {
|
||||
p := &sessionProbe{}
|
||||
workDir := t.TempDir()
|
||||
c := NewChatAgent(p, "test-model", workDir, nil, 100000)
|
||||
for range 2 {
|
||||
if _, err := c.Chat(t.Context(), "assistant", "conv-stable", "hello", 1, 0, false, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if ids := p.seen(); len(ids) != 2 || ids[0] != "conv-stable" || ids[1] != "conv-stable" {
|
||||
t.Fatalf("provider session ids: %v", ids)
|
||||
}
|
||||
if files := jsonlFiles(t, workDir); len(files) != 0 {
|
||||
t.Fatalf("transcript written without persistence: %v", files)
|
||||
}
|
||||
}
|
||||
|
||||
func TestChatMissingTranscriptStartsFresh(t *testing.T) {
|
||||
store := transcript.NewStore(t.TempDir())
|
||||
p := &sessionProbe{}
|
||||
c := NewChatAgent(p, "test-model", t.TempDir(), store, 100000)
|
||||
if _, err := c.Chat(t.Context(), "assistant", "conv-new", "hello", 1, 0, false, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if ids := p.seen(); len(ids) != 1 || ids[0] != "conv-new" {
|
||||
t.Fatalf("provider session ids: %v", ids)
|
||||
}
|
||||
recs, err := store.Load(store.MainPath("conv-new"))
|
||||
if err != nil || len(recs) == 0 {
|
||||
t.Fatalf("fresh transcript not written: %d records, err=%v", len(recs), err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestChatRefusesDamagedTranscript(t *testing.T) {
|
||||
for _, tc := range damageCases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
store := transcript.NewStore(t.TempDir())
|
||||
original := damageTranscript(t, store, "conv-broken", tc.unreadable)
|
||||
p := &sessionProbe{}
|
||||
c := NewChatAgent(p, "test-model", t.TempDir(), store, 100000)
|
||||
_, err := c.Chat(t.Context(), "assistant", "conv-broken", "hello", 1, 0, false, nil)
|
||||
assertRestoreError(t, err, len(p.seen()))
|
||||
assertTranscriptUntouched(t, store, "conv-broken", original, tc.unreadable)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestChatResumesSignedThinkingHistory(t *testing.T) {
|
||||
store := transcript.NewStore(t.TempDir())
|
||||
w := store.NewWriter("conv-signed", "")
|
||||
w.RecordMessage(llm.UserText("earlier question"), llm.Usage{})
|
||||
w.RecordMessage(llm.Message{Role: llm.RoleAssistant, Content: []llm.ContentBlock{
|
||||
{Type: llm.BlockThinking, Thinking: "reasoning", Signature: "signed"},
|
||||
{Type: llm.BlockRedactedThinking, Data: "opaque"},
|
||||
{Type: llm.BlockText, Text: "earlier answer"},
|
||||
}}, llm.Usage{})
|
||||
if err := w.Err(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
p := &sessionProbe{}
|
||||
c := NewChatAgent(p, "test-model", t.TempDir(), store, 100000)
|
||||
if _, err := c.Chat(t.Context(), "assistant", "conv-signed", "next question", 1, 0, false, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
p.mu.Lock()
|
||||
defer p.mu.Unlock()
|
||||
if len(p.msgs) != 1 {
|
||||
t.Fatalf("provider calls: %d", len(p.msgs))
|
||||
}
|
||||
var thinking, redacted bool
|
||||
for _, m := range p.msgs[0] {
|
||||
for _, b := range m.Content {
|
||||
thinking = thinking || (b.Type == llm.BlockThinking && b.Thinking == "reasoning" && b.Signature == "signed")
|
||||
redacted = redacted || (b.Type == llm.BlockRedactedThinking && b.Data == "opaque")
|
||||
}
|
||||
}
|
||||
if !thinking || !redacted {
|
||||
t.Fatalf("resumed history lost signed thinking=%v redacted=%v: %+v", thinking, redacted, p.msgs[0])
|
||||
}
|
||||
}
|
||||
|
||||
// sessionFixture is one exploration with one intent on the test database.
|
||||
type sessionFixture struct {
|
||||
expID int64
|
||||
intentID int64
|
||||
ts *db.ExplorationStore
|
||||
intent *db.Node
|
||||
}
|
||||
|
||||
func newSessionFixture(t *testing.T) sessionFixture {
|
||||
t.Helper()
|
||||
d := testDB(t)
|
||||
t.Cleanup(func() { _ = d.Close() })
|
||||
expID, err := d.CreateExploration("session identity probe", "keep the session id stable")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _, _ = d.Exec(`DELETE FROM explorations WHERE id=$1`, expID) })
|
||||
ts := d.Exploration(expID)
|
||||
payload := map[string]any{"summary": "session probe"}
|
||||
intentID, err := ts.AddNode("intent", payload, 0, "running", "planner", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
raw, _ := json.Marshal(payload)
|
||||
return sessionFixture{expID: expID, intentID: intentID, ts: ts, intent: &db.Node{ID: intentID, Payload: raw}}
|
||||
}
|
||||
|
||||
// run drives one agent kind once and returns the session id it should use.
|
||||
func (f sessionFixture) run(t *testing.T, kind string, p *sessionProbe, tx *transcript.Store) (string, error) {
|
||||
t.Helper()
|
||||
workDir := t.TempDir()
|
||||
switch kind {
|
||||
case "worker":
|
||||
_, _, err := NewWorker(p, "test-model", workDir, tx, 0, 3).Execute(t.Context(), "work#1", f.expID, nil, f.ts, f.intent, passHooks{}, nil, nil, nil)
|
||||
return WorkerSessionID(f.expID, f.intentID), err
|
||||
case "planner":
|
||||
_, _, err := NewPlanner(p, "test-model", workDir, tx, 0, 3).Plan(t.Context(), f.expID, nil, f.ts, "probe goal", nil, passHooks{}, nil)
|
||||
return fmt.Sprintf("exp%d-planner", f.expID), err
|
||||
case "mainagent":
|
||||
_, err := NewMainAgent(p, "test-model", workDir, tx, 0, 3).Chat(t.Context(), f.expID, 0, nil, f.ts, "probe goal", "status?", passHooks{}, nil, nil, nil, nil, nil)
|
||||
return fmt.Sprintf("exp%d-main", f.expID), err
|
||||
case "mainagent-seg":
|
||||
_, err := NewMainAgent(p, "test-model", workDir, tx, 0, 3).Chat(t.Context(), f.expID, 2, nil, f.ts, "probe goal", "status?", passHooks{}, nil, nil, nil, nil, nil)
|
||||
return fmt.Sprintf("exp%d-main-s2", f.expID), err
|
||||
}
|
||||
t.Fatalf("unknown agent kind %q", kind)
|
||||
return "", nil
|
||||
}
|
||||
|
||||
func TestAgentSessionIdentityWithAndWithoutTranscript(t *testing.T) {
|
||||
f := newSessionFixture(t)
|
||||
for _, kind := range []string{"worker", "planner", "mainagent", "mainagent-seg"} {
|
||||
t.Run(kind, func(t *testing.T) {
|
||||
bare := &sessionProbe{}
|
||||
want, err := f.run(t, kind, bare, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
store := transcript.NewStore(t.TempDir())
|
||||
persisted := &sessionProbe{}
|
||||
if _, err := f.run(t, kind, persisted, store); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, ids := range [][]string{bare.seen(), persisted.seen()} {
|
||||
if len(ids) == 0 {
|
||||
t.Fatal("provider never called")
|
||||
}
|
||||
for _, id := range ids {
|
||||
if id != want {
|
||||
t.Fatalf("provider session ids %v, want %q", ids, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
if recs, err := store.Load(store.MainPath(want)); err != nil || len(recs) == 0 {
|
||||
t.Fatalf("transcript %q not written under the session id: %d records, err=%v", want, len(recs), err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAgentRefusesDamagedTranscript(t *testing.T) {
|
||||
f := newSessionFixture(t)
|
||||
for _, kind := range []string{"worker", "mainagent"} {
|
||||
for _, tc := range damageCases {
|
||||
t.Run(kind+"/"+tc.name, func(t *testing.T) {
|
||||
store := transcript.NewStore(t.TempDir())
|
||||
id := WorkerSessionID(f.expID, f.intentID)
|
||||
if kind == "mainagent" {
|
||||
id = fmt.Sprintf("exp%d-main", f.expID)
|
||||
}
|
||||
original := damageTranscript(t, store, id, tc.unreadable)
|
||||
p := &sessionProbe{}
|
||||
_, err := f.run(t, kind, p, store)
|
||||
assertRestoreError(t, err, len(p.seen()))
|
||||
assertTranscriptUntouched(t, store, id, original, tc.unreadable)
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
+10
-2
@@ -540,9 +540,12 @@ func (w *Worker) execute(ctx context.Context, name string, taskID int64, as *db.
|
||||
if hooks != nil { // typed-nil guard: only set when concrete (avoids harness panic)
|
||||
opts.Hooks = hooks
|
||||
}
|
||||
// The session id is the provider-side identity (session header, usage metering)
|
||||
// with or without persistence; Norma only puts it on ctx when it writes a transcript.
|
||||
opts.SessionID = WorkerSessionID(ts.ID(), intent.ID)
|
||||
ctx = transcript.WithSessionID(ctx, opts.SessionID)
|
||||
if w.tx != nil { // persist raw LLM conversation; one file per worked intent
|
||||
opts.Transcript = w.tx
|
||||
opts.SessionID = WorkerSessionID(ts.ID(), intent.ID)
|
||||
}
|
||||
intentID := intent.ID
|
||||
emitWrap := func(r db.Activity) {
|
||||
@@ -574,7 +577,12 @@ func (w *Worker) execute(ctx context.Context, name string, taskID int64, as *db.
|
||||
// restarting from scratch.
|
||||
alreadyRecorded := false
|
||||
if w.tx != nil {
|
||||
_ = s.Resume(opts.SessionID)
|
||||
// A corrupt or unreadable transcript stops the run before any model or tool
|
||||
// call. No terminal reason: the engine marks the intent blocked without the
|
||||
// model_error reruns, which would only fail the same way again.
|
||||
if err := resumeSession(s, opts.SessionID); err != nil {
|
||||
return "", tsx.Writes(), err
|
||||
}
|
||||
alreadyRecorded = requestID != "" && hasWorkerChatMessage(s.Messages(), requestID)
|
||||
if len(s.Messages()) > 0 && message == "" {
|
||||
seedUnlockFromHistory(s.Messages(), def.UnlockSkill)
|
||||
|
||||
Generated
+588
-234
File diff suppressed because it is too large
Load Diff
+2
-3
@@ -21,7 +21,6 @@
|
||||
},
|
||||
"dependencies": {
|
||||
"@antv/g6": "^5.1.1",
|
||||
"@antv/graphin": "^3.0.5",
|
||||
"@base-ui/react": "^1.6.0",
|
||||
"@dnd-kit/core": "^6.3.1",
|
||||
"@dnd-kit/modifiers": "^9.0.0",
|
||||
@@ -40,7 +39,7 @@
|
||||
"geist": "^1.7.2",
|
||||
"input-otp": "^1.4.2",
|
||||
"lucide-react": "^1.22.0",
|
||||
"next": "^16.2.9",
|
||||
"next": "^16.4.6",
|
||||
"next-themes": "^0.4.6",
|
||||
"radix-ui": "^1.6.0",
|
||||
"react": "^19.2.7",
|
||||
@@ -52,7 +51,6 @@
|
||||
"react-resizable-panels": "^4.12.0",
|
||||
"recharts": "^3.8.0",
|
||||
"remark-gfm": "^4.0.1",
|
||||
"shadcn": "^4.12.0",
|
||||
"simple-icons": "^16.24.1",
|
||||
"sonner": "^2.0.7",
|
||||
"tailwind-merge": "^3.6.0",
|
||||
@@ -74,6 +72,7 @@
|
||||
"husky": "^9.1.7",
|
||||
"lint-staged": "^16.4.0",
|
||||
"postcss": "^8.5.16",
|
||||
"shadcn": "^4.12.0",
|
||||
"tailwindcss": "^4.1.5",
|
||||
"ts-node": "^10.9.2",
|
||||
"tw-animate-css": "^1.4.0",
|
||||
|
||||
Reference in New Issue
Block a user