@causyne/agent 0.0.0-stage → 1.10.0

package/native-skills/testing/test-doubles-and-mocking/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: test-doubles-and-mocking
+description: Use mocks, stubs, or fakes in tests. Use when a test needs an external dependency, when mocks make tests brittle, or when a suite mocks its own internals.
+---
+
+# Test Doubles
+
+## The kinds, and when each is right
+
+- **Stub** — returns canned answers. For queries: "this returns three users."
+- **Fake** — a working lightweight implementation. An in-memory repository. Usually the best of the four.
+- **Mock** — asserts it was called in a particular way. For commands with no observable result: "an email was sent."
+- **Spy** — records calls for later inspection.
+
+Prefer a fake. It exercises real behaviour and does not encode the caller's implementation into the test.
+
+## Workflow
+
+1. Mock only at real boundaries.
+   - Network, filesystem, clock, randomness, and third-party services. Mocking your own modules couples the test to the current internal structure — the thing you most want to be free to change.
+   - **Done when:** every double replaces something outside the unit under test.
+
+2. Never mock what you can control cheaply.
+   - A containerised database is faster to set up and catches far more than a mocked repository. Same for a local HTTP server versus a mocked client.
+   - **Done when:** slow-and-external is the only justification for each double.
+
+3. Make time and randomness injectable.
+   - Pass a clock and a source of randomness rather than calling the global. This removes the need to mock a global, which is the most fragile kind of double.
+   - **Done when:** no test needs to patch a global time or random function.
+
+4. Keep the double honest.
+   - A stub returning a shape the real dependency never returns produces a green test and a broken system. Where the language allows, type the double against the real interface, and add one contract test against the real dependency.
+   - **Done when:** at least one test exercises the real dependency for each mocked boundary.
+
+5. Assert interactions sparingly.
+   - Verify a call only when the call IS the outcome. Verifying every internal call turns the test into a transcript of the implementation.
+   - **Done when:** interaction assertions exist only for side effects with no observable result.
+
+## Verification
+
+- Each double replaces a genuine external boundary.
+- A contract test covers each mocked dependency against the real thing.
+- Refactoring internals does not require changing doubles.

package/native-skills/testing/test-strategy-and-pyramid/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: test-strategy-and-pyramid
+description: Decide what to test and at what level. Use when a suite is slow and flaky, when coverage is high but bugs still ship, or when starting testing on an untested codebase.
+---
+
+# Test Strategy
+
+## The proportions
+
+Many fast unit tests, fewer integration tests, very few end-to-end tests. Inverting this gives a suite that is slow, flaky, and gives its feedback long after the mistake was made. But note the real goal: CONFIDENCE per second of runtime. A pure unit suite that mocks every boundary can pass while the system is entirely broken.
+
+## Workflow
+
+1. Test behaviour at the boundary the user cares about.
+   - For a library, that is its public API. For a service, its HTTP surface. For a UI, what a user can see and do. Testing internals locks the implementation and makes refactoring a test rewrite.
+   - **Done when:** the tests still pass after an internal refactor.
+
+2. Put each test at the lowest level that gives real confidence.
+   - Pure logic: unit. A query, a serialiser, an auth check: integration against a real dependency. A critical user journey: end-to-end, and only a handful of them.
+   - **Done when:** every test's level is justified by what it would catch.
+
+3. Use real dependencies where they are cheap.
+   - A containerised database in an integration test catches what a mocked repository never will — wrong SQL, a missing index, a constraint violation. Mock only what is slow, external, or non-deterministic.
+   - **Done when:** database and serialisation code is tested against the real thing.
+
+4. Treat coverage as a diagnostic, not a target.
+   - Coverage finds untested code. It cannot tell whether the tests assert anything meaningful. A coverage target produces tests written to satisfy the target.
+   - **Done when:** coverage is reported and used to find gaps, not enforced as a gate on its own.
+
+5. Delete flaky tests or fix them the same day.
+   - A tolerated flaky test teaches the team to re-run rather than to read. That habit is what lets a real failure ship.
+   - **Done when:** the suite has no known intermittent failures.
+
+## Verification
+
+- The unit suite runs in seconds.
+- The full suite runs in minutes.
+- Ten consecutive runs give identical results.
+- An internal refactor requires no test changes.

package/native-skills/testing/writing-good-assertions/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: writing-good-assertions
+description: Write or improve test assertions. Use when a failure message does not say what broke, when tests assert on implementation details, or when a test passes with any input.
+---
+
+# Writing Good Assertions
+
+## What a failing test owes you
+
+The failure message alone should tell you what broke and why, without opening the test. `expected true to be false` fails that; it costs a debugging session to learn what the test was even checking.
+
+## Workflow
+
+1. Assert on the outcome, not on the steps.
+   - Assert what the function returned and what changed in the world. Asserting that an internal helper was called with particular arguments tests the implementation, and breaks on every refactor while catching no bugs.
+   - **Done when:** no assertion mentions a private function or an internal call count.
+
+2. Compare whole values, not field by field.
+   - One deep equality on the expected object gives a diff. Ten separate field assertions stop at the first and hide the rest.
+   - **Done when:** structured results are asserted as a whole.
+
+3. Make the test name the specification.
+   - `rejects a token that expired one second ago`, not `test auth 3`. The name plus the failure should be enough to act on.
+   - **Done when:** every test name is a sentence about behaviour.
+
+4. Assert the negative space too.
+   - What must NOT happen: no email sent, no second write, nothing logged at error level, no other field changed. Most regressions are unintended extra effects, and only a negative assertion catches them.
+   - **Done when:** effect-producing code has at least one assertion about what did not happen.
+
+5. Prove the test can fail.
+   - Break the implementation deliberately and confirm the test goes red. A test that passes against broken code is worse than no test, because it is believed.
+   - **Done when:** each new test has been seen to fail for the right reason.
+
+6. Avoid conditionals in tests.
+   - An `if` in a test means it asserts different things in different runs, and it can silently assert nothing. Split it into separate tests or parametrise it.
+   - **Done when:** no test branches on runtime values.
+
+## Verification
+
+- Every new test has been observed failing against a deliberate break.
+- No assertion references a private implementation detail.
+- Failure output identifies the problem without opening the test file.

package/native-skills/web/accessible-components/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: accessible-components
+description: Build or audit an interactive UI component — modal, dropdown, tabs, menu, form. Use when a component is built from divs, when it cannot be operated by keyboard, or when accessibility is being reviewed.
+---
+
+# Accessible Components
+
+## The first rule
+
+Use the native element. `<button>`, `<a href>`, `<details>`, `<dialog>`, `<input type="checkbox">`. Every one of them brings focus handling, keyboard behaviour, and screen-reader semantics that a div plus ARIA has to reimplement, usually incompletely. Reach for ARIA only when no native element exists.
+
+## Workflow
+
+1. Audit by keyboard alone.
+   - Unplug the mouse. Tab through the component. Can you reach everything, operate everything, and see where focus is?
+   - **Done when:** every interactive element is reachable and operable, and the focus ring is always visible.
+
+2. Fix semantics before appearance.
+   - A clickable div needs `role`, `tabindex`, and key handlers for Enter and Space. A button needs none of them. Convert rather than patch.
+   - **Done when:** the accessibility tree in DevTools shows the right role for every control.
+
+3. Manage focus at boundaries.
+   - Opening a modal moves focus into it and traps it there. Closing returns focus to the trigger. Without the return, keyboard users land at the top of the document.
+   - **Done when:** opening and closing leaves focus exactly where a mouse user's attention would be.
+
+4. Name everything.
+   - Every control has an accessible name: visible text, `aria-label`, or a `<label for>`. An icon-only button with no name is unusable by a screen reader.
+   - **Done when:** no control in the accessibility tree has an empty name.
+
+5. Announce what changes.
+   - Content that appears without a page change (validation errors, toasts, results counts) needs a live region, or it is silent.
+   - **Done when:** a screen reader announces the change without the user hunting for it.
+
+## Per-component keyboard contracts
+
+- **Modal:** Escape closes, focus trapped, `role="dialog"` `aria-modal="true"`, labelled by its title.
+- **Tabs:** arrow keys move between tabs, Tab moves into the panel, `aria-selected` and `aria-controls` wired.
+- **Menu:** arrows move, Escape closes and returns focus, Home and End jump to the ends.
+- **Combobox:** arrows move through options, Enter selects, Escape reverts, `aria-activedescendant` tracks.
+
+## Verification
+
+- The whole flow is completable with the keyboard only.
+- `axe` or the browser's accessibility audit reports no violations.
+- Every control has a non-empty accessible name.

package/native-skills/web/api-client-resilience/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: api-client-resilience
+description: Write client-side code that calls an API. Use when fetch calls have no error handling, no timeout, or no cancellation, or when a component fetches in an effect without cleanup.
+---
+
+# API Client Resilience
+
+## What every network call needs
+
+A timeout, a cancellation path, an error branch, and a decision about retrying. A `fetch` with none of them will eventually hang a UI on a flaky network, and that failure is invisible in testing on a fast connection.
+
+## Workflow
+
+1. Give every request a timeout.
+   - `fetch` has no default timeout — a request can hang indefinitely. Use `AbortSignal.timeout(ms)`, and combine it with a cancellation signal via `AbortSignal.any()`.
+   - **Done when:** no request can outlive a stated deadline.
+
+2. Cancel on unmount and on supersession.
+   - A request whose component has unmounted must be aborted, or it resolves into a dead component. A search-as-you-type must abort the previous request, or responses arrive out of order and the UI shows the wrong result.
+   - **Done when:** rapid input produces one final result matching the last query.
+
+3. Treat a non-2xx response as an error explicitly.
+   - `fetch` does not reject on 404 or 500. Check `response.ok` — code that omits this parses an error page as data.
+   - **Done when:** every call checks `response.ok` before parsing.
+
+4. Retry only what is safe.
+   - Idempotent requests (GET, PUT, DELETE) may retry with exponential backoff and jitter. A POST may not, unless it carries an idempotency key.
+   - Never retry a 4xx: the request was wrong and will be wrong again.
+   - **Done when:** the retry policy is stated per method, and 4xx is excluded.
+
+5. Prefer a server-cache library over hand-rolled effects.
+   - TanStack Query or SWR already implement deduplication, caching, revalidation, retry and cancellation correctly. Hand-rolling them in `useEffect` reimplements the same four bugs each time.
+   - **Done when:** either a cache library is used, or the four behaviours above are each implemented and tested.
+
+## Verification
+
+- A request against an unreachable host fails within the timeout rather than hanging.
+- Typing quickly into a search box leaves the result matching the final query.
+- A 500 response surfaces as an error state, not as parsed data.

package/native-skills/web/bundle-size-reduction/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: bundle-size-reduction
+description: Reduce JavaScript or CSS bundle size. Use when a build warns about chunk size, when a page ships more than a few hundred kilobytes of script, or when load time is dominated by download and parse.
+---
+
+# Bundle Size Reduction
+
+## Workflow
+
+1. Look at the bundle before guessing.
+   - `rollup-plugin-visualizer`, `webpack-bundle-analyzer`, or `vite build --mode production` with a visualiser. One dependency is usually most of the weight.
+   - **Done when:** you can name the three largest contributors and their sizes.
+
+2. Attack the largest one first.
+   - Common offenders and their fixes:
+     - A date library — use `Intl.DateTimeFormat` or a modular alternative.
+     - A full icon set — import individual icons, never the barrel file.
+     - `lodash` — import the single function path, or use the platform equivalent.
+     - A charting or editor library — load it dynamically at the point of use.
+   - **Done when:** the largest contributor has dropped measurably or is justified in writing.
+
+3. Split by route.
+   - Dynamic `import()` at route boundaries. The landing page should not carry the admin dashboard's code.
+   - **Done when:** navigating between routes loads separate chunks.
+
+4. Check tree-shaking is actually working.
+   - It requires ES modules, `"sideEffects": false` in the dependency's manifest, and no barrel file re-exporting everything. A single CommonJS dependency in the chain can defeat it silently.
+   - **Done when:** an unused export from a first-party module is absent from the output.
+
+5. Do not forget CSS and fonts.
+   - Unused CSS from a utility framework needs the purge step configured against every template path. Subset fonts to the characters actually used.
+   - **Done when:** the CSS bundle contains no selector the app cannot produce.
+
+## Verification
+
+- Report the before and after transferred size for the entry chunk.
+- The largest chunk is below the project's stated budget.
+- The app still works: run the test suite and load every route.

package/native-skills/web/core-web-vitals/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: core-web-vitals
+description: Improve page load or interaction performance on the web. Use when a page feels slow, when Lighthouse scores are low, or before shipping a public-facing page.
+---
+
+# Core Web Vitals
+
+## The three metrics, and what actually moves them
+
+- **LCP** (largest contentful paint) — how long until the main thing appears. Dominated by server response time and by whether the hero image or font is discoverable early.
+- **INP** (interaction to next paint) — how long the page takes to respond to input. Dominated by long tasks on the main thread.
+- **CLS** (cumulative layout shift) — how much things move. Dominated by images and ads without reserved space, and by fonts swapping.
+
+## Workflow
+
+1. Measure before changing anything.
+   - Lab first (Lighthouse, DevTools performance panel), then field data if available. Lab numbers on a fast laptop are optimistic; throttle to a mid-tier device.
+   - **Done when:** you have a baseline number for each of the three metrics.
+
+2. Fix LCP at the source.
+   - Identify the LCP element in DevTools. It is almost always an image or a heading blocked by a font.
+   - Preload it, set `fetchpriority="high"`, serve modern formats, and size it correctly. Never lazy-load the LCP image — that is the single most common self-inflicted LCP regression.
+   - **Done when:** the LCP element starts loading in the first network round trip.
+
+3. Fix CLS by reserving space.
+   - Every image and video gets explicit `width` and `height` (or `aspect-ratio`). Every font uses `font-display: optional` or `swap` with a metric-matched fallback.
+   - **Done when:** CLS is under 0.1 and the page does not visibly jump on reload.
+
+4. Fix INP by breaking up long tasks.
+   - Find tasks over 50ms in the performance panel. Split them, defer them, or move them off the main thread.
+   - Ship less JavaScript: code-split by route, drop polyfills for browsers you do not support, and audit the bundle for a single dependency dominating it.
+   - **Done when:** no task on the interaction path exceeds 50ms.
+
+5. Re-measure.
+   - **Done when:** each metric has improved against the recorded baseline, with the numbers stated.
+
+## Verification
+
+- Lighthouse on a throttled mid-tier profile shows LCP under 2.5s, INP under 200ms, CLS under 0.1.
+- The before and after numbers are reported side by side.

package/native-skills/web/css-layout-systems/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: css-layout-systems
+description: Build a page or component layout in CSS. Use when a layout uses absolute positioning or floats, when it breaks at a viewport size, or when a container will not centre.
+---
+
+# CSS Layout Systems
+
+## Choosing between the two
+
+- **Flexbox** — one dimension. A row of items, a column of stacked sections, anything where content size should drive the layout.
+- **Grid** — two dimensions, or any layout where the CONTAINER should define the structure regardless of content. Page shells, card grids, forms with aligned labels.
+
+Absolute positioning is for overlays only. Floats are for wrapping text around an image and nothing else.
+
+## Workflow
+
+1. Name the layout in one sentence before writing CSS.
+   - "A sidebar of fixed width and a main area that fills the rest" is a grid. "A row of buttons pushed to the right" is flex. The sentence picks the tool.
+   - **Done when:** the layout is described in words and the tool follows from it.
+
+2. Let the intrinsic sizing work.
+   - `minmax()`, `auto-fit`, `clamp()` and `min-content` remove most media queries. A card grid that reflows with `repeat(auto-fit, minmax(16rem, 1fr))` needs no breakpoints at all.
+   - **Done when:** the layout adapts across widths with as few explicit breakpoints as possible.
+
+3. Fix overflow at the source.
+   - A grid or flex item defaults to `min-width: auto`, which refuses to shrink below its content. That is why a long word or a wide table breaks the page. Set `min-width: 0` on the item.
+   - **Done when:** no horizontal scrollbar appears on the page body at any width.
+
+4. Use logical properties.
+   - `margin-inline`, `padding-block`, `inset-inline-start`. They work in right-to-left languages without a second stylesheet.
+   - **Done when:** the layout is correct with `dir="rtl"` set on the document.
+
+5. Contain what scrolls.
+   - Wide content — tables, code blocks, diagrams — scrolls inside its own `overflow-x: auto` container. The page body never scrolls sideways.
+   - **Done when:** every wide element scrolls within itself.
+
+## Verification
+
+- No horizontal page scroll from 320px to 2560px.
+- `dir="rtl"` produces a mirrored, correct layout.
+- Zooming text to 200% does not clip or overlap content.

package/native-skills/web/form-validation-ux/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: form-validation-ux
+description: Build or fix a form. Use when validation fires on every keystroke, when errors are not associated with fields, or when a submit can be double-fired.
+---
+
+# Form Validation UX
+
+## Timing is the whole design
+
+Validate a field when the user LEAVES it, not while they are typing. Validating on every keystroke tells someone their email is invalid after the first character, which is both true and useless. Once a field has errored, re-validate on change so the error clears as soon as it is fixed.
+
+## Workflow
+
+1. Validate on the server regardless.
+   - Client validation is a convenience. Anything that matters is enforced server-side, because the client is under the user's control.
+   - **Done when:** every rule exists on the server, whether or not it also exists on the client.
+
+2. Share one schema.
+   - Define the rules once (Zod, Valibot, a JSON schema) and use them on both sides. Two hand-written copies drift, and the drift shows up as a form that submits and then fails.
+   - **Done when:** changing a rule in one place changes both sides.
+
+3. Wire errors to fields accessibly.
+   - `aria-invalid` on the input, `aria-describedby` pointing at the message, and the message in a live region. An error rendered near the field but not associated with it is invisible to a screen reader.
+   - **Done when:** a screen reader announces the error when focus enters the field.
+
+4. Make submission safe.
+   - Disable the submit while in flight and guard on the server with an idempotency key. A double-click on a slow network creates two orders.
+   - **Done when:** double-submitting produces one result.
+
+5. Never lose what was typed.
+   - On a failed submit, keep every value and focus the first invalid field. Clearing a form on error is the fastest way to lose a user.
+   - **Done when:** a failed submit preserves all input and moves focus to the first problem.
+
+## Verification
+
+- Submitting empty shows all errors at once, with focus on the first.
+- Fixing a field clears its error immediately.
+- Double-clicking submit produces one server-side effect.
+- The whole form is completable by keyboard.

package/native-skills/web/react-state-architecture/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: react-state-architecture
+description: Choose where state lives in a React application. Use when props are threaded through many layers, when a context re-renders the whole tree, or when a global store is being added.
+---
+
+# React State Architecture
+
+## The ordering rule
+
+State belongs at the lowest level that can own it. Every level it is lifted above that is a re-render nobody asked for. Reach for the next tier only when the current one provably fails.
+
+1. Local `useState` — owned by one component.
+2. Lifted to the nearest common parent — shared by siblings.
+3. URL — anything the user should be able to link to, refresh into, or navigate back to. Filters, tabs, pagination, selected item.
+4. Server cache (TanStack Query, SWR, RSC) — anything that came from the network. This is not application state; it is a cache with staleness, and treating it as state is the single most common source of duplicate fetching and stale UI.
+5. Context — genuinely global and rarely changing: theme, locale, the authenticated user.
+6. A store (Zustand, Redux) — high-frequency global state with complex updates. Rare.
+
+## Workflow
+
+1. Classify each piece of state against the tiers above.
+   - The question that resolves most cases: does this come from the server? If yes, it belongs in the server cache, not in `useState` with a `useEffect`.
+   - **Done when:** every piece of state is assigned to a tier with a stated reason.
+
+2. Move URL-shaped state to the URL.
+   - Search params via the router. This gets back-button and shareability for free, both of which are otherwise bugs users will report.
+   - **Done when:** reloading the page restores the same view.
+
+3. Split contexts by update frequency.
+   - One context holding both the theme and a live cursor position re-renders every consumer on every mouse move. Separate them.
+   - **Done when:** no context holds values with different change rates.
+
+4. Derive instead of storing.
+   - A value computable from other state must not be stored. Two sources of truth drift, and the drift is a bug class you cannot test away.
+   - **Done when:** no `useEffect` exists whose only job is to sync one state value from another.
+
+## Verification
+
+- The React DevTools profiler shows no component re-rendering on an update it does not display.
+- Reloading any view restores it exactly.
+- Searching for `useEffect` finds none that only call `setState` from other state.

package/native-skills/web/ssr-hydration-correctness/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: ssr-hydration-correctness
+description: Debug or prevent a server-rendering hydration mismatch. Use when the console warns about hydration, when content flashes and changes on load, or when a component behaves differently on first render.
+---
+
+# SSR Hydration Correctness
+
+## What a mismatch means
+
+The server produced one tree and the client produced a different one from the same props. The framework has to discard its work and re-render, which costs the performance the server render was supposed to buy — and in the worst case leaves the DOM and the component state disagreeing.
+
+## The four causes, in order of frequency
+
+1. **Non-deterministic values.** `Date.now()`, `Math.random()`, `crypto.randomUUID()` produce different output on each side.
+2. **Browser-only APIs read during render.** `window`, `document`, `localStorage`, `matchMedia`. These are undefined on the server, so the branch differs.
+3. **Locale or timezone formatting.** The server formats in UTC and the client in the user's zone.
+4. **Invalid HTML nesting.** A `<div>` inside a `<p>`, or a `<td>` outside a row. The browser repairs the DOM, so the client tree no longer matches what was sent.
+
+## Workflow
+
+1. Read the mismatch message for the specific element.
+   - Modern frameworks name the node and show both trees. That usually identifies the cause outright.
+   - **Done when:** you can point at the exact element and value that differ.
+
+2. Move non-deterministic work out of render.
+   - Compute it on the server and pass it as a prop, or compute it in an effect after mount and accept one frame of the fallback.
+   - **Done when:** render is a pure function of props on both sides.
+
+3. Gate browser-only reads behind mount.
+   - Read the value in an effect and store it in state, rather than reading it during render. The first render then matches the server by construction.
+   - **Done when:** no browser global is read during render.
+
+4. Fix formatting by fixing the inputs.
+   - Send an ISO timestamp and an explicit timezone; format identically on both sides. Do not paper over it with a suppression attribute — that hides the mismatch without removing it.
+   - **Done when:** the same input formats to the same string on both sides.
+
+5. Validate the HTML.
+   - Run the server output through a validator. Nesting errors produce mismatches that look inexplicable at the component level.
+   - **Done when:** the server HTML validates.
+
+## Verification
+
+- No hydration warning in the console on any route.
+- No visible flash of changed content on load.
+- Disabling JavaScript still shows correct server-rendered content.

package/package.json

@@ -1,6 +1,70 @@
 {
   "name": "@causyne/agent",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.10.0",
+  "description": "Agentic AI for software, tools, and computer workflows",
+  "main": "bin/causyne.js",
+  "type": "module",
+  "bin": {
+    "causyne": "bin/causyne.js",
+    "causyne-agent": "bin/causyne.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "native-skills/",
+    "README.md",
+    "SECURITY.md",
+    "LICENSE",
+    "docs/ARCHITECTURE.md",
+    "docs/PROVENANCE.md",
+    "docs/SECURITY_REVIEW.md",
+    "docs/THIRD_PARTY_NOTICES.md"
+  ],
+  "scripts": {
+    "start": "node ./bin/causyne.js",
+    "test": "node --test --import ./tests/helpers/isolateState.js \"tests/**/*.test.js\"",
+    "build": "node scripts/compile_skills.js",
+    "check:release": "node scripts/check_release.js",
+    "check:public": "npm run check:release && node scripts/check_public_release.js",
+    "prepublishOnly": "npm run check:public && npm test && npm run typecheck:strict",
+    "typecheck": "tsc -p tsconfig.json",
+    "typecheck:strict": "tsc -p tsconfig.strict.json"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "automation",
+    "causyne",
+    "cli"
+  ],
+  "license": "BUSL-1.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ikbal-causyne/causyne-agent.git"
+  },
+  "homepage": "https://causyne.com/",
+  "bugs": {
+    "url": "https://github.com/ikbal-causyne/causyne-agent/issues"
+  },
+  "overrides": {
+    "form-data": "^4.0.0",
+    "axios": "^1.20.0"
+  },
+  "dependencies": {
+    "@babel/parser": "^8.0.4",
+    "acorn-walk": "^8.3.5",
+    "commander": "^11.1.0",
+    "duck-duck-scrape": "^2.2.7",
+    "googlethis": "^1.8.0",
+    "inquirer": "^9.2.12"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.2",
+    "acorn": "^8.18.0",
+    "typescript": "^7.0.2"
+  },
+  "private": false
+}