@depact/cli 0.0.1

package/AGENTS.md

@@ -0,0 +1,16 @@
+# depact
+
+Dependency impact analyzer for large TypeScript codebases
+
+## What this is
+
+`depact` builds the exact transitive import graph from an entry file and surfaces actionable metrics: exclusive cost per contributor, barrel amplification, shortest import chain to a target (`why`), affected test selection from changed files.
+
+## Key architecture decisions
+
+Custom import scanner and resolver written in Go for speed and parallelism.
+
+## Commands (target CLI)
+
+`analyze`, `check`, `why`, `diff`.
+All commands support `--json`, `--type`, `--follow-externals`, `--project`.

package/README.md

@@ -0,0 +1,3 @@
+# depact
+
+Dependency impact analyzer for large TypeScript codebases

package/fixtures/barrel/src/entry.ts

@@ -0,0 +1,2 @@
+import { Button } from "./ui/index.ts";
+export const page = () => Button();

package/fixtures/barrel/src/ui/Button.ts

@@ -0,0 +1,3 @@
+import { helperA } from "./helpers/a.ts";
+import { helperB } from "./helpers/b.ts";
+export const Button = () => helperA() + helperB();

package/fixtures/barrel/src/ui/Card.ts

@@ -0,0 +1,2 @@
+import { helperF } from "./helpers/f.ts";
+export const Card = () => helperF();

package/fixtures/barrel/src/ui/Input.ts

@@ -0,0 +1,2 @@
+import { helperC } from "./helpers/c.ts";
+export const Input = () => helperC();

package/fixtures/barrel/src/ui/Modal.ts

@@ -0,0 +1,2 @@
+import { helperD } from "./helpers/d.ts";
+export const Modal = () => helperD();

package/fixtures/barrel/src/ui/Tooltip.ts

@@ -0,0 +1,2 @@
+import { helperE } from "./helpers/e.ts";
+export const Tooltip = () => helperE();

package/fixtures/barrel/src/ui/helpers/a.ts

@@ -0,0 +1 @@
+export const helperA = () => 1;

package/fixtures/barrel/src/ui/helpers/b.ts

@@ -0,0 +1 @@
+export const helperB = () => 2;

package/fixtures/barrel/src/ui/helpers/c.ts

@@ -0,0 +1 @@
+export const helperC = () => 3;

package/fixtures/barrel/src/ui/helpers/d.ts

@@ -0,0 +1 @@
+export const helperD = () => 4;

package/fixtures/barrel/src/ui/helpers/e.ts

@@ -0,0 +1 @@
+export const helperE = () => 5;

package/fixtures/barrel/src/ui/helpers/f.ts

@@ -0,0 +1 @@
+export const helperF = () => 6;

package/fixtures/barrel/src/ui/index.ts

@@ -0,0 +1,5 @@
+export * from "./Button.ts";
+export * from "./Input.ts";
+export * from "./Modal.ts";
+export * from "./Tooltip.ts";
+export * from "./Card.ts";

package/fixtures/barrel/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*"]
+}

package/fixtures/externals/node_modules/acme/helper.js

@@ -0,0 +1 @@
+export const helper = () => 2;

package/fixtures/externals/node_modules/acme/index.d.ts

@@ -0,0 +1 @@
+export const acme: () => number;

package/fixtures/externals/node_modules/acme/index.js

@@ -0,0 +1,2 @@
+import { helper } from "./helper.js";
+export const acme = () => helper() + 1;

package/fixtures/externals/node_modules/acme/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "acme",
+  "version": "1.0.0",
+  "main": "./index.js",
+  "types": "./index.d.ts"
+}

package/fixtures/externals/node_modules/leftpad/index.d.ts

@@ -0,0 +1 @@
+export const leftpad: (s: string) => string;

package/fixtures/externals/node_modules/leftpad/index.js

@@ -0,0 +1 @@
+export const leftpad = (s) => " " + s;

package/fixtures/externals/node_modules/leftpad/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "leftpad",
+  "version": "1.0.0",
+  "main": "./index.js",
+  "types": "./index.d.ts"
+}

package/fixtures/externals/src/entry.ts

@@ -0,0 +1,5 @@
+import { acme } from "acme";
+import { leftpad } from "leftpad";
+import { local } from "./local.ts";
+
+export const x = () => acme() + leftpad("1") + local();

package/fixtures/externals/src/local.ts

@@ -0,0 +1,2 @@
+import { leftpad } from "leftpad";
+export const local = () => leftpad("ok");

package/fixtures/externals/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Node10",
+    "strict": true,
+    "esModuleInterop": true,
+    "allowJs": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*"]
+}

package/fixtures/linear/src/b.ts

@@ -0,0 +1,2 @@
+import { c } from "./c.ts";
+export const b = () => c() + 1;

package/fixtures/linear/src/c.ts

@@ -0,0 +1,2 @@
+import { d } from "./d.ts";
+export const c = () => d() + 1;

package/fixtures/linear/src/d.ts

@@ -0,0 +1 @@
+export const d = () => 42;

package/fixtures/linear/src/entry.ts

@@ -0,0 +1,2 @@
+import { b } from "./b.ts";
+export const entry = () => b() + 1;

package/fixtures/linear/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*"]
+}

package/fixtures/paths/src/app/page.tsx

@@ -0,0 +1,7 @@
+import { useThing } from "@lib/hook";
+import { Icon } from "@lib/icon";
+
+export function Page() {
+  const thing = useThing();
+  return <Icon label={thing} />;
+}

package/fixtures/paths/src/lib/hook.ts

@@ -0,0 +1 @@
+export const useThing = (): string => "thing";

package/fixtures/paths/src/lib/icon.tsx

@@ -0,0 +1,3 @@
+export function Icon({ label }: { label: string }) {
+  return <span>{label}</span>;
+}

package/fixtures/paths/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "preserve",
+    "strict": true,
+    "esModuleInterop": true,
+    "noEmit": true,
+    "baseUrl": ".",
+    "paths": {
+      "@lib/*": ["src/lib/*"]
+    }
+  },
+  "include": ["src/**/*"]
+}

package/go.mod

@@ -0,0 +1,3 @@
+module depact
+
+go 1.25.0

package/main.go

@@ -0,0 +1,9 @@
+package main
+
+import (
+	"depact/parser"
+)
+
+func main() {
+	_ = parser.Parse([]byte("import x from 'mod'"))
+}

package/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@depact/cli",
+  "version": "0.0.1",
+  "scripts": {}
+}

package/parser/module.go

@@ -0,0 +1,45 @@
+package parser
+
+type Symbol struct {
+	Name     string
+	TypeOnly bool
+}
+
+type EdgeType int
+
+const (
+	DefaultEdge EdgeType = iota
+	NamedEdge
+	NamespaceEdge
+	SideEffectEdge
+	DynamicEdge
+)
+
+type Import struct {
+	Kind    EdgeType
+	From    string
+	Symbols []Symbol
+}
+
+type Export struct {
+	Kind    EdgeType
+	Symbols []Symbol
+}
+
+type Module struct {
+	Path    string
+	Imports []Import
+	Exports []Export
+}
+
+func (i Import) TypeOnly() bool {
+	if len(i.Symbols) == 0 {
+		return false
+	}
+	for _, s := range i.Symbols {
+		if !s.TypeOnly {
+			return false
+		}
+	}
+	return true
+}

package/parser/parser.go

@@ -0,0 +1,7 @@
+package parser
+
+func Parse(src []byte) *Module {
+	scanner := &scanner{src: src}
+	imports, exports := scanner.scan() // TODO: handle errors
+	return &Module{Imports: imports, Exports: exports}
+}

package/parser/scanner.go

@@ -0,0 +1,215 @@
+package parser
+
+type state int
+
+const (
+	code         state = iota
+	lineComment        // //
+	blockComment       // /* */
+	stringDouble       // "..."
+	stringSingle       // '...'
+	template           // `...`
+)
+
+type scanner struct {
+	src     []byte
+	state   state
+	i       int
+	imports []Import
+	exports []Export
+}
+
+func (s *scanner) scan() ([]Import, []Export) {
+	for s.i < len(s.src) {
+		char := s.src[s.i]
+
+		switch s.state {
+		case code:
+			switch {
+			case char == '/' && s.i+1 < len(s.src) && s.src[s.i+1] == '/':
+				s.state = lineComment
+				s.i++
+
+			case char == '/' && s.i+1 < len(s.src) && s.src[s.i+1] == '*':
+				s.state = blockComment
+				s.i++
+
+			case char == '"':
+				s.state = stringDouble
+
+			case char == '\'':
+				s.state = stringSingle
+
+			case char == '`':
+				s.state = template
+
+			default: // TODO: case == 'i' || 'e'
+				s.parseCode()
+			}
+
+		case lineComment:
+			if char == '\n' {
+				s.state = code
+			}
+
+		case blockComment:
+			if char == '*' && s.i+1 < len(s.src) && s.src[s.i+1] == '/' {
+				s.state = code
+				s.i++
+			}
+
+		case stringDouble: // TODO: handle \\"
+			if char == '"' && s.i > 0 && s.src[s.i-1] != '\\' {
+				s.state = code
+			}
+
+		case stringSingle: // TODO: handle \\'
+			if char == '\'' && s.i > 0 && s.src[s.i-1] != '\\' {
+				s.state = code
+			}
+
+		case template: // TODO: handle `${}`
+			if char == '`' {
+				s.state = code
+			}
+		}
+
+		s.i++
+	}
+
+	return s.imports, s.exports
+}
+
+// TODO: add a s.peek() method
+
+func (s *scanner) parseCode() {
+	if !s.isWord([]byte("import")) {
+		return
+	}
+
+	imp := Import{}
+	exp := Export{}
+
+	s.skipSpace()
+
+	onlyTypes := false
+	if s.src[s.i] == 't' && s.nextWord() == "type" {
+		onlyTypes = true
+		s.skipSpace()
+	}
+
+	switch s.src[s.i] {
+	case '"', '\'':
+		imp.Kind = SideEffectEdge
+		imp.From = s.readString()
+
+	case '{':
+		imp.Kind = NamedEdge
+		s.i++
+		for {
+			s.skipSpace()
+			if s.src[s.i] == '}' {
+				s.i++
+				break
+			}
+			if s.src[s.i] == ',' {
+				s.i++
+				continue
+			}
+			imp.Symbols = append(imp.Symbols, s.symbolFromNextWord(onlyTypes))
+		}
+		s.skipSpace()
+		s.nextWord() // from
+		s.skipSpace()
+		imp.From = s.readString()
+
+	case '(':
+		imp.Kind = DynamicEdge
+		s.i++
+		imp.From = s.readString()
+		s.i++
+
+	case '*':
+		imp.Kind = NamespaceEdge
+		s.i++
+		s.skipSpace()
+		s.nextWord() // as
+		s.skipSpace()
+		imp.Symbols = append(imp.Symbols, s.symbolFromNextWord(onlyTypes))
+		s.skipSpace()
+		s.nextWord() // from
+		s.skipSpace()
+		imp.From = s.readString()
+
+	default:
+		imp.Kind = DefaultEdge
+		imp.Symbols = append(imp.Symbols, s.symbolFromNextWord(onlyTypes))
+		s.skipSpace()
+		s.nextWord() // from
+		s.skipSpace()
+		imp.From = s.readString()
+	}
+
+	s.imports = append(s.imports, imp)
+	s.exports = append(s.exports, exp)
+}
+
+func (s *scanner) isWord(word []byte) bool {
+	if s.i+len(word) > len(s.src) {
+		return false
+	}
+	for i := range len(word) {
+		c := word[i]
+		if c != s.src[s.i+i] {
+			return false
+		}
+	}
+	s.i += len(word)
+	return true // TODO: check byte before and after are not letters
+}
+
+func (s *scanner) nextWord() string {
+	pos := s.i
+	for isLetter(s.src[s.i]) {
+		s.i++
+	}
+	return string(s.src[pos:s.i])
+}
+
+func (s *scanner) skipSpace() {
+	for s.i < len(s.src) {
+		char := s.src[s.i]
+		if char == ' ' || char == '\t' || char == '\n' || char == '\r' {
+			s.i++
+		} else {
+			break
+		}
+	}
+}
+
+func (s *scanner) readString() string {
+	quote := s.src[s.i]
+	s.i++
+	start := s.i
+	for s.src[s.i] != quote {
+		s.i++
+	}
+	s.i++
+	return string(s.src[start : s.i-1])
+}
+
+func isLetter(char byte) bool {
+	return 'a' <= char && char <= 'z' || 'A' <= char && char <= 'Z' || char == '_'
+}
+
+func (s *scanner) symbolFromNextWord(onlyTypes bool) Symbol {
+	symbol := Symbol{Name: s.nextWord()}
+	if symbol.Name == "type" {
+		symbol.TypeOnly = true
+		s.skipSpace()
+		symbol.Name = s.nextWord()
+	} else if onlyTypes {
+		symbol.TypeOnly = true
+	}
+	return symbol
+}

package/parser/scanner_test.go

@@ -0,0 +1,62 @@
+package parser
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestScannerEveryImport(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected Import
+	}{
+		{"side-effect single quote", "import 'mod'", Import{Kind: SideEffectEdge, From: "mod"}},
+		{"side-effect double quote", "import \"mod\"", Import{Kind: SideEffectEdge, From: "mod"}},
+		{"default import", "import foo from 'mod'", Import{Kind: DefaultEdge, From: "mod", Symbols: []Symbol{{Name: "foo"}}}},
+		{"default type import", "import type foo from 'mod'", Import{Kind: DefaultEdge, From: "mod", Symbols: []Symbol{{Name: "foo", TypeOnly: true}}}},
+		{"named imports", "import { foo, bar } from 'mod'", Import{Kind: NamedEdge, From: "mod", Symbols: []Symbol{{Name: "foo"}, {Name: "bar"}}}},
+		// {"renamed imports", "import { foo as bar } from 'mod'", Import{Kind: NamedEdge, From: "mod", Symbols: []Symbol{{Name: "foo"}}}},
+		{"named type imports", "import { type foo, bar } from 'mod'", Import{Kind: NamedEdge, From: "mod", Symbols: []Symbol{{Name: "foo", TypeOnly: true}, {Name: "bar"}}}},
+		{"named only type imports", "import type { foo, bar } from 'mod'", Import{Kind: NamedEdge, From: "mod", Symbols: []Symbol{{Name: "foo", TypeOnly: true}, {Name: "bar", TypeOnly: true}}}},
+		{"namepace import", "import * as foo from 'mod'", Import{Kind: NamespaceEdge, From: "mod", Symbols: []Symbol{{Name: "foo"}}}},
+		// {"", "import type foo, { bar } from 'mod'", Import{}},
+		{"namepace type import", "import type * as foo from 'mod'", Import{Kind: NamespaceEdge, From: "mod", Symbols: []Symbol{{Name: "foo", TypeOnly: true}}}},
+		{"dynamic import", "import('mod')", Import{Kind: DynamicEdge, From: "mod"}},
+	}
+
+	// TODO: Tightly packed forms
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			scanner := &scanner{src: []byte(tt.input)}
+			imports, _ := scanner.scan()
+
+			if len(imports) != 1 {
+				t.Fatalf("expected 1 edge, got %d", len(imports))
+			}
+
+			if !reflect.DeepEqual(imports[0], tt.expected) {
+				t.Errorf("expected %+v, got %+v", tt.expected, imports[0])
+			}
+		})
+	}
+}
+
+// TODO: add tests for non imports
+
+// import x from "mod"
+// import { a, b } from "mod"
+// import * as ns from "mod"
+// import "mod"
+// import type { T } from "mod"
+// const x = require("mod")
+// const x = await import("mod")
+
+// export const x = ...
+// export function f() {}
+// export default ...
+// export { a, b as c }
+// export { x } from "mod"
+// export * from "mod"
+// export * as ns from "mod"