taphound 0.2.0-dev.1 → 0.2.0-dev.12

package/dist/domain/project-context.d.ts

@@ -1,4 +1,14 @@
 import { z } from "zod";
+export declare const InteractionActionSchema: z.ZodEnum<{
+    swipe: "swipe";
+    click: "click";
+    longClick: "longClick";
+    inputText: "inputText";
+    scrollTo: "scrollTo";
+    back: "back";
+    wait: "wait";
+}>;
+export type InteractionAction = z.infer<typeof InteractionActionSchema>;
 export declare const ContextEvidenceConfidenceSchema: z.ZodEnum<{
     unknown: "unknown";
     sourceConfirmed: "sourceConfirmed";
@@ -12,6 +22,7 @@ export declare const ContextManifestSchema: z.ZodObject<{
     files: z.ZodArray<z.ZodObject<{
         path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
         sha256: z.ZodString;
+        semanticSha256: z.ZodOptional<z.ZodString>;
         confidence: z.ZodEnum<{
             unknown: "unknown";
             sourceConfirmed: "sourceConfirmed";
@@ -49,8 +60,34 @@ export declare const InteractionPolicySchema: z.ZodObject<{
         wait: "wait";
     }>>;
 }, z.core.$strict>;
+export declare const ContextShardStatusSchema: z.ZodEnum<{
+    complete: "complete";
+    partial: "partial";
+    unsupported: "unsupported";
+    notAnalyzed: "notAnalyzed";
+}>;
+export declare const ContextModuleReferenceSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectDir: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    kind: z.ZodEnum<{
+        application: "application";
+        feature: "feature";
+        library: "library";
+    }>;
+    contextPath: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    sha256: z.ZodString;
+    features: z.ZodArray<z.ZodString>;
+    activities: z.ZodArray<z.ZodString>;
+    dependsOn: z.ZodArray<z.ZodString>;
+    status: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+        unsupported: "unsupported";
+        notAnalyzed: "notAnalyzed";
+    }>;
+}, z.core.$strict>;
 export declare const ProjectContextSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
+    version: z.ZodLiteral<2>;
     packageName: z.ZodString;
     launchActivity: z.ZodString;
     manifest: z.ZodObject<{
@@ -58,6 +95,7 @@ export declare const ProjectContextSchema: z.ZodObject<{
         files: z.ZodArray<z.ZodObject<{
             path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
             sha256: z.ZodString;
+            semanticSha256: z.ZodOptional<z.ZodString>;
             confidence: z.ZodEnum<{
                 unknown: "unknown";
                 sourceConfirmed: "sourceConfirmed";
@@ -95,7 +133,187 @@ export declare const ProjectContextSchema: z.ZodObject<{
             wait: "wait";
         }>>;
     }, z.core.$strict>;
+    modules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        projectDir: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        kind: z.ZodEnum<{
+            application: "application";
+            feature: "feature";
+            library: "library";
+        }>;
+        contextPath: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        sha256: z.ZodString;
+        features: z.ZodArray<z.ZodString>;
+        activities: z.ZodArray<z.ZodString>;
+        dependsOn: z.ZodArray<z.ZodString>;
+        status: z.ZodEnum<{
+            complete: "complete";
+            partial: "partial";
+            unsupported: "unsupported";
+            notAnalyzed: "notAnalyzed";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const ProjectContextModuleSchema: z.ZodObject<{
+    version: z.ZodLiteral<2>;
+    moduleId: z.ZodString;
+    projectDir: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    status: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+        unsupported: "unsupported";
+        notAnalyzed: "notAnalyzed";
+    }>;
+    inventory: z.ZodObject<{
+        version: z.ZodLiteral<2>;
+        pathSetSha256: z.ZodString;
+        categories: z.ZodArray<z.ZodEnum<{
+            manifests: "manifests";
+            sources: "sources";
+            layouts: "layouts";
+            navigation: "navigation";
+        }>>;
+    }, z.core.$strict>;
+    manifest: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            sha256: z.ZodString;
+            semanticSha256: z.ZodOptional<z.ZodString>;
+            confidence: z.ZodEnum<{
+                unknown: "unknown";
+                sourceConfirmed: "sourceConfirmed";
+                runtimeConfirmed: "runtimeConfirmed";
+                inferred: "inferred";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    summary: z.ZodObject<{
+        features: z.ZodArray<z.ZodString>;
+        activities: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            entryPoints: z.ZodArray<z.ZodString>;
+            screens: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        elements: z.ZodArray<z.ZodObject<{
+            screen: z.ZodString;
+            resourceId: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            contentDescription: z.ZodOptional<z.ZodString>;
+            actions: z.ZodArray<z.ZodEnum<{
+                swipe: "swipe";
+                click: "click";
+                longClick: "longClick";
+                inputText: "inputText";
+                scrollTo: "scrollTo";
+                back: "back";
+                wait: "wait";
+            }>>;
+        }, z.core.$strict>>;
+        transitions: z.ZodArray<z.ZodObject<{
+            fromActivity: z.ZodString;
+            actionResourceId: z.ZodOptional<z.ZodString>;
+            actionText: z.ZodOptional<z.ZodString>;
+            toActivity: z.ZodString;
+        }, z.core.$strict>>;
+        logcat: z.ZodArray<z.ZodObject<{
+            tag: z.ZodString;
+            pattern: z.ZodString;
+            match: z.ZodEnum<{
+                literal: "literal";
+                regex: "regex";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ContextSelectionSchema: z.ZodObject<{
+    bundleVersion: z.ZodLiteral<2>;
+    indexHash: z.ZodString;
+    modules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sha256: z.ZodString;
+        projectDir: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        inventory: z.ZodObject<{
+            pathSetSha256: z.ZodString;
+            categories: z.ZodArray<z.ZodEnum<{
+                manifests: "manifests";
+                sources: "sources";
+                layouts: "layouts";
+                navigation: "navigation";
+            }>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const ResolvedProjectContextSchema: z.ZodObject<{
+    version: z.ZodLiteral<2>;
+    packageName: z.ZodString;
+    launchActivity: z.ZodString;
+    manifest: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            sha256: z.ZodString;
+            semanticSha256: z.ZodOptional<z.ZodString>;
+            confidence: z.ZodEnum<{
+                unknown: "unknown";
+                sourceConfirmed: "sourceConfirmed";
+                runtimeConfirmed: "runtimeConfirmed";
+                inferred: "inferred";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    interactionPolicy: z.ZodObject<{
+        allowedActions: z.ZodArray<z.ZodEnum<{
+            swipe: "swipe";
+            click: "click";
+            longClick: "longClick";
+            inputText: "inputText";
+            scrollTo: "scrollTo";
+            back: "back";
+            wait: "wait";
+        }>>;
+        confirmationRequiredActions: z.ZodArray<z.ZodEnum<{
+            swipe: "swipe";
+            click: "click";
+            longClick: "longClick";
+            inputText: "inputText";
+            scrollTo: "scrollTo";
+            back: "back";
+            wait: "wait";
+        }>>;
+        forbiddenActions: z.ZodArray<z.ZodEnum<{
+            swipe: "swipe";
+            click: "click";
+            longClick: "longClick";
+            inputText: "inputText";
+            scrollTo: "scrollTo";
+            back: "back";
+            wait: "wait";
+        }>>;
+    }, z.core.$strict>;
+    selection: z.ZodObject<{
+        bundleVersion: z.ZodLiteral<2>;
+        indexHash: z.ZodString;
+        modules: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            sha256: z.ZodString;
+            projectDir: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            inventory: z.ZodObject<{
+                pathSetSha256: z.ZodString;
+                categories: z.ZodArray<z.ZodEnum<{
+                    manifests: "manifests";
+                    sources: "sources";
+                    layouts: "layouts";
+                    navigation: "navigation";
+                }>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
 }, z.core.$strict>;
 export type ContextManifest = z.infer<typeof ContextManifestSchema>;
 export type InteractionPolicy = z.infer<typeof InteractionPolicySchema>;
 export type ProjectContext = z.infer<typeof ProjectContextSchema>;
+export type ContextModuleReference = z.infer<typeof ContextModuleReferenceSchema>;
+export type ProjectContextModule = z.infer<typeof ProjectContextModuleSchema>;
+export type ContextSelection = z.infer<typeof ContextSelectionSchema>;
+export type ResolvedProjectContext = z.infer<typeof ResolvedProjectContextSchema>;

package/dist/domain/project-context.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
+import { CONTEXT_DIR } from "./workspace.js";
 const QualifiedNameSchema = z.string().regex(/^(?:[A-Za-z_$][\w$]*\.)+[A-Za-z_$][\w$]*$/, "Value must be fully qualified");
-const GenerationActionSchema = z.enum([
+export const InteractionActionSchema = z.enum([
     "click",
     "longClick",
     "inputText",
@@ -22,19 +23,34 @@ export const ProjectRelativePathSchema = z.string()
     .refine((path) => (!path.startsWith("/")
     && !/^[A-Za-z]:/.test(path)
     && !path.split("/").includes("..")), "Path must stay within the project");
+const ContextDocumentPathSchema = ProjectRelativePathSchema.refine((path) => path.startsWith(`${CONTEXT_DIR}/`)
+    || path.startsWith("context/"), "Context documents must stay under the TapHound context directory");
 const ContextFileSchema = z.strictObject({
     path: ProjectRelativePathSchema,
     sha256: z.string().regex(/^[a-f\d]{64}$/),
+    semanticSha256: z.string().regex(/^[a-f\d]{64}$/).optional(),
     confidence: ContextEvidenceConfidenceSchema
 });
 export const ContextManifestSchema = z.strictObject({
     version: z.literal(1),
     files: z.array(ContextFileSchema).min(1)
+}).superRefine((manifest, context) => {
+    const paths = new Set();
+    for (const [index, file] of manifest.files.entries()) {
+        if (paths.has(file.path)) {
+            context.addIssue({
+                code: "custom",
+                path: ["files", index, "path"],
+                message: "Context evidence paths must be unique"
+            });
+        }
+        paths.add(file.path);
+    }
 });
 export const InteractionPolicySchema = z.strictObject({
-    allowedActions: z.array(GenerationActionSchema),
-    confirmationRequiredActions: z.array(GenerationActionSchema),
-    forbiddenActions: z.array(GenerationActionSchema)
+    allowedActions: z.array(InteractionActionSchema),
+    confirmationRequiredActions: z.array(InteractionActionSchema),
+    forbiddenActions: z.array(InteractionActionSchema)
 }).superRefine((policy, context) => {
     const forbidden = new Set(policy.forbiddenActions);
     const overlap = policy.allowedActions.find((action) => forbidden.has(action));
@@ -55,10 +71,197 @@ export const InteractionPolicySchema = z.strictObject({
         });
     }
 });
+const NonemptyUniqueStringsSchema = z.array(z.string().trim().min(1))
+    .superRefine((values, context) => {
+    const seen = new Set();
+    for (const [index, value] of values.entries()) {
+        if (seen.has(value)) {
+            context.addIssue({
+                code: "custom",
+                path: [index],
+                message: "Values must be unique"
+            });
+        }
+        seen.add(value);
+    }
+});
+export const ContextShardStatusSchema = z.enum([
+    "complete",
+    "partial",
+    "unsupported",
+    "notAnalyzed"
+]);
+export const ContextModuleReferenceSchema = z.strictObject({
+    id: z.string().trim().min(1),
+    projectDir: ProjectRelativePathSchema,
+    kind: z.enum(["application", "feature", "library"]),
+    contextPath: ContextDocumentPathSchema,
+    sha256: z.string().regex(/^[a-f\d]{64}$/),
+    features: NonemptyUniqueStringsSchema,
+    activities: z.array(QualifiedNameSchema).superRefine((values, context) => {
+        if (new Set(values).size !== values.length) {
+            context.addIssue({
+                code: "custom",
+                message: "Module Activity names must be unique"
+            });
+        }
+    }),
+    dependsOn: NonemptyUniqueStringsSchema,
+    status: ContextShardStatusSchema
+});
 export const ProjectContextSchema = z.strictObject({
-    version: z.literal(1),
+    version: z.literal(2),
+    packageName: QualifiedNameSchema,
+    launchActivity: QualifiedNameSchema,
+    manifest: ContextManifestSchema,
+    interactionPolicy: InteractionPolicySchema,
+    modules: z.array(ContextModuleReferenceSchema).min(1)
+}).superRefine((bundle, context) => {
+    const ids = new Set();
+    const paths = new Set();
+    if (!bundle.modules.some((module) => module.kind === "application")) {
+        context.addIssue({
+            code: "custom",
+            path: ["modules"],
+            message: "Project Context needs at least one application module"
+        });
+    }
+    for (const [index, module] of bundle.modules.entries()) {
+        if (ids.has(module.id)) {
+            context.addIssue({
+                code: "custom",
+                path: ["modules", index, "id"],
+                message: "Context module ids must be unique"
+            });
+        }
+        if (paths.has(module.contextPath)) {
+            context.addIssue({
+                code: "custom",
+                path: ["modules", index, "contextPath"],
+                message: "Context module paths must be unique"
+            });
+        }
+        ids.add(module.id);
+        paths.add(module.contextPath);
+    }
+    for (const [index, module] of bundle.modules.entries()) {
+        for (const dependency of module.dependsOn) {
+            if (!ids.has(dependency)) {
+                context.addIssue({
+                    code: "custom",
+                    path: ["modules", index, "dependsOn"],
+                    message: `Unknown module dependency: ${dependency}`
+                });
+            }
+            if (dependency === module.id) {
+                context.addIssue({
+                    code: "custom",
+                    path: ["modules", index, "dependsOn"],
+                    message: "A Context module cannot depend on itself"
+                });
+            }
+        }
+    }
+});
+const ContextElementSchema = z.strictObject({
+    screen: z.string().trim().min(1),
+    resourceId: z.string().trim().min(1).optional(),
+    text: z.string().trim().min(1).optional(),
+    contentDescription: z.string().trim().min(1).optional(),
+    actions: z.array(InteractionActionSchema).min(1)
+}).refine((element) => (element.resourceId !== undefined
+    || element.text !== undefined
+    || element.contentDescription !== undefined), "A Context element needs at least one locator identity");
+const ContextActivitySummarySchema = z.strictObject({
+    name: QualifiedNameSchema,
+    entryPoints: z.array(QualifiedNameSchema),
+    screens: NonemptyUniqueStringsSchema
+});
+const ContextTransitionSchema = z.strictObject({
+    fromActivity: QualifiedNameSchema,
+    actionResourceId: z.string().trim().min(1).optional(),
+    actionText: z.string().trim().min(1).optional(),
+    toActivity: QualifiedNameSchema
+}).refine((transition) => (transition.actionResourceId !== undefined
+    || transition.actionText !== undefined), "A Context transition needs an action identity");
+const ContextLogcatCandidateSchema = z.strictObject({
+    tag: z.string().trim().min(1),
+    pattern: z.string().trim().min(1),
+    match: z.enum(["literal", "regex"])
+});
+export const ProjectContextModuleSchema = z.strictObject({
+    version: z.literal(2),
+    moduleId: z.string().trim().min(1),
+    projectDir: ProjectRelativePathSchema,
+    status: ContextShardStatusSchema,
+    inventory: z.strictObject({
+        version: z.literal(2),
+        pathSetSha256: z.string().regex(/^[a-f\d]{64}$/),
+        categories: z.array(z.enum([
+            "manifests",
+            "sources",
+            "layouts",
+            "navigation"
+        ])).min(1).superRefine((values, context) => {
+            if (new Set(values).size !== values.length) {
+                context.addIssue({
+                    code: "custom",
+                    message: "Inventory categories must be unique"
+                });
+            }
+        })
+    }),
+    manifest: ContextManifestSchema,
+    summary: z.strictObject({
+        features: NonemptyUniqueStringsSchema,
+        activities: z.array(ContextActivitySummarySchema),
+        elements: z.array(ContextElementSchema),
+        transitions: z.array(ContextTransitionSchema),
+        logcat: z.array(ContextLogcatCandidateSchema)
+    })
+});
+export const ContextSelectionSchema = z.strictObject({
+    bundleVersion: z.literal(2),
+    indexHash: z.string().regex(/^[a-f\d]{64}$/),
+    modules: z.array(z.strictObject({
+        id: z.string().trim().min(1),
+        sha256: z.string().regex(/^[a-f\d]{64}$/),
+        projectDir: ProjectRelativePathSchema,
+        inventory: z.strictObject({
+            pathSetSha256: z.string().regex(/^[a-f\d]{64}$/),
+            categories: z.array(z.enum([
+                "manifests",
+                "sources",
+                "layouts",
+                "navigation"
+            ])).min(1).superRefine((values, context) => {
+                if (new Set(values).size !== values.length) {
+                    context.addIssue({
+                        code: "custom",
+                        message: "Bound inventory categories must be unique"
+                    });
+                }
+            })
+        })
+    })).min(1).superRefine((modules, context) => {
+        const ids = new Set();
+        for (const [index, module] of modules.entries()) {
+            if (ids.has(module.id)) {
+                context.addIssue({
+                    code: "custom",
+                    path: [index, "id"],
+                    message: "Selected Context module ids must be unique"
+                });
+            }
+            ids.add(module.id);
+        }
+    })
+});
+export const ResolvedProjectContextSchema = z.strictObject({
+    version: z.literal(2),
     packageName: QualifiedNameSchema,
     launchActivity: QualifiedNameSchema,
     manifest: ContextManifestSchema,
-    interactionPolicy: InteractionPolicySchema
+    interactionPolicy: InteractionPolicySchema,
+    selection: ContextSelectionSchema
 });