@praneeth_54/agentdoctor 2.1.0 → 3.0.1

package/dist/product/deps/analyze.js

@@ -0,0 +1,137 @@
+import path from "node:path";
+import { DEFAULT_MAX_FILE_SIZE_BYTES } from "../../constants.js";
+import { detectProject } from "../../detectors/project.js";
+import { detectMonorepo } from "../../detectors/monorepo.js";
+import { readJsonFile } from "../../utils/fs.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { parseAllLockfiles } from "./lockfiles.js";
+function basename(rel) {
+    const parts = rel.split("/");
+    return parts[parts.length - 1] ?? rel;
+}
+function lockfilesFromPaths(relativePaths) {
+    const names = new Set();
+    for (const p of relativePaths) {
+        const base = basename(p).toLowerCase();
+        if (base === "package-lock.json" ||
+            base === "yarn.lock" ||
+            base === "pnpm-lock.yaml" ||
+            base === "bun.lockb") {
+            names.add(p.replace(/\\/g, "/"));
+        }
+    }
+    return [...names].sort();
+}
+function importersForPackage(depName, graph) {
+    if (!graph)
+        return [];
+    const importers = new Set();
+    for (const edge of graph.edges) {
+        if (edge.kind !== "imports" && edge.kind !== "depends-on")
+            continue;
+        const target = graph.nodes.find((n) => n.id === edge.to);
+        const source = graph.nodes.find((n) => n.id === edge.from);
+        if (!target || !source)
+            continue;
+        const label = target.label ?? target.id;
+        if (label === depName || label.endsWith(`/${depName}`) || label.includes(depName)) {
+            if (source.path)
+                importers.add(source.path.replace(/\\/g, "/"));
+            else if (source.label)
+                importers.add(source.label);
+        }
+    }
+    return [...importers].sort();
+}
+export async function analyzeDependencies(rootInput, options) {
+    const maxFileSizeBytes = options?.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE_BYTES;
+    const root = resolveRepoRoot(rootInput);
+    const detection = await detectProject(root, maxFileSizeBytes);
+    const relativePaths = detection.discovery.files.map((f) => f.relativePath.replace(/\\/g, "/"));
+    let rootWorkspaces;
+    const rootPkg = await readJsonFile(path.join(root, "package.json"), maxFileSizeBytes);
+    if (rootPkg.ok)
+        rootWorkspaces = rootPkg.data.workspaces;
+    const monorepo = detectMonorepo({
+        relativePaths,
+        packageJsonWorkspaces: rootWorkspaces,
+    }).monorepo;
+    const lockfilesPresent = lockfilesFromPaths(relativePaths);
+    const limitations = [
+        "Direct dependencies are read from package.json files only.",
+        "Transitive versions are VERIFIED only when a lockfile was parsed successfully.",
+    ];
+    if (!lockfilesPresent.length) {
+        limitations.push("No lockfile detected; transitive upgrade impact is UNKNOWN.");
+    }
+    const lockParse = await parseAllLockfiles(root, lockfilesPresent, maxFileSizeBytes);
+    limitations.push(...lockParse.limitations);
+    const packageJsonPaths = relativePaths.filter((p) => basename(p).toLowerCase() === "package.json");
+    const directDependencies = [];
+    const nameToPaths = new Map();
+    for (const rel of packageJsonPaths) {
+        const parsed = await readJsonFile(path.join(root, rel), maxFileSizeBytes);
+        if (!parsed.ok)
+            continue;
+        const pkgName = parsed.data.name?.trim();
+        if (pkgName) {
+            const list = nameToPaths.get(pkgName) ?? [];
+            list.push(rel);
+            nameToPaths.set(pkgName, list);
+        }
+        const sections = [
+            ["dependencies", parsed.data.dependencies],
+            ["devDependencies", parsed.data.devDependencies],
+            ["peerDependencies", parsed.data.peerDependencies],
+        ];
+        for (const [section, deps] of sections) {
+            if (!deps)
+                continue;
+            for (const [name, versionRange] of Object.entries(deps)) {
+                directDependencies.push({
+                    name,
+                    versionRange,
+                    packageJsonPath: rel,
+                    truth: "VERIFIED",
+                    evidence: [{ path: rel, excerpt: `${section}.${name}` }],
+                });
+            }
+        }
+    }
+    directDependencies.sort((a, b) => a.name === b.name
+        ? a.packageJsonPath.localeCompare(b.packageJsonPath)
+        : a.name.localeCompare(b.name));
+    const duplicateNames = [];
+    for (const [name, paths] of nameToPaths) {
+        if (paths.length > 1) {
+            duplicateNames.push({
+                name,
+                paths: [...paths].sort(),
+                truth: "VERIFIED",
+            });
+        }
+    }
+    const upgradeImpact = [];
+    const uniqueDeps = [...new Set(directDependencies.map((d) => d.name))];
+    for (const dep of uniqueDeps) {
+        const importers = importersForPackage(dep, options?.graph);
+        if (importers.length) {
+            upgradeImpact.push({
+                dependency: dep,
+                importers,
+                truth: options?.graph ? "INFERRED" : "UNKNOWN",
+            });
+        }
+    }
+    return {
+        root,
+        monorepo,
+        directDependencies,
+        duplicateNames,
+        lockfilesPresent,
+        lockfilesParsed: lockParse.parsedLockfiles,
+        transitiveFromLockfile: lockParse.packages,
+        upgradeImpact,
+        limitations,
+    };
+}

package/dist/product/deps/lockfiles.d.ts

@@ -0,0 +1,25 @@
+import type { ProductEvidence, TruthLabel } from "../truth.js";
+export interface LockfilePackageVersion {
+    name: string;
+    version: string;
+    lockfile: string;
+    truth: TruthLabel;
+    evidence: ProductEvidence[];
+}
+export interface ParsedLockfile {
+    lockfilePath: string;
+    format: "npm" | "yarn" | "pnpm" | "unknown";
+    packages: LockfilePackageVersion[];
+    limitations: string[];
+}
+export declare function parsePackageLockJson(content: string, lockfilePath: string): ParsedLockfile;
+export declare function parseYarnLock(content: string, lockfilePath: string): ParsedLockfile;
+export declare function parsePnpmLockYaml(content: string, lockfilePath: string): ParsedLockfile;
+export declare function parseLockfileAtPath(root: string, relativePath: string, maxBytes: number): Promise<ParsedLockfile | null>;
+export declare function parseAllLockfiles(root: string, lockfilePaths: string[], maxBytes: number): Promise<{
+    packages: LockfilePackageVersion[];
+    parsedLockfiles: string[];
+    limitations: string[];
+}>;
+/** Test helper: read lockfile from disk */
+export declare function readLockfileFile(filePath: string): Promise<string>;

package/dist/product/deps/lockfiles.js

@@ -0,0 +1,200 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { readTextFile } from "../../utils/fs.js";
+function npmPackageNameFromKey(key) {
+    if (!key || key === "")
+        return null;
+    const idx = key.lastIndexOf("node_modules/");
+    const tail = idx >= 0 ? key.slice(idx + "node_modules/".length) : key;
+    if (!tail || (tail.startsWith("@") === false && tail.includes("@"))) {
+        const at = tail.indexOf("@");
+        if (at > 0)
+            return tail.slice(0, at);
+    }
+    return tail.split("/").filter(Boolean).pop() ?? null;
+}
+export function parsePackageLockJson(content, lockfilePath) {
+    const limitations = [];
+    let data;
+    try {
+        data = JSON.parse(content);
+    }
+    catch {
+        return {
+            lockfilePath,
+            format: "npm",
+            packages: [],
+            limitations: ["package-lock.json is not valid JSON"],
+        };
+    }
+    const obj = data;
+    const packages = [];
+    const seen = new Set();
+    if (obj.packages && typeof obj.packages === "object") {
+        for (const [key, entry] of Object.entries(obj.packages)) {
+            const version = entry?.version?.trim();
+            if (!version)
+                continue;
+            const name = entry.name?.trim() ||
+                npmPackageNameFromKey(key) ||
+                (key === "" ? null : key.replace(/^node_modules\//, ""));
+            if (!name)
+                continue;
+            const dedupe = `${name}@${version}`;
+            if (seen.has(dedupe))
+                continue;
+            seen.add(dedupe);
+            packages.push({
+                name,
+                version,
+                lockfile: lockfilePath,
+                truth: "VERIFIED",
+                evidence: [{ path: lockfilePath, excerpt: `packages["${key}"].version=${version}` }],
+            });
+        }
+    }
+    else if (obj.dependencies && typeof obj.dependencies === "object") {
+        limitations.push("npm lockfile v1 dependencies tree — shallow direct entries only");
+        for (const [name, entry] of Object.entries(obj.dependencies)) {
+            const version = entry?.version?.trim();
+            if (!version)
+                continue;
+            packages.push({
+                name,
+                version,
+                lockfile: lockfilePath,
+                truth: "VERIFIED",
+                evidence: [{ path: lockfilePath, excerpt: `dependencies.${name}=${version}` }],
+            });
+        }
+    }
+    else {
+        limitations.push("Unrecognized package-lock.json shape");
+    }
+    packages.sort((a, b) => a.name.localeCompare(b.name) || a.version.localeCompare(b.version));
+    return { lockfilePath, format: "npm", packages, limitations };
+}
+export function parseYarnLock(content, lockfilePath) {
+    const packages = [];
+    const seen = new Set();
+    const lines = content.split(/\r?\n/);
+    let currentKey = null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const header = /^([^\s].+):$/.exec(line);
+        if (header) {
+            currentKey = header[1].trim();
+            continue;
+        }
+        if (currentKey && /^\s+version\s+/.test(line)) {
+            const verMatch = /version\s+"([^"]+)"/.exec(line);
+            if (!verMatch)
+                continue;
+            const version = verMatch[1];
+            const resolvedName = (() => {
+                const first = currentKey.split(",")[0].trim();
+                const at = first.lastIndexOf("@");
+                if (at <= 0)
+                    return first;
+                return first.slice(0, at);
+            })();
+            const dedupe = `${resolvedName}@${version}`;
+            if (seen.has(dedupe))
+                continue;
+            seen.add(dedupe);
+            packages.push({
+                name: resolvedName,
+                version,
+                lockfile: lockfilePath,
+                truth: "VERIFIED",
+                evidence: [{ path: lockfilePath, line: i + 1, excerpt: line.trim().slice(0, 120) }],
+            });
+        }
+        if (line.trim() === "" && currentKey) {
+            currentKey = null;
+        }
+    }
+    packages.sort((a, b) => a.name.localeCompare(b.name) || a.version.localeCompare(b.version));
+    return {
+        lockfilePath,
+        format: "yarn",
+        packages,
+        limitations: ["yarn.lock parsing uses version blocks — workspace aliases may be incomplete"],
+    };
+}
+export function parsePnpmLockYaml(content, lockfilePath) {
+    const packages = [];
+    const seen = new Set();
+    const limitations = [
+        "pnpm-lock.yaml parsing is heuristic (packages: keys) — not a full YAML AST",
+    ];
+    const pkgSection = /(?:^|\n)packages:\s*\n([\s\S]*?)(?:\n\S|\n*$)/.exec(content);
+    const body = pkgSection?.[1] ?? content;
+    for (const line of body.split(/\r?\n/)) {
+        const keyMatch = /^\s{2}(['"]?)(\/[^'":]+@[^'":]+)\1:\s*$/.exec(line);
+        if (!keyMatch)
+            continue;
+        const key = keyMatch[2];
+        const at = key.lastIndexOf("@");
+        if (at <= 1)
+            continue;
+        const name = key.slice(1, at);
+        const version = key.slice(at + 1);
+        const dedupe = `${name}@${version}`;
+        if (seen.has(dedupe))
+            continue;
+        seen.add(dedupe);
+        packages.push({
+            name,
+            version,
+            lockfile: lockfilePath,
+            truth: "VERIFIED",
+            evidence: [{ path: lockfilePath, excerpt: key.slice(0, 120) }],
+        });
+    }
+    packages.sort((a, b) => a.name.localeCompare(b.name) || a.version.localeCompare(b.version));
+    return { lockfilePath, format: "pnpm", packages, limitations };
+}
+export async function parseLockfileAtPath(root, relativePath, maxBytes) {
+    const abs = path.join(root, relativePath);
+    const base = path.basename(relativePath).toLowerCase();
+    const text = await readTextFile(abs, maxBytes);
+    if (text === null)
+        return null;
+    if (base === "package-lock.json" || base === "npm-shrinkwrap.json") {
+        return parsePackageLockJson(text, relativePath);
+    }
+    if (base === "yarn.lock") {
+        return parseYarnLock(text, relativePath);
+    }
+    if (base === "pnpm-lock.yaml") {
+        return parsePnpmLockYaml(text, relativePath);
+    }
+    return null;
+}
+export async function parseAllLockfiles(root, lockfilePaths, maxBytes) {
+    const all = [];
+    const parsedLockfiles = [];
+    const limitations = [];
+    const seen = new Set();
+    for (const rel of lockfilePaths) {
+        const parsed = await parseLockfileAtPath(root, rel, maxBytes);
+        if (!parsed || parsed.packages.length === 0)
+            continue;
+        parsedLockfiles.push(rel);
+        limitations.push(...parsed.limitations);
+        for (const p of parsed.packages) {
+            const key = `${p.name}@${p.version}::${p.lockfile}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            all.push(p);
+        }
+    }
+    all.sort((a, b) => a.name.localeCompare(b.name) || a.version.localeCompare(b.version));
+    return { packages: all, parsedLockfiles, limitations };
+}
+/** Test helper: read lockfile from disk */
+export async function readLockfileFile(filePath) {
+    return fs.readFile(filePath, "utf8");
+}

package/dist/product/discovery/roots.d.ts

@@ -0,0 +1,52 @@
+import type { TruthLabel } from "../truth.js";
+export interface ProjectCandidate {
+    root: string;
+    score: number;
+    markers: string[];
+    truth: TruthLabel;
+    reason: string;
+}
+export interface ProjectDiscoveryReport {
+    cwd: string;
+    home: string;
+    candidates: ProjectCandidate[];
+    selected: ProjectCandidate | null;
+    blocked: boolean;
+    blockReason: string | null;
+    estimatedEntries: number;
+    limitations: string[];
+}
+export interface DiscoverProjectOptions {
+    cwd?: string;
+    /** Maximum directory entries to count before aborting deep scans. */
+    maxEntries?: number;
+    /** Prefer this path if it is a valid project. */
+    prefer?: string;
+    /** Auto-select highest score when exactly one strong candidate. */
+    autoSelect?: boolean;
+}
+/**
+ * True when `cwd` is the user home directory or a similarly unsafe broad folder
+ * (Desktop / Downloads / Documents). Used to refuse silent whole-home scans.
+ */
+export declare function classifyBroadUserScanRoot(cwdInput: string, homeInput?: string): {
+    blocked: true;
+    reason: string;
+} | {
+    blocked: false;
+};
+/**
+ * Discover likely project roots from cwd without silently scanning home/Desktop/Downloads
+ * or unbounded parent trees.
+ */
+export declare function discoverProjectRoots(options?: DiscoverProjectOptions): Promise<ProjectDiscoveryReport>;
+export declare function resolveStartedProjectRoot(pathArg: string | undefined, options?: {
+    maxEntries?: number;
+}): Promise<{
+    ok: true;
+    root: string;
+    discovery: ProjectDiscoveryReport;
+} | {
+    ok: false;
+    discovery: ProjectDiscoveryReport;
+}>;

package/dist/product/discovery/roots.js

@@ -0,0 +1,231 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { DEFAULT_IGNORE_DIRECTORIES } from "../../constants.js";
+import { isDirectory, pathExists } from "../../utils/fs.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+/** Markers that strongly suggest a software project root. */
+const PROJECT_MARKERS = [
+    "package.json",
+    "composer.json",
+    "pyproject.toml",
+    "Cargo.toml",
+    "go.mod",
+    "pom.xml",
+    "build.gradle",
+    "build.gradle.kts",
+    "Gemfile",
+    "mix.exs",
+    "pubspec.yaml",
+    ".git",
+];
+const SUSPICIOUS_DIR_NAMES = new Set([
+    "desktop",
+    "downloads",
+    "documents",
+    "pictures",
+    "movies",
+    "music",
+    "library",
+    "applications",
+]);
+function normalizeHome(home) {
+    return path.resolve(home);
+}
+function isUnderHomeSubtree(abs, home, leaf) {
+    const target = path.resolve(home, leaf);
+    const resolved = path.resolve(abs);
+    return resolved === target || resolved.startsWith(target + path.sep);
+}
+async function countEntriesShallow(dir, budget) {
+    let count = 0;
+    const queue = [dir];
+    const skip = DEFAULT_IGNORE_DIRECTORIES;
+    while (queue.length > 0 && count < budget) {
+        const current = queue.pop();
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            count += 1;
+            if (count >= budget)
+                return count;
+            if (!entry.isDirectory() || entry.isSymbolicLink())
+                continue;
+            if (skip.has(entry.name) || entry.name.startsWith("."))
+                continue;
+            queue.push(path.join(current, entry.name));
+        }
+    }
+    return count;
+}
+async function markersAt(dir) {
+    const found = [];
+    for (const marker of PROJECT_MARKERS) {
+        if (await pathExists(path.join(dir, marker))) {
+            found.push(marker);
+        }
+    }
+    return found;
+}
+function scoreMarkers(markers) {
+    let score = 0;
+    for (const m of markers) {
+        if (m === ".git")
+            score += 3;
+        else if (m === "package.json" || m === "composer.json" || m === "pyproject.toml")
+            score += 5;
+        else
+            score += 4;
+    }
+    return score;
+}
+/**
+ * True when `cwd` is the user home directory or a similarly unsafe broad folder
+ * (Desktop / Downloads / Documents). Used to refuse silent whole-home scans.
+ */
+export function classifyBroadUserScanRoot(cwdInput, homeInput) {
+    const cwd = path.resolve(cwdInput);
+    const home = normalizeHome(homeInput ?? os.homedir());
+    const baselower = path.basename(cwd).toLowerCase();
+    if (cwd === home ||
+        SUSPICIOUS_DIR_NAMES.has(baselower) ||
+        isUnderHomeSubtree(cwd, home, "Desktop") ||
+        isUnderHomeSubtree(cwd, home, "Downloads") ||
+        isUnderHomeSubtree(cwd, home, "Documents")) {
+        return {
+            blocked: true,
+            reason: "Refusing to scan home / Desktop / Downloads / Documents (or similarly broad user folders) as a project root. Navigate into a project directory or pass an explicit project path.",
+        };
+    }
+    return { blocked: false };
+}
+/**
+ * Discover likely project roots from cwd without silently scanning home/Desktop/Downloads
+ * or unbounded parent trees.
+ */
+export async function discoverProjectRoots(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const home = normalizeHome(os.homedir());
+    const maxEntries = options.maxEntries ?? 25_000;
+    const limitations = [
+        "Discovery uses shallow marker probes and bounded entry counts — not a full repository index.",
+        "Candidates are VERIFIED only when marker files/directories exist on disk.",
+    ];
+    const broad = classifyBroadUserScanRoot(cwd, home);
+    if (broad.blocked) {
+        const estimatedEntries = await countEntriesShallow(cwd, Math.min(maxEntries, 5_000));
+        return {
+            cwd,
+            home,
+            candidates: [],
+            selected: null,
+            blocked: true,
+            blockReason: broad.reason,
+            estimatedEntries,
+            limitations,
+        };
+    }
+    const estimatedEntries = await countEntriesShallow(cwd, maxEntries + 1);
+    if (estimatedEntries > maxEntries) {
+        return {
+            cwd,
+            home,
+            candidates: [],
+            selected: null,
+            blocked: true,
+            blockReason: `Directory tree exceeds safe scan budget (${maxEntries} entries). Narrow to a project subdirectory or raise --max-entries deliberately.`,
+            estimatedEntries,
+            limitations,
+        };
+    }
+    const candidates = [];
+    const seen = new Set();
+    async function consider(dir, reason) {
+        const resolved = path.resolve(dir);
+        if (seen.has(resolved))
+            return;
+        if (!(await isDirectory(resolved)))
+            return;
+        if (resolved === home)
+            return;
+        const markers = await markersAt(resolved);
+        if (markers.length === 0)
+            return;
+        seen.add(resolved);
+        candidates.push({
+            root: resolved,
+            score: scoreMarkers(markers),
+            markers,
+            truth: "VERIFIED",
+            reason,
+        });
+    }
+    if (options.prefer) {
+        await consider(options.prefer, "explicit prefer path");
+    }
+    await consider(cwd, "current working directory");
+    // Walk up a few parents looking for markers (bounded).
+    let parent = path.dirname(cwd);
+    for (let i = 0; i < 4; i++) {
+        if (parent === home || parent === path.dirname(parent))
+            break;
+        await consider(parent, "parent directory with project markers");
+        parent = path.dirname(parent);
+    }
+    // Immediate children that look like projects (monorepo packages / sibling apps).
+    try {
+        const entries = await fs.readdir(cwd, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.isSymbolicLink())
+                continue;
+            if (DEFAULT_IGNORE_DIRECTORIES.has(entry.name) || entry.name.startsWith("."))
+                continue;
+            await consider(path.join(cwd, entry.name), "child directory with project markers");
+        }
+    }
+    catch {
+        limitations.push("Could not list child directories for candidate discovery.");
+    }
+    candidates.sort((a, b) => b.score - a.score || a.root.localeCompare(b.root));
+    let selected = null;
+    if (options.prefer) {
+        selected = candidates.find((c) => c.root === path.resolve(options.prefer)) ?? null;
+    }
+    else if (options.autoSelect !== false) {
+        const strong = candidates.filter((c) => c.score >= 5);
+        if (strong.length === 1) {
+            selected = strong[0];
+        }
+        else if (candidates.length === 1) {
+            selected = candidates[0];
+        }
+    }
+    return {
+        cwd,
+        home,
+        candidates,
+        selected,
+        blocked: false,
+        blockReason: null,
+        estimatedEntries,
+        limitations,
+    };
+}
+export async function resolveStartedProjectRoot(pathArg, options) {
+    const prefer = pathArg ? resolveRepoRoot(pathArg) : undefined;
+    const discovery = await discoverProjectRoots({
+        cwd: prefer ?? process.cwd(),
+        ...(prefer !== undefined ? { prefer } : {}),
+        ...(options?.maxEntries !== undefined ? { maxEntries: options.maxEntries } : {}),
+        autoSelect: true,
+    });
+    if (discovery.blocked || !discovery.selected) {
+        return { ok: false, discovery };
+    }
+    return { ok: true, root: discovery.selected.root, discovery };
+}

package/dist/product/dna/build.d.ts

@@ -0,0 +1,50 @@
+import type { TruthLabel } from "../truth.js";
+export interface ProjectDna {
+    fingerprint: string;
+    name: string;
+    root: string;
+    projectType: string;
+    languages: string[];
+    frameworks: string[];
+    frontend: string[];
+    backend: string[];
+    database: string[];
+    packageManagers: string[];
+    buildSystems: string[];
+    testFrameworks: string[];
+    infrastructure: string[];
+    cloudIndicators: string[];
+    git: {
+        present: boolean;
+        truth: TruthLabel;
+    };
+    monorepo: {
+        isMonorepo: boolean;
+        tool: string;
+        packages: Array<{
+            name: string;
+            path: string;
+        }>;
+        truth: TruthLabel;
+    };
+    services: string[];
+    packages: string[];
+    applications: string[];
+    externalIntegrations: string[];
+    aiCodingTools: string[];
+    counts: {
+        files: number;
+        sourceFiles: number;
+        testFiles: number;
+        configFiles: number;
+    };
+    configurationStructure: string[];
+    truth: TruthLabel;
+    limitations: string[];
+    generatedAt: string;
+}
+/**
+ * Deterministic Project DNA from repository detectors + file inventory.
+ */
+export declare function buildProjectDna(rootInput: string): Promise<ProjectDna>;
+export declare function persistProjectDna(rootInput: string, dna?: ProjectDna): Promise<ProjectDna>;